* commands, and wraps the string in a element. The attributes have to be
* "fresh" in the sense that the terminal must not have changed since they were
* obtained using the vte_terminal_get* function.
*
* Returns: (transfer full): a newly allocated text string, or %NULL.
*/
GString*
Terminal::attributes_to_html(GString* text_string,
GArray* attrs)
{
GString *string;
guint from,to;
const VteCellAttr *attr;
char *escaped, *marked;
char const* text = text_string->str;
auto len = text_string->len;
g_assert_cmpuint(len, ==, attrs->len);
/* 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, "");
/* Find streches with equal attributes. Newlines are treated specially,
* so that the do not cover multiple lines.
*/
from = to = 0;
while (text[from] != '\0') {
g_assert(from == to);
if (text[from] == '\n') {
g_string_append_c(string, '\n');
from = ++to;
} else {
attr = char_to_cell_attr(
&g_array_index(attrs, VteCharAttributes, from));
while (text[to] != '\0' && text[to] != '\n' &&
vte_terminal_cellattr_equal(attr,
char_to_cell_attr(
&g_array_index(attrs, VteCharAttributes, to))))
{
to++;
}
escaped = g_markup_escape_text(text + from, to - from);
marked = cellattr_to_html(attr, escaped);
g_string_append(string, marked);
g_free(escaped);
g_free(marked);
from = to;
}
}
g_string_append(string, "");
return string;
}
/* 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. */
void
Terminal::widget_copy(vte::platform::ClipboardType type,
vte::platform::ClipboardFormat format)
{
/* Only put HTML on the CLIPBOARD, not PRIMARY */
assert(type == vte::platform::ClipboardType::CLIPBOARD ||
format == vte::platform::ClipboardFormat::TEXT);
/* Chuck old selected text and retrieve the newly-selected text. */
GArray *attributes = g_array_new(FALSE, TRUE, sizeof(struct _VteCharAttributes));
auto selection = get_selected_text(attributes);
auto const sel = vte::to_integral(type);
if (m_selection[sel]) {
g_string_free(m_selection[sel], TRUE);
m_selection[sel] = nullptr;
}
if (selection == nullptr) {
g_array_free(attributes, TRUE);
m_selection_owned[sel] = false;
return;
}
if (format == vte::platform::ClipboardFormat::HTML) {
m_selection[sel] = attributes_to_html(selection, attributes);
g_string_free(selection, TRUE);
} else {
m_selection[sel] = selection;
}
g_array_free (attributes, TRUE);
/* Place the text on the clipboard. */
_vte_debug_print(VTE_DEBUG_SELECTION,
"Assuming ownership of selection.\n");
m_selection_owned[sel] = true;
m_selection_format[sel] = format;
m_changing_selection = true;
widget()->clipboard_offer_data(type, format);
m_changing_selection = false;
}
/* Confine coordinates into the visible area. Padding is already subtracted. */
void
Terminal::confine_coordinates(long *xp,
long *yp)
{
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(),
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;
}
/* 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 gtk drag threshold.
*/
void
Terminal::start_selection (vte::view::coords const& pos,
SelectionType type)
{
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;
m_selecting_had_delta = false; /* resolve_selection() below will most likely flip it to true. */
m_will_select_after_threshold = false;
_vte_debug_print(VTE_DEBUG_SELECTION,
"Selection started at %s.\n",
m_selection_origin.to_string());
/* Take care of updating the display. */
resolve_selection();
/* Temporarily stop caring about input from the child. */
disconnect_pty_read();
}
bool
Terminal::maybe_end_selection()
{
if (m_selecting) {
/* Copy only if something was selected. */
if (!m_selection_resolved.empty() &&
m_selecting_had_delta) {
widget_copy(vte::platform::ClipboardType::PRIMARY,
vte::platform::ClipboardFormat::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;
}
/*
* Terminal::select_all:
*
* Selects all text within the terminal. Note that we only select the writable
* region, *not* the scrollback buffer, due to this potentially selecting so
* much data that putting it on the clipboard either hangs the process for a long
* time or even crash it directly. (FIXME!)
*/
void
Terminal::select_all()
{
deselect_all();
m_selecting_had_delta = TRUE;
m_selection_resolved.set({m_screen->insert_delta, 0},
{_vte_ring_next(m_screen->row_data), 0});
_vte_debug_print(VTE_DEBUG_SELECTION, "Selecting *all* text.\n");
widget_copy(vte::platform::ClipboardType::PRIMARY,
vte::platform::ClipboardFormat::TEXT);
emit_selection_changed();
invalidate_all();
}
bool
Terminal::mouse_autoscroll_timer_callback()
{
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) {
/* Try to scroll up by one line. */
adj = m_screen->scroll_delta - 1;
queue_adjustment_value_changed_clamped(adj);
extend = true;
_vte_debug_print(VTE_DEBUG_EVENTS, "Autoscrolling down.\n");
}
if (m_mouse_last_position.y >= m_view_usable_extents.height()) {
/* Try to scroll up by one line. */
adj = m_screen->scroll_delta + 1;
queue_adjustment_value_changed_clamped(adj);
extend = true;
_vte_debug_print(VTE_DEBUG_EVENTS, "Autoscrolling up.\n");
}
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);
y = CLAMP(m_mouse_last_position.y, 0, ymax);
/* 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(vte::view::coords(x, y));
} else {
/* Stop autoscrolling. */
again = false;
}
return again;
}
/* Start autoscroll. */
void
Terminal::start_autoscroll()
{
if (m_mouse_autoscroll_timer)
return;
m_mouse_autoscroll_timer.schedule(666 / m_row_count, // FIXME WTF?
vte::glib::Timer::Priority::eLOW);
}
bool
Terminal::widget_mouse_motion(vte::platform::MouseEvent const& event)
{
/* Need to ensure the ringview is updated. */
ringview_update();
auto pos = view_coords_from_event(event);
auto rowcol = grid_coords_from_view_coords(pos);
_vte_debug_print(VTE_DEBUG_EVENTS,
"Motion grid %s\n", rowcol.to_string());
m_modifiers = event.modifiers();
if (m_will_select_after_threshold) {
if (!gtk_drag_check_threshold(m_widget,
m_mouse_last_position.x,
m_mouse_last_position.y,
pos.x, pos.y))
return true;
start_selection(vte::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) {
_vte_debug_print(VTE_DEBUG_EVENTS, "Mousing drag 1.\n");
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;
}
bool
Terminal::widget_mouse_press(vte::platform::MouseEvent const& event)
{
bool handled = false;
gboolean start_selecting = FALSE, extend_selecting = FALSE;
/* Need to ensure the ringview is updated. */
ringview_update();
/* Reset IM (like GtkTextView does) here */
if (event.press_count() == 1)
widget()->im_reset();
auto pos = view_coords_from_event(event);
auto rowcol = grid_coords_from_view_coords(pos);
_vte_debug_print(VTE_DEBUG_EVENTS,
"Click gesture pressed button=%d at grid %s\n",
event.button_value(),
rowcol.to_string());
m_modifiers = event.modifiers();
switch (event.press_count()) {
case 1: /* single click */
/* Handle this event ourselves. */
switch (event.button()) {
case vte::platform::MouseEvent::Button::eLEFT:
_vte_debug_print(VTE_DEBUG_EVENTS,
"Handling click ourselves.\n");
/* Grab focus. */
if (!m_has_focus)
widget()->grab_focus();
// FIXMEchpe FIXMEgtk do im_reset() here
/* 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 & GDK_SHIFT_MASK) {
start_selecting = TRUE;
}
} else {
/* If the user hit shift, then extend the
* selection instead. */
if ((m_modifiers & GDK_SHIFT_MASK) &&
!m_selection_resolved.empty()) {
extend_selecting = TRUE;
} else {
start_selecting = TRUE;
}
}
if (start_selecting) {
deselect_all();
m_will_select_after_threshold = true;
m_selection_block_mode = !!(m_modifiers & GDK_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;
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 vte::platform::MouseEvent::Button::eMIDDLE:
if ((m_modifiers & GDK_SHIFT_MASK) ||
m_mouse_tracking_mode == MouseTrackingMode::eNONE) {
if (widget()->primary_paste_enabled()) {
widget()->clipboard_request_text(vte::platform::ClipboardType::PRIMARY);
handled = true;
}
}
break;
case vte::platform::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) {
handled = maybe_send_mouse_button(rowcol, event);
}
break;
case 2: /* double click */
switch (event.button()) {
case vte::platform::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 vte::platform::MouseEvent::Button::eMIDDLE:
case vte::platform::MouseEvent::Button::eRIGHT:
default:
break;
}
break;
case 3: /* triple click */
switch (event.button()) {
case vte::platform::MouseEvent::Button::eLEFT:
if ((m_mouse_handled_buttons & 1) != 0) {
start_selection(pos,
SelectionType::eLINE);
handled = true;
}
break;
case vte::platform::MouseEvent::Button::eMIDDLE:
case vte::platform::MouseEvent::Button::eRIGHT:
default:
break;
}
default:
break;
}
#if VTE_GTK == 4
if (!handled &&
((event.button() == vte::platform::MouseEvent::Button::eRIGHT) ||
!(event.modifiers() & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK)))) {
_vte_debug_print(VTE_DEBUG_EVENTS, "Showing context menu\n");
// FIXMEgtk4 context menu
handled = true;
}
#endif /* VTE_GTK == 4 */
/* 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;
}
bool
Terminal::widget_mouse_release(vte::platform::MouseEvent const& event)
{
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);
_vte_debug_print(VTE_DEBUG_EVENTS,
"Click gesture released button=%d at grid %s\n",
event.button_value(), rowcol.to_string());
stop_autoscroll();
m_modifiers = event.modifiers();
switch (event.type()) {
case vte::platform::EventBase::Type::eMOUSE_RELEASE:
switch (event.button()) {
case vte::platform::MouseEvent::Button::eLEFT:
if ((m_mouse_handled_buttons & 1) != 0)
handled = maybe_end_selection();
break;
case vte::platform::MouseEvent::Button::eMIDDLE:
handled = (m_mouse_handled_buttons & 2) != 0;
m_mouse_handled_buttons &= ~2;
break;
case vte::platform::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;
}
void
Terminal::widget_focus_in()
{
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;
/* 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);
}
}
void
Terminal::widget_focus_out()
{
/* 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();
}
void
Terminal::widget_mouse_enter(vte::platform::MouseEvent const& event)
{
auto pos = view_coords_from_event(event);
// FIXMEchpe read event modifiers here
// FIXMEgtk4 or maybe not since there is no event to read them from on gtk4
_vte_debug_print(VTE_DEBUG_EVENTS, "Motion enter at grid %s\n", pos.to_string());
m_mouse_cursor_over_widget = TRUE;
m_mouse_last_position = pos;
set_pointer_autohidden(false);
hyperlink_hilite_update();
match_hilite_update();
apply_mouse_cursor();
}
void
Terminal::widget_mouse_leave(vte::platform::MouseEvent const& event)
{
#if VTE_GTK == 3
auto pos = view_coords_from_event(event);
// FIXMEchpe read event modifiers here
// FIXMEgtk4 or maybe not since there is no event to read them from on gtk4
_vte_debug_print(VTE_DEBUG_EVENTS, "Motion leave at grid %s\n", pos.to_string());
m_mouse_cursor_over_widget = FALSE;
m_mouse_last_position = pos;
#elif VTE_GTK == 4
// FIXMEgtk4 !!!
m_mouse_cursor_over_widget = false;
// keep m_mouse_last_position since the event here has no position
#endif
// FIXMEchpe: also set m_mouse_scroll_delta to 0 here?
hyperlink_hilite_update();
match_hilite_update();
apply_mouse_cursor();
}
/* 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}.
*/
void
Terminal::apply_font_metrics(int cell_width_unscaled,
int cell_height_unscaled,
int cell_width,
int cell_height,
int char_ascent,
int char_descent,
GtkBorder char_spacing)
{
int char_height;
bool resize = false, cresize = false;
/* Sanity check for broken font changes. */
cell_width_unscaled = MAX(cell_width_unscaled, 1);
cell_height_unscaled = MAX(cell_height_unscaled, 2);
cell_width = MAX(cell_width, 1);
cell_height = MAX(cell_height, 2);
char_ascent = MAX(char_ascent, 1);
char_descent = MAX(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_unscaled != m_cell_width_unscaled) {
cresize = true;
m_cell_width_unscaled = cell_width_unscaled;
}
if (cell_height_unscaled != m_cell_height_unscaled) {
cresize = true;
m_cell_height_unscaled = cell_height_unscaled;
}
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(GtkBorder)) != 0) {
resize = true;
m_char_padding = char_spacing;
}
m_line_thickness = MAX (MIN (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);
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);
m_undercurl_thickness = m_line_thickness;
m_undercurl_position = MIN (char_spacing.top + char_ascent + m_line_thickness, cell_height - _vte_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()) {
#if VTE_GTK == 3
gtk_widget_queue_resize_no_redraw(m_widget);
#elif VTE_GTK == 4
gtk_widget_queue_resize(m_widget); // FIXMEgtk4?
#endif
}
}
/* 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_unscaled,
m_cell_width_unscaled);
}
if (widget())
widget()->notify_char_size_changed(m_cell_width, m_cell_height);
}
/* Repaint. */
invalidate_all();
}
void
Terminal::ensure_font()
{
{
/* Load default fonts, if no fonts have been loaded. */
if (!m_has_fonts) {
update_font_desc();
}
if (m_fontdirty) {
int cell_width_unscaled, cell_height_unscaled;
int cell_width, cell_height;
int char_ascent, char_descent;
GtkBorder char_spacing;
m_fontdirty = false;
if (!_vte_double_equal(m_font_scale, 1.)) {
m_draw.set_text_font(
m_widget,
m_unscaled_font_desc.get(),
m_cell_width_scale,
m_cell_height_scale);
m_draw.get_text_metrics(
&cell_width_unscaled, &cell_height_unscaled,
nullptr, nullptr, nullptr);
}
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);
if (_vte_double_equal(m_font_scale, 1.)) {
cell_width_unscaled = cell_width;
cell_height_unscaled = cell_height;
}
apply_font_metrics(cell_width_unscaled, cell_height_unscaled,
cell_width, cell_height,
char_ascent, char_descent,
char_spacing);
}
}
}
void
Terminal::update_font()
{
/* We'll get called again later */
if (!m_unscaled_font_desc)
return;
auto desc = vte::take_freeable(pango_font_description_copy(m_unscaled_font_desc.get()));
double size = pango_font_description_get_size(desc.get());
if (pango_font_description_get_size_is_absolute(desc.get())) {
pango_font_description_set_absolute_size(desc.get(), m_font_scale * size);
} else {
pango_font_description_set_size(desc.get(), m_font_scale * size);
}
m_fontdesc = std::move(desc);
m_fontdirty = true;
m_has_fonts = true;
/* Set the drawing font. */
if (widget_realized()) {
ensure_font();
}
}
/*
* 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 gtk_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.
*/
bool
Terminal::set_font_desc(vte::Freeable font_desc)
{
m_api_font_desc = std::move(font_desc);
return update_font_desc();
}
bool
Terminal::update_font_desc()
{
#if VTE_GTK == 3
auto desc = vte::Freeable{};
auto context = gtk_widget_get_style_context(m_widget);
gtk_style_context_save(context);
gtk_style_context_set_state (context, GTK_STATE_FLAG_NORMAL);
gtk_style_context_get(context, GTK_STATE_FLAG_NORMAL, "font",
&vte::get_freeable(desc),
nullptr);
gtk_style_context_restore(context);
#elif VTE_GTK == 4
// FIXMEgtk4
// This is how gtktextview does it, but the APIs are private... thanks, gtk4!
// desc = vte::take_freeable
// (gtk_css_style_get_pango_font(gtk_style_context_lookup_style(context));
auto context = gtk_widget_get_pango_context(m_widget);
auto context_desc = pango_context_get_font_description(context);
auto desc = vte::take_freeable(pango_font_description_copy(context_desc));
#endif /* VTE_GTK */
pango_font_description_set_family_static(desc.get(), "monospace");
if (m_api_font_desc) {
pango_font_description_merge(desc.get(), m_api_font_desc.get(), true);
_VTE_DEBUG_IF(VTE_DEBUG_MISC) {
if (desc) {
char *tmp;
tmp = pango_font_description_to_string(desc.get());
g_printerr("Using pango font \"%s\".\n", tmp);
g_free (tmp);
}
}
} else {
_vte_debug_print(VTE_DEBUG_MISC,
"Using default monospace font.\n");
}
/* Sanitise the font description.
*
* Gravity makes no sense in vte.
* Style needs to be default, and weight needs to allow bolding,
* since those are set via SGR attributes.
*
* Allowing weight <= medium does not absolutely guarantee that bold
* actually is bolder than the specified weight, but should be good enough
* until we can check that the actually loaded bold font is weightier than
* the normal font (FIXME!).
*
* As a special exception, allow any weight if bold-is-bright is enabled.
*/
pango_font_description_unset_fields(desc.get(),
PangoFontMask(PANGO_FONT_MASK_GRAVITY |
PANGO_FONT_MASK_STYLE));
auto const max_weight = 1000 - VTE_FONT_WEIGHT_BOLDENING;
if ((pango_font_description_get_set_fields(desc.get()) & PANGO_FONT_MASK_WEIGHT) &&
(pango_font_description_get_weight(desc.get()) > max_weight) &&
!m_bold_is_bright) {
pango_font_description_set_weight(desc.get(), PangoWeight(max_weight));
}
bool const same_desc = m_unscaled_font_desc &&
pango_font_description_equal(m_unscaled_font_desc.get(), desc.get());
/* 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 = std::move(desc);
update_font();
return !same_desc;
}
bool
Terminal::set_font_scale(gdouble scale)
{
/* FIXME: compare old and new scale in pixel space */
if (_vte_double_equal(scale, m_font_scale))
return false;
m_font_scale = scale;
update_font();
return true;
}
bool
Terminal::set_cell_width_scale(double scale)
{
/* FIXME: compare old and new scale in pixel space */
if (_vte_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;
}
bool
Terminal::set_cell_height_scale(double scale)
{
/* FIXME: compare old and new scale in pixel space */
if (_vte_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;
}
/* Read and refresh our perception of the size of the PTY. */
void
Terminal::refresh_size()
{
if (!pty())
return;
int rows, columns;
if (!pty()->get_size(&rows, &columns)) {
/* Error reading PTY size, use defaults */
rows = VTE_ROWS;
columns = VTE_COLUMNS;
}
if (m_row_count == rows &&
m_column_count == columns)
return;
m_row_count = rows;
m_column_count = columns;
m_tabstops.resize(columns);
}
/* Resize the given screen (normal or alternate) of the terminal. */
void
Terminal::screen_set_size(VteScreen *screen_,
long old_columns,
long old_rows,
bool do_rewrap)
{
VteRing *ring = screen_->row_data;
VteVisualPosition cursor_saved_absolute;
VteVisualPosition below_viewport;
VteVisualPosition below_current_paragraph;
VteVisualPosition selection_start, selection_end;
VteVisualPosition *markers[7];
gboolean was_scrolled_to_top = ((long) ceil(screen_->scroll_delta) == _vte_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();
_vte_debug_print(VTE_DEBUG_RESIZE,
"Resizing %s screen_\n"
"Old insert_delta=%ld scroll_delta=%f\n"
" cursor (absolute) row=%ld col=%ld\n"
" cursor_saved (relative to insert_delta) row=%ld col=%ld\n",
screen_ == &m_normal_screen ? "normal" : "alternate",
screen_->insert_delta, screen_->scroll_delta,
screen_->cursor.row, screen_->cursor.col,
screen_->saved.cursor.row, screen_->saved.cursor.col);
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 < _vte_ring_next(ring)
&& _vte_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)
_vte_ring_rewrap(ring, m_column_count, markers);
if (_vte_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 = _vte_ring_next(ring) - m_row_count;
new_top_lines = below_current_paragraph.row - screen_->insert_delta;
drop1 = _vte_ring_length(ring) - m_row_count;
drop2 = _vte_ring_next(ring) - below_current_paragraph.row;
drop3 = old_top_lines - new_top_lines;
drop = MIN(MIN(drop1, drop2), drop3);
if (drop > 0) {
int new_ring_next = screen_->insert_delta + m_row_count - drop;
_vte_debug_print(VTE_DEBUG_RESIZE,
"Dropping %ld [== MIN(%ld, %ld, %ld)] rows at the bottom\n",
drop, drop1, drop2, drop3);
_vte_ring_shrink(ring, new_ring_next - _vte_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 (_vte_ring_length(ring) <= m_row_count) {
/* Everything fits without scrollbars. Align at top. */
screen_->insert_delta = _vte_ring_delta(ring);
new_scroll_delta = screen_->insert_delta;
_vte_debug_print(VTE_DEBUG_RESIZE,
"Everything fits without scrollbars\n");
} else {
/* Scrollbar required. Can't afford unused lines at bottom. */
screen_->insert_delta = _vte_ring_next(ring) - m_row_count;
if (was_scrolled_to_bottom) {
/* Was scrolled to bottom, keep this way. */
new_scroll_delta = screen_->insert_delta;
_vte_debug_print(VTE_DEBUG_RESIZE,
"Scroll to bottom\n");
} 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 = _vte_ring_delta(ring);
_vte_debug_print(VTE_DEBUG_RESIZE,
"Scroll to top\n");
} 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);
_vte_debug_print(VTE_DEBUG_RESIZE,
"Scroll so bottom row stays\n");
}
}
/* 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;
_vte_debug_print(VTE_DEBUG_RESIZE,
"New insert_delta=%ld scroll_delta=%f\n"
" cursor (absolute) row=%ld col=%ld\n"
" cursor_saved (relative to insert_delta) row=%ld col=%ld\n\n",
screen_->insert_delta, new_scroll_delta,
screen_->cursor.row, screen_->cursor.col,
screen_->saved.cursor.row, screen_->saved.cursor.col);
if (screen_ == m_screen)
queue_adjustment_value_changed(new_scroll_delta);
else
screen_->scroll_delta = new_scroll_delta;
}
void
Terminal::set_size(long columns,
long rows)
{
glong old_columns, old_rows;
_vte_debug_print(VTE_DEBUG_RESIZE,
"Setting PTY size to %ldx%ld.\n",
columns, rows);
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_unscaled,
m_cell_width_unscaled)) {
// 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;
_vte_ring_set_visible_rows(m_normal_screen.row_data, m_row_count);
_vte_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,
_vte_ring_delta (m_screen->row_data),
MAX (_vte_ring_delta (m_screen->row_data),
_vte_ring_next (m_screen->row_data) - 1));
adjust_adjustments_full();
#if VTE_GTK == 3
gtk_widget_queue_resize_no_redraw(m_widget);
#elif VTE_GTK == 4
gtk_widget_queue_resize(m_widget); // FIXMEgtk4?
#endif
/* Our visible text changed. */
emit_text_modified();
}
}
void
Terminal::set_scroll_value(double value)
{
auto const lower = _vte_ring_delta(m_screen->row_data);
auto const upper_minus_row_count = m_screen->insert_delta;
value = std::clamp(value,
double(lower),
double(std::max(lower, upper_minus_row_count)));
/* Save the difference. */
auto const dy = value - m_screen->scroll_delta;
m_screen->scroll_delta = value;
/* Sanity checks. */
if (G_UNLIKELY(!widget_realized()))
return;
/* FIXME: do this check in pixel space */
if (!_vte_double_equal(dy, 0)) {
_vte_debug_print(VTE_DEBUG_ADJ,
"Scrolling by %f\n", dy);
invalidate_all();
match_contents_clear();
emit_text_scrolled(dy);
queue_contents_changed();
} else {
_vte_debug_print(VTE_DEBUG_ADJ, "Not scrolling\n");
}
}
Terminal::Terminal(vte::platform::Widget* w,
VteTerminal *t) :
m_real_widget(w),
m_terminal(t),
m_widget(&t->widget),
m_normal_screen(VTE_SCROLLBACK_INIT, true),
m_alternate_screen(VTE_ROWS, false),
m_screen(&m_normal_screen)
{
/* Inits allocation to 1x1 @ -1,-1 */
cairo_rectangle_int_t allocation;
gtk_widget_get_allocation(m_widget, &allocation);
set_allocated_rect(allocation);
/* 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 /* zero terminated */,
FALSE /* 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 (auto i = 0; i < VTE_PALETTE_SIZE; i++)
m_palette[i].sources[VTE_COLOR_SOURCE_ESCAPE].is_set = FALSE;
/* Dispatch unripe DCS (for now, just DECSIXEL) sequences,
* so we can switch data syntax and parse the contents with
* the SIXEL subparser.
*/
m_parser.set_dispatch_unripe(true);
/* Set up I/O encodings. */
m_outgoing = _vte_byte_array_new();
/* Setting the terminal type and size requires the PTY master to
* be set up properly first. */
set_size(VTE_COLUMNS, VTE_ROWS);
/* Default is 0, forces update in vte_terminal_set_scrollback_lines */
set_scrollback_lines(VTE_SCROLLBACK_INIT);
/* 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);
update_view_extents();
#ifdef VTE_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);
}
#endif
#ifndef WITH_GNUTLS
std::string str{"\e[1m\e[31m"};
str.append(_("WARNING"));
str.append(":\e[39m ");
str.append(_("GnuTLS not enabled; data will be written to disk unencrypted!"));
str.append("\e[0m\n\e[G");
feed(str, false);
#endif
}
void
Terminal::widget_measure_width(int *minimum_width,
int *natural_width)
{
ensure_font();
refresh_size();
*minimum_width = m_cell_width * VTE_MIN_GRID_WIDTH;
*natural_width = m_cell_width * m_column_count;
*minimum_width += m_style_padding.left + m_style_padding.right;
*natural_width += m_style_padding.left + m_style_padding.right;
_vte_debug_print(VTE_DEBUG_WIDGET_SIZE,
"[Terminal %p] minimum_width=%d, natural_width=%d for %ldx%ld cells (padding %d,%d;%d,%d).\n",
m_terminal,
*minimum_width, *natural_width,
m_column_count,
m_row_count,
m_style_padding.left, m_style_padding.right,
m_style_padding.top, m_style_padding.bottom);
}
void
Terminal::widget_measure_height(int *minimum_height,
int *natural_height)
{
ensure_font();
refresh_size();
*minimum_height = m_cell_height * VTE_MIN_GRID_HEIGHT;
*natural_height = m_cell_height * m_row_count;
*minimum_height += m_style_padding.top + m_style_padding.bottom;
*natural_height += m_style_padding.top + m_style_padding.bottom;
_vte_debug_print(VTE_DEBUG_WIDGET_SIZE,
"[Terminal %p] minimum_height=%d, natural_height=%d for %ldx%ld cells (padding %d,%d;%d,%d).\n",
m_terminal,
*minimum_height, *natural_height,
m_column_count,
m_row_count,
m_style_padding.left, m_style_padding.right,
m_style_padding.top, m_style_padding.bottom);
}
void
#if VTE_GTK == 3
Terminal::widget_size_allocate(int allocation_x,
int allocation_y,
int allocation_width,
int allocation_height,
int allocation_baseline,
Alignment xalign,
Alignment yalign)
#elif VTE_GTK == 4
Terminal::widget_size_allocate(int allocation_width,
int allocation_height,
int allocation_baseline,
Alignment xalign,
Alignment yalign)
#endif /* VTE_GTK */
{
auto width = allocation_width - (m_style_padding.left + m_style_padding.right);
auto height = allocation_height - (m_style_padding.top + m_style_padding.bottom);
auto grid_width = int(width / m_cell_width);
auto grid_height = int(height / m_cell_height);
width -= grid_width * m_cell_width;
height -= grid_height * m_cell_height;
/* assert(width >= 0); assert(height >= 0); */
/* Distribute extra space according to alignment */
auto lpad = 0, rpad = 0;
switch (xalign) {
default:
case Alignment::START_FILL:
case Alignment::START: lpad = 0; rpad = width; break;
case Alignment::CENTRE: lpad = width / 2; rpad = width - lpad; break;
case Alignment::END: lpad = width; rpad = 0; break;
}
auto tpad = 0, bpad = 0;
switch (yalign) {
default:
case Alignment::START: tpad = 0; bpad = height; break;
case Alignment::CENTRE: tpad = height / 2; bpad = height - tpad; break;
case Alignment::END: tpad = height; bpad = 0; break;
case Alignment::START_FILL: tpad = bpad = 0; break;
}
m_padding.left = m_style_padding.left + lpad;
m_padding.right = m_style_padding.right + rpad;
m_padding.top = m_style_padding.top + tpad;
m_padding.bottom = m_style_padding.bottom + bpad;
/* The minimum size returned from ::widget_measure_width/height()
* is VTE_MIN_GRID_WIDTH/HEIGHT, but let's be extra safe.
*/
grid_width = std::max(grid_width, VTE_MIN_GRID_WIDTH);
grid_height = std::max(grid_height, VTE_MIN_GRID_HEIGHT);
_vte_debug_print(VTE_DEBUG_WIDGET_SIZE,
"[Terminal %p] Sizing window to %dx%d (%dx%d, effective padding %d,%d;%d,%d).\n",
m_terminal,
allocation_width, allocation_height,
grid_width, grid_height,
m_padding.left, m_padding.right, m_padding.top, m_padding.bottom);
auto const current_allocation = get_allocated_rect();
auto const repaint = current_allocation.width != allocation_width ||
current_allocation.height != allocation_height;
/* FIXME: remove this */
auto const update_scrollback = current_allocation.height != allocation_height;
#if VTE_GTK == 3
set_allocated_rect({allocation_x, allocation_y, allocation_width, allocation_height});
#elif VTE_GTK == 4
set_allocated_rect({0, 0, allocation_width, allocation_height});
#endif
if (grid_width != m_column_count ||
grid_height != m_row_count ||
update_scrollback) {
/* Set the size of the pseudo-terminal. */
set_size(grid_width, grid_height);
/* Notify viewers that the contents have changed. */
queue_contents_changed();
}
/* Force a repaint if we were resized. */
if (widget_realized() && repaint) {
reset_update_rects();
invalidate_all();
}
}
void
Terminal::widget_unmap()
{
m_ringview.pause();
}
void
Terminal::widget_unrealize()
{
/* Deallocate the cursors. */
m_mouse_cursor_over_widget = FALSE;
match_hilite_clear();
m_im_preedit_active = FALSE;
/* 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;
m_cursor_moved_pending = FALSE;
m_text_modified_flag = FALSE;
m_text_inserted_flag = FALSE;
m_text_deleted_flag = FALSE;
/* Clear modifiers. */
m_modifiers = 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 (auto sel_type : {vte::platform::ClipboardType::CLIPBOARD,
vte::platform::ClipboardType::PRIMARY}) {
auto const sel = vte::to_integral(sel_type);
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 HTML format
widget()->clipboard_set_text(sel_type,
{m_selection[sel]->str,
m_selection[sel]->len});
}
g_string_free(m_selection[sel], TRUE);
m_selection[sel] = nullptr;
}
}
}
void
Terminal::set_blink_settings(bool blink,
int blink_time,
int blink_timeout) noexcept
{
m_cursor_blinks = m_cursor_blinks_system = blink;
m_cursor_blink_cycle = std::max(blink_time / 2, VTE_MIN_CURSOR_BLINK_CYCLE);
m_cursor_blink_timeout = std::max(blink_timeout, VTE_MIN_CURSOR_BLINK_TIMEOUT);
update_cursor_blinks();
/* Misuse gtk-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();
}
}
Terminal::~Terminal()
{
/* Make sure not to change selection while in destruction. See issue vte#89. */
m_changing_selection = true;
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) {
g_array_free(m_match_attributes, TRUE);
}
g_free(m_match_contents);
if (m_search_attrs)
g_array_free (m_search_attrs, TRUE);
/* Disconnect from autoscroll requests. */
stop_autoscroll();
/* Cancel pending adjustment change notifications. */
m_adjustment_changed_pending = false;
/* Stop listening for child-exited signals. */
if (m_reaper) {
g_signal_handlers_disconnect_by_func(m_reaper,
(gpointer)reaper_child_exited_cb,
this);
g_object_unref(m_reaper);
}
/* Discard any pending data. */
_vte_byte_array_free(m_outgoing);
m_outgoing = nullptr;
/* Update rects */
g_array_free(m_update_rects, TRUE /* free segment */);
}
void
Terminal::widget_realize()
{
m_mouse_cursor_over_widget = FALSE; /* We'll receive an enter_notify_event if the window appears under the cursor. */
m_im_preedit_active = FALSE;
/* Clear modifiers. */
m_modifiers = 0;
// Create the font cache
ensure_font();
}
// FIXMEchpe probably @attr should be passed by ref
void
Terminal::determine_colors(VteCellAttr const* attr,
bool is_selected,
bool is_cursor,
guint *pfore,
guint *pback,
guint *pdeco) const
{
guint fore, back, deco;
g_assert(attr);
/* Start with cell colors */
vte_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())) {
if (fore == VTE_DEFAULT_FG)
fore = VTE_DEFAULT_BG;
if (back == VTE_DEFAULT_BG)
back = VTE_DEFAULT_FG;
}
/* Handle bold by using set bold color or brightening */
if (attr->bold()) {
if (fore == VTE_DEFAULT_FG && get_color(VTE_BOLD_FG) != NULL) {
fore = VTE_BOLD_FG;
} else if (m_bold_is_bright &&
fore >= VTE_LEGACY_COLORS_OFFSET &&
fore < VTE_LEGACY_COLORS_OFFSET + VTE_LEGACY_COLOR_SET_SIZE) {
fore += VTE_COLOR_BRIGHT_OFFSET;
}
}
/* 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 & VTE_RGB_COLOR_MASK(8, 8, 8))) {
fore |= VTE_DIM_COLOR;
}
/* Reverse cell? */
if (attr->reverse()) {
using std::swap;
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(VTE_HIGHLIGHT_BG) != NULL) {
back = VTE_HIGHLIGHT_BG;
do_swap = false;
}
if (get_color(VTE_HIGHLIGHT_FG) != NULL) {
fore = VTE_HIGHLIGHT_FG;
do_swap = false;
}
if (do_swap) {
using std::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(VTE_CURSOR_BG) != NULL) {
back = VTE_CURSOR_BG;
do_swap = false;
}
if (get_color(VTE_CURSOR_FG) != NULL) {
fore = VTE_CURSOR_FG;
do_swap = false;
}
if (do_swap) {
using std::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 = VTE_DEFAULT_FG;
}
*pfore = fore;
*pback = back;
*pdeco = deco;
}
void
Terminal::determine_colors(VteCell const* cell,
bool highlight,
guint *fore,
guint *back,
guint *deco) const
{
determine_colors(cell ? &cell->attr : &basic_cell.attr,
highlight, false /* not cursor */,
fore, back, deco);
}
void
Terminal::determine_cursor_colors(VteCell const* cell,
bool highlight,
guint *fore,
guint *back,
guint *deco) const
{
determine_colors(cell ? &cell->attr : &basic_cell.attr,
highlight, true /* cursor */,
fore, back, deco);
}
void
Terminal::resolve_normal_colors(VteCell const* cell,
unsigned* pfore,
unsigned* pback,
vte::color::rgb& fg,
vte::color::rgb& bg)
{
auto deco = unsigned{};
determine_colors(cell, false, pfore, pback, &deco);
rgb_from_index<8, 8, 8>(*pfore, fg);
rgb_from_index<8, 8, 8>(*pback, bg);
}
// FIXMEchpe this constantly removes and reschedules the timer. improve this!
bool
Terminal::text_blink_timer_callback()
{
invalidate_all();
return false; /* don't run again */
}
/* Draw a string of characters with similar attributes. */
void
Terminal::draw_cells(vte::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)
{
int i, xl, xr, y;
gint columns = 0;
vte::color::rgb fg, bg, dc;
g_assert(n > 0);
#if 0
_VTE_DEBUG_IF(VTE_DEBUG_CELLS) {
GString *str = g_string_new (NULL);
gchar *tmp;
for (i = 0; i < n; i++) {
g_string_append_unichar (str, items[i].c);
}
tmp = g_string_free (str, FALSE);
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);
}
#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 == VTE_DEFAULT_FG)
dc = fg;
else
rgb_from_index<4, 5, 4>(deco, dc);
#ifndef WITH_SIXEL
if (clear && (draw_default_bg || back != VTE_DEFAULT_BG)) {
#else
{
#endif
/* 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)) {
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 */
}
}
#ifdef WITH_SIXEL
if (back == VTE_DEFAULT_BG) {
/* Clear cells in order to properly overdraw images */
m_draw.clear(xl,
y,
xr - xl, row_height,
get_color(VTE_DEFAULT_BG), m_background_alpha);
}
if (clear && (draw_default_bg || back != VTE_DEFAULT_BG)) {
#else
{
#endif
m_draw.fill_rectangle(
xl,
y,
xr - xl, row_height,
&bg, VTE_DRAW_OPAQUE);
}
}
}
if (attr & VTE_ATTR_BLINK) {
/* 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 & (VTE_ATTR_UNDERLINE_MASK |
VTE_ATTR_STRIKETHROUGH_MASK |
VTE_ATTR_OVERLINE_MASK |
VTE_ATTR_BOXED_MASK)) |
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)) {
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 (vte_attr_get_value(attr, VTE_ATTR_UNDERLINE_VALUE_MASK, VTE_ATTR_UNDERLINE_SHIFT)) {
case 1:
m_draw.draw_line(
xl,
y + m_underline_position,
xr - 1,
y + m_underline_position + m_underline_thickness - 1,
VTE_LINE_WIDTH,
&dc, VTE_DRAW_OPAQUE);
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,
VTE_LINE_WIDTH,
&dc, VTE_DRAW_OPAQUE);
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,
VTE_LINE_WIDTH,
&dc, VTE_DRAW_OPAQUE);
break;
case 3:
m_draw.draw_undercurl(
xl,
y + m_undercurl_position,
m_undercurl_thickness,
columns,
&dc, VTE_DRAW_OPAQUE);
break;
}
if (attr & VTE_ATTR_STRIKETHROUGH) {
m_draw.draw_line(
xl,
y + m_strikethrough_position,
xr - 1,
y + m_strikethrough_position + m_strikethrough_thickness - 1,
VTE_LINE_WIDTH,
&fg, VTE_DRAW_OPAQUE);
}
if (attr & VTE_ATTR_OVERLINE) {
m_draw.draw_line(
xl,
y + m_overline_position,
xr - 1,
y + m_overline_position + m_overline_thickness - 1,
VTE_LINE_WIDTH,
&fg, VTE_DRAW_OPAQUE);
}
if (hilite) {
m_draw.draw_line(
xl,
y + m_regex_underline_position,
xr - 1,
y + m_regex_underline_position + m_regex_underline_thickness - 1,
VTE_LINE_WIDTH,
&fg, VTE_DRAW_OPAQUE);
} 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),
m_regex_underline_thickness,
&fg, VTE_DRAW_OPAQUE);
}
}
if (attr & VTE_ATTR_BOXED) {
m_draw.draw_rectangle(
xl,
y,
xr - xl,
row_height,
&fg, VTE_DRAW_OPAQUE);
}
}
}
m_draw.draw_text(
items, n,
attr,
&fg, VTE_DRAW_OPAQUE);
}
/* FIXME: we don't have a way to tell GTK+ 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. */
void
Terminal::fudge_pango_colors(GSList *attributes,
VteCell *cells,
gsize n)
{
gsize i, sumlen = 0;
struct _fudge_cell_props{
gboolean saw_fg, saw_bg;
vte::color::rgb fg, bg;
guint index;
}*props = g_newa (struct _fudge_cell_props, n);
for (i = 0; i < n; i++) {
gchar ubuf[7];
gint len = g_unichar_to_utf8 (cells[i].c, ubuf);
props[i].index = sumlen;
props[i].saw_fg = props[i].saw_bg = FALSE;
sumlen += len;
}
while (attributes != 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;
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;
color = (PangoAttrColor*) attr;
props[i].bg = color->color;
}
break;
default:
break;
}
attributes = g_slist_next(attributes);
}
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);
}
}
}
/* Apply the attribute given in the PangoAttribute to the list of cells. */
void
Terminal::apply_pango_attr(PangoAttribute *attr,
VteCell *cells,
gsize n_cells)
{
guint i, ival;
PangoAttrInt *attrint;
PangoAttrColor *attrcolor;
switch (attr->klass->type) {
case PANGO_ATTR_FOREGROUND:
case PANGO_ATTR_BACKGROUND:
attrcolor = (PangoAttrColor*) attr;
ival = VTE_RGB_COLOR(8, 8, 8,
((attrcolor->color.red & 0xFF00) >> 8),
((attrcolor->color.green & 0xFF00) >> 8),
((attrcolor->color.blue & 0xFF00) >> 8));
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 = VTE_RGB_COLOR(4, 5, 4,
((attrcolor->color.red & 0xFF00) >> 8),
((attrcolor->color.green & 0xFF00) >> 8),
((attrcolor->color.blue & 0xFF00) >> 8));
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);
}
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;
}
}
/* 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. */
void
Terminal::translate_pango_cells(PangoAttrList *attrs,
VteCell *cells,
gsize n_cells)
{
PangoAttribute *attr;
PangoAttrIterator *attriter;
GSList *list, *listiter;
guint i;
for (i = 0; i < n_cells; i++) {
cells[i] = m_color_defaults;
}
attriter = pango_attr_list_get_iterator(attrs);
if (attriter != NULL) {
do {
list = pango_attr_iterator_get_attrs(attriter);
if (list != NULL) {
for (listiter = list;
listiter != NULL;
listiter = g_slist_next(listiter)) {
attr = (PangoAttribute *)listiter->data;
apply_pango_attr(attr, cells, n_cells);
}
attr = (PangoAttribute *)list->data;
fudge_pango_colors(
list,
cells +
attr->start_index,
MIN(n_cells, attr->end_index) -
attr->start_index);
g_slist_free_full(list, (GDestroyNotify)pango_attribute_destroy);
}
} while (pango_attr_iterator_next(attriter) == TRUE);
pango_attr_iterator_destroy(attriter);
}
}
/* 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. */
void
Terminal::draw_cells_with_attributes(vte::view::DrawingContext::TextRequest* items,
gssize n,
PangoAttrList *attrs,
bool draw_default_bg,
gint column_width,
gint height)
{
int i, j, cell_count;
VteCell *cells;
char scratch_buf[VTE_UTF8_BPC];
guint fore, back, deco;
/* Note: since this function is only called with the pre-edit text,
* all the items contain gunichar only, not vteunistr. */
// FIXMEchpe is that really true for all input methods?
uint32_t const attr_mask = m_allow_bold ? ~0 : ~VTE_ATTR_BOLD_MASK;
for (i = 0, cell_count = 0; i < n; i++) {
cell_count += g_unichar_to_utf8(items[i].c, scratch_buf);
}
cells = g_new(VteCell, cell_count);
translate_pango_cells(attrs, cells, cell_count);
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, draw_default_bg,
cells[j].attr.attr & attr_mask,
m_allow_hyperlink && cells[j].attr.hyperlink_idx != 0,
FALSE, column_width, height);
j += g_unichar_to_utf8(items[i].c, scratch_buf);
}
g_free(cells);
}
void
Terminal::ringview_update()
{
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 ();
}
/* 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. */
void
Terminal::draw_rows(VteScreen *screen_,
cairo_region_t const* region,
vte::grid::row_t start_row,
vte::grid::row_t end_row,
gint start_y, /* must be the start of a row */
gint column_width,
gint row_height)
{
vte::grid::row_t row;
vte::grid::column_t i, j, lcol, vcol;
int y;
guint fore = VTE_DEFAULT_FG, nfore, back = VTE_DEFAULT_BG, nback, deco = VTE_DEFAULT_FG, ndeco;
gboolean hyperlink = FALSE, nhyperlink; /* non-hovered explicit hyperlink, needs dashed underlining */
gboolean hilite = FALSE, nhilite; /* hovered explicit hyperlink or regex match, needs continuous underlining */
gboolean selected;
gboolean nrtl = FALSE, rtl; /* for debugging */
uint32_t attr = 0, nattr;
guint item_count;
const VteCell *cell;
VteRowData const* row_data;
vte::base::BidiRow const* bidirow;
auto const column_count = m_column_count;
uint32_t const attr_mask = m_allow_bold ? ~0 : ~VTE_ATTR_BOLD_MASK;
/* Need to ensure the ringview is updated. */
ringview_update();
auto items = g_newa(vte::view::DrawingContext::TextRequest, 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);
_VTE_DEBUG_IF (VTE_DEBUG_BIDI) {
/* Debug: Highlight the paddings of RTL rows with a slightly different background. */
if (bidirow->base_is_rtl()) {
vte::color::rgb bg;
rgb_from_index<8, 8, 8>(VTE_DEFAULT_BG, 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, VTE_DRAW_OPAQUE);
m_draw.fill_rectangle(
column_count * column_width,
y,
rect_width - m_padding.left - column_count * column_width,
row_height,
&bg, VTE_DRAW_OPAQUE);
}
}
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 ? _vte_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 ? _vte_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 || (_vte_debug_on (VTE_DEBUG_BIDI) && nrtl != rtl)) {
break;
}
}
if (back != VTE_DEFAULT_BG) {
vte::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, VTE_DRAW_OPAQUE);
}
_VTE_DEBUG_IF (VTE_DEBUG_BIDI) {
/* Debug: Highlight RTL letters and RTL rows with a slightly different background. */
vte::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, VTE_DRAW_OPAQUE);
m_draw.fill_rectangle(
i * column_width,
y2,
(j - i) * column_width,
y + row_height - y2,
&bg, VTE_DRAW_OPAQUE);
}
/* 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, VTE_DRAW_OPAQUE);
}
}
/* 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)
continue; /* Skip row. */
/* Ensure that drawing is restricted to the cell (plus the overdraw area) */
_vte_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 = _vte_row_data_get (row_data, lcol);
g_assert(cell != nullptr);
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 ||
#ifndef WITH_SIXEL
((cell->c == ' ' || cell->c == '\t') && // FIXME '\t' is newly added now, double check
cell->attr.has_none(VTE_ATTR_UNDERLINE_MASK |
VTE_ATTR_STRIKETHROUGH_MASK |
VTE_ATTR_OVERLINE_MASK) &&
!nhyperlink &&
!nhilite) ||
#endif
cell->attr.fragment() ||
cell->attr.invisible()) {
/* Skip empty or fragment cell, but erase on ' ' and '\t', since
* it may be overwriting an image. */
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) & (VTE_ATTR_BOLD_MASK |
VTE_ATTR_ITALIC_MASK |
VTE_ATTR_UNDERLINE_MASK |
VTE_ATTR_STRIKETHROUGH_MASK |
VTE_ATTR_OVERLINE_MASK |
VTE_ATTR_BLINK_MASK |
VTE_ATTR_INVISIBLE_MASK)) || // 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, FALSE,
attr & attr_mask,
hyperlink, hilite,
column_width, row_height);
item_count = 0;
}
/* Combine with subsequent spacing marks. */
vteunistr c = cell->c;
j = lcol + cell->attr.columns();
if (G_UNLIKELY (lcol == 0 && g_unichar_ismark (_vte_unistr_get_base (cell->c)))) {
/* 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 = _vte_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 = _vte_row_data_get (row_data, j);
if (cell && !cell->attr.fragment() && g_unichar_ismark (_vte_unistr_get_base (cell->c))) {
c = _vte_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);
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 & VTE_BIDI_FLAG_BOX_MIRROR);
item_count++;
g_assert_cmpint (j, >, lcol);
lcol = j;
}
/* Draw the last run of cells in the row. */
if (item_count > 0) {
draw_cells(items, item_count,
fore, back, deco, FALSE, FALSE,
attr & attr_mask,
hyperlink, hilite,
column_width, row_height);
}
}
}
void
Terminal::paint_cursor()
{
vte::view::DrawingContext::TextRequest item;
vte::grid::row_t drow;
vte::grid::column_t lcol, vcol;
int width, height, cursor_width;
guint fore, back, deco;
vte::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)
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. */
VteRowData const *row_data = find_row_data(drow);
vte::base::BidiRow const *bidirow = m_ringview.get_bidirow(drow);
auto cell = find_charcell(lcol, drow);
while (cell != 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 & VTE_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, VTE_LINE_WIDTH, m_cell_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, VTE_DRAW_OPAQUE);
/* 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, VTE_DRAW_OPAQUE);
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, VTE_LINE_WIDTH, m_char_ascent + m_char_descent);
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);
right = MAX(right, r);
}
m_draw.fill_rectangle(
x + left, y + m_cell_height - m_char_padding.bottom - line_height,
right - left, line_height,
&bg, VTE_DRAW_OPAQUE);
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);
}
uint32_t const attr_mask = m_allow_bold ? ~0 : ~VTE_ATTR_BOLD_MASK;
if (focus) {
/* just reverse the character under the cursor */
m_draw.fill_rectangle(
x, y,
cursor_width, height,
&bg, VTE_DRAW_OPAQUE);
if (cell && cell->c != 0 && cell->c != ' ' && cell->c != '\t') {
draw_cells(
&item, 1,
fore, back, deco, TRUE, FALSE,
cell->attr.attr & attr_mask,
m_allow_hyperlink && cell->attr.hyperlink_idx != 0,
FALSE,
width,
height);
}
} else {
/* draw a box around the character */
m_draw.draw_rectangle(
x - VTE_LINE_WIDTH,
y - VTE_LINE_WIDTH,
cursor_width + 2*VTE_LINE_WIDTH,
height + 2*VTE_LINE_WIDTH,
&bg, VTE_DRAW_OPAQUE);
}
break;
}
}
void
Terminal::paint_im_preedit_string()
{
int vcol, columns;
long row;
long width, height;
int i, len;
if (m_im_preedit.empty())
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())
return;
vte::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) {
vcol = MAX(0, m_column_count - columns);
}
/* Draw the preedit string, boxed. */
if (len > 0) {
const char *preedit = m_im_preedit.c_str();
int preedit_cursor;
auto items = g_new0(vte::view::DrawingContext::TextRequest, len);
for (i = columns = 0; i < len; i++) {
items[i].c = g_utf8_get_char(preedit);
items[i].columns = _vte_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);
}
if (G_LIKELY(m_clear_background)) {
m_draw.clear(
vcol * width,
row_to_pixel(m_screen->cursor.row),
width * columns,
height,
get_color(VTE_DEFAULT_BG), m_background_alpha);
}
draw_cells_with_attributes(
items, len,
m_im_preedit_attrs.get(),
TRUE,
width, height);
preedit_cursor = m_im_preedit_cursor;
if (preedit_cursor >= 0 && preedit_cursor < len) {
uint32_t fore, back, deco;
vte_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, /* clear */
TRUE, /* draw_default_bg */
VTE_ATTR_NONE | VTE_ATTR_BOXED,
FALSE, /* hyperlink */
FALSE, /* hilite */
width, height);
}
g_free(items);
}
}
#if VTE_GTK == 3
void
Terminal::widget_draw(cairo_t* cr)
{
#ifdef VTE_DEBUG
_VTE_DEBUG_IF(VTE_DEBUG_LIFECYCLE | VTE_DEBUG_WORK | VTE_DEBUG_UPDATES) do {
auto clip_rect = cairo_rectangle_int_t{};
if (!gdk_cairo_get_clip_rectangle (cr, &clip_rect))
break;
_vte_debug_print(VTE_DEBUG_LIFECYCLE, "vte_terminal_draw()\n");
_vte_debug_print (VTE_DEBUG_WORK, "+");
_vte_debug_print (VTE_DEBUG_UPDATES, "Draw (%d,%d)x(%d,%d)\n",
clip_rect.x, clip_rect.y,
clip_rect.width, clip_rect.height);
} while (0);
#endif /* VTE_DEBUG */
auto region = vte_cairo_get_clip_region(cr);
if (!region)
return;
/* Transform to view coordinates */
cairo_region_translate(region.get(), -m_padding.left, -m_padding.top);
draw(cr, region.get());
}
#endif /* VTE_GTK == 3 */
void
Terminal::draw(cairo_t* cr,
cairo_region_t const* region)
{
int allocated_width, allocated_height;
int extra_area_for_cursor;
bool text_blink_enabled_now;
#ifdef WITH_SIXEL
VteRing *ring = m_screen->row_data;
#endif
gint64 now = 0;
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)) {
m_draw.clear(0, 0,
allocated_width, allocated_height,
get_color(VTE_DEFAULT_BG), 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);
#ifdef WITH_SIXEL
/* Draw images */
if (m_images_enabled) {
vte::grid::row_t top_row = first_displayed_row();
vte::grid::row_t bottom_row = last_displayed_row();
auto const& image_map = ring->image_map();
auto const image_map_end = image_map.end();
for (auto it = image_map.begin(); it != image_map_end; ++it) {
auto const& image = it->second;
if (image->get_bottom() < top_row ||
image->get_top() > bottom_row)
continue;
auto const x = image->get_left () * m_cell_width;
auto const y = (image->get_top () - m_screen->scroll_delta) * m_cell_height;
/* Clear cell extent; image may be slightly smaller */
m_draw.clear(x, y, image->get_width() * m_cell_width,
image->get_height() * m_cell_height,
get_color(VTE_DEFAULT_BG), m_background_alpha);
image->paint(cr, x, y, m_cell_width, m_cell_height);
}
}
#endif /* WITH_SIXEL */
/* 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);
if (text_blink_enabled_now) {
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();
cairo_restore(cr);
/* Re-clip, allowing VTE_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) ? VTE_LINE_WIDTH : 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);
/* 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))
m_text_blink_timer.schedule(m_text_blink_cycle - now % m_text_blink_cycle,
vte::glib::Timer::Priority::eLOW);
m_invalidated_all = FALSE;
}
#if VTE_GTK == 3
/* Handle an expose event by painting the exposed area. */
static vte::Freeable
vte_cairo_get_clip_region(cairo_t *cr)
{
auto list = vte::take_freeable(cairo_copy_clip_rectangle_list(cr));
if (list->status == CAIRO_STATUS_CLIP_NOT_REPRESENTABLE) {
auto clip_rect = cairo_rectangle_int_t{};
if (!gdk_cairo_get_clip_rectangle(cr, &clip_rect))
return nullptr;
return vte::take_freeable(cairo_region_create_rectangle(&clip_rect));
}
auto region = vte::take_freeable(cairo_region_create());
for (auto i = list->num_rectangles - 1; i >= 0; --i) {
auto 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.get(), &clip_rect) != CAIRO_STATUS_SUCCESS) {
region.reset();
break;
}
}
return region;
}
#endif /* VTE_GTK == 3 */
bool
Terminal::widget_mouse_scroll(vte::platform::ScrollEvent const& event)
{
gdouble v;
gint cnt, i;
int button;
/* Need to ensure the ringview is updated. */
ringview_update();
m_modifiers = event.modifiers();
m_mouse_smooth_scroll_delta += event.dy();
/* 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;
_vte_debug_print(VTE_DEBUG_EVENTS,
"Scroll application by %d lines, smooth scroll delta set back to %f\n",
cnt, m_mouse_smooth_scroll_delta);
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(grid_coords_from_view_coords(m_mouse_last_position),
button,
false /* not drag */,
false /* not release */);
}
return true;
}
v = MAX (1., ceil (m_row_count /* page increment */ / 10.));
_vte_debug_print(VTE_DEBUG_EVENTS,
"Scroll speed is %d lines per non-smooth scroll unit\n",
(int) v);
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;
_vte_debug_print(VTE_DEBUG_EVENTS,
"Scroll by %d lines, smooth scroll delta set back to %f\n",
cnt, m_mouse_smooth_scroll_delta);
/* In the alternate screen there is no scrolling,
* so fake a few cursor keystrokes. */
_vte_keymap_map (
cnt > 0 ? GDK_KEY_Down : GDK_KEY_Up,
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 if (m_fallback_scrolling) {
/* 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 false;
}
bool
Terminal::set_audible_bell(bool setting)
{
if (setting == m_audible_bell)
return false;
m_audible_bell = setting;
return true;
}
bool
Terminal::set_text_blink_mode(TextBlinkMode setting)
{
if (setting == m_text_blink_mode)
return false;
m_text_blink_mode = setting;
invalidate_all();
return true;
}
bool
Terminal::set_enable_bidi(bool setting)
{
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;
}
bool
Terminal::set_enable_shaping(bool setting)
{
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;
}
bool
Terminal::set_allow_bold(bool setting)
{
if (setting == m_allow_bold)
return false;
m_allow_bold = setting;
invalidate_all();
return true;
}
bool
Terminal::set_bold_is_bright(bool setting)
{
if (setting == m_bold_is_bright)
return false;
m_bold_is_bright = setting;
/* Need to re-sanitise the font description to ensure bold is distinct. */
update_font_desc();
invalidate_all();
return true;
}
bool
Terminal::set_allow_hyperlink(bool setting)
{
if (setting == m_allow_hyperlink)
return false;
if (setting == false) {
m_hyperlink_hover_idx = _vte_ring_get_hyperlink_at_position(m_screen->row_data, -1, -1, true, NULL);
g_assert (m_hyperlink_hover_idx == 0);
m_hyperlink_hover_uri = NULL;
emit_hyperlink_hover_uri_changed(NULL); /* FIXME only emit if really changed */
m_defaults.attr.hyperlink_idx = _vte_ring_get_hyperlink_idx(m_screen->row_data, NULL);
g_assert (m_defaults.attr.hyperlink_idx == 0);
}
m_allow_hyperlink = setting;
invalidate_all();
return true;
}
bool
Terminal::set_fallback_scrolling(bool set)
{
if (set == m_fallback_scrolling)
return false;
m_fallback_scrolling = set;
return true;
}
bool
Terminal::set_scroll_on_output(bool scroll)
{
if (scroll == m_scroll_on_output)
return false;
m_scroll_on_output = scroll;
return true;
}
bool
Terminal::set_scroll_on_keystroke(bool scroll)
{
if (scroll == m_scroll_on_keystroke)
return false;
m_scroll_on_keystroke = scroll;
return true;
}
bool
Terminal::set_rewrap_on_resize(bool rewrap)
{
if (rewrap == m_rewrap_on_resize)
return false;
m_rewrap_on_resize = rewrap;
return true;
}
void
Terminal::update_cursor_blinks()
{
auto blink = false;
switch (decscusr_cursor_blink()) {
case CursorBlinkMode::eSYSTEM:
blink = m_cursor_blinks_system;
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();
}
bool
Terminal::set_cursor_blink_mode(CursorBlinkMode mode)
{
if (mode == m_cursor_blink_mode)
return false;
m_cursor_blink_mode = mode;
update_cursor_blinks();
return true;
}
bool
Terminal::set_cursor_shape(CursorShape shape)
{
if (shape == m_cursor_shape)
return false;
m_cursor_shape = shape;
invalidate_cursor_once();
return true;
}
/* DECSCUSR set cursor style */
bool
Terminal::set_cursor_style(CursorStyle style)
{
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;
}
/*
* 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
*/
Terminal::CursorBlinkMode
Terminal::decscusr_cursor_blink() const noexcept
{
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;
}
}
/*
* Terminal::decscusr_cursor_shape:
* @terminal: a #VteTerminal
*
* 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
*/
Terminal::CursorShape
Terminal::decscusr_cursor_shape() const noexcept
{
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;
}
}
bool
Terminal::set_scrollback_lines(long lines)
{
glong low, high, next;
double scroll_delta;
VteScreen *scrn;
if (lines < 0)
lines = G_MAXLONG;
#if 0
/* FIXME: this breaks the scrollbar range, bug #562511 */
if (lines == m_scrollback_lines)
return false;
#endif
_vte_debug_print (VTE_DEBUG_MISC,
"Setting scrollback lines to %ld\n", lines);
m_scrollback_lines = lines;
/* The main screen gets the full scrollback buffer. */
scrn = &m_normal_screen;
lines = MAX (lines, m_row_count);
next = MAX (m_screen->cursor.row + 1,
_vte_ring_next (scrn->row_data));
_vte_ring_resize (scrn->row_data, lines);
low = _vte_ring_delta (scrn->row_data);
high = lines + MIN (G_MAXLONG - lines, low - m_row_count + 1);
scrn->insert_delta = CLAMP (scrn->insert_delta, low, high);
scrn->scroll_delta = CLAMP (scrn->scroll_delta, low, scrn->insert_delta);
next = MIN (next, scrn->insert_delta + m_row_count);
if (_vte_ring_next (scrn->row_data) > next){
_vte_ring_shrink (scrn->row_data, next - low);
}
/* The alternate scrn isn't allowed to scroll at all. */
scrn = &m_alternate_screen;
_vte_ring_resize (scrn->row_data, m_row_count);
scrn->scroll_delta = _vte_ring_delta (scrn->row_data);
scrn->insert_delta = _vte_ring_delta (scrn->row_data);
if (_vte_ring_next (scrn->row_data) > scrn->insert_delta + m_row_count){
_vte_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
vte_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;
}
bool
Terminal::set_backspace_binding(EraseMode binding)
{
if (binding == m_backspace_binding)
return false;
m_backspace_binding = binding;
return true;
}
bool
Terminal::set_delete_binding(EraseMode binding)
{
if (binding == m_delete_binding)
return false;
m_delete_binding = binding;
return true;
}
bool
Terminal::set_mouse_autohide(bool autohide)
{
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;
}
void
Terminal::reset_decoder()
{
switch (primary_data_syntax()) {
case DataSyntax::ECMA48_UTF8:
m_utf8_decoder.reset();
break;
#ifdef WITH_ICU
case DataSyntax::ECMA48_PCTERM:
m_converter->decoder().reset();
break;
#endif
default:
g_assert_not_reached();
}
}
void
Terminal::reset_data_syntax()
{
if (current_data_syntax() == primary_data_syntax())
return;
switch (current_data_syntax()) {
#ifdef WITH_SIXEL
case DataSyntax::DECSIXEL:
m_sixel_context->reset();
break;
#endif
default:
break;
}
pop_data_syntax();
}
void
Terminal::reset_graphics_color_registers()
{
#ifdef WITH_SIXEL
if (m_sixel_context)
m_sixel_context->reset_colors();
#endif
}
/*
* 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.
*
*/
void
Terminal::reset(bool clear_tabstops,
bool clear_history,
bool from_api)
{
if (from_api && !m_input_enabled)
return;
auto const freezer = vte::glib::FreezeObjectNotify{m_terminal};
m_bell_pending = false;
/* Clear the output buffer. */
_vte_byte_array_clear(m_outgoing);
/* Reset charset substitution state. */
/* Reset decoder */
reset_decoder();
/* Reset parser */
reset_data_syntax();
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[VTE_COLOR_SOURCE_ESCAPE].is_set = FALSE;
/* 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] = VTE_CHARACTER_REPLACEMENT_NONE;
m_character_replacements[1] = VTE_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 =
_vte_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 =
_vte_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
vte_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;
/* 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;
m_selecting_had_delta = FALSE;
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 = vte::view::coords(-1, -1);
m_mouse_smooth_scroll_delta = 0.;
/* Clear modifiers. */
m_modifiers = 0;
#ifdef WITH_SIXEL
if (m_sixel_context)
m_sixel_context->reset_colors();
#endif
/* Reset the saved cursor. */
save_cursor(&m_normal_screen);
save_cursor(&m_alternate_screen);
/* BiDi */
m_bidi_rtl = FALSE;
/* Cause everything to be redrawn (or cleared). */
invalidate_all();
/* Reset XTerm window controls */
m_xterm_wm_iconified = false;
/* When not using private colour registers, we should
* clear (assign to black) all SIXEL colour registers.
* (DEC PPLV2 § 5.8)
*/
reset_graphics_color_registers();
}
void
Terminal::unset_pty(bool notify_widget)
{
/* 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 = {};
_vte_byte_array_clear(m_outgoing);
stop_processing(this); // FIXMEchpe only if m_incoming_queue.empty() !!!
reset_decoder();
m_pty.reset();
if (notify_widget && widget())
widget()->unset_pty();
}
bool
Terminal::set_pty(vte::base::Pty *new_pty)
{
if (pty().get() == new_pty)
return false;
if (pty()) {
unset_pty(false /* don't notify widget */);
}
m_pty = vte::base::make_ref(new_pty);
if (!new_pty)
return true;
set_size(m_column_count, m_row_count);
if (!pty()->set_utf8(primary_data_syntax() == DataSyntax::ECMA48_UTF8)) {
// nothing we can do here
}
/* Open channels to listen for input on. */
connect_pty_read();
return true;
}
bool
Terminal::terminate_child() noexcept
{
if (m_pty_pid == -1)
return false;
auto pgrp = getpgid(m_pty_pid);
if (pgrp != -1 && pgrp != getpgid(getpid())) {
kill(-pgrp, SIGHUP);
}
kill(m_pty_pid, SIGHUP);
m_pty_pid = -1;
return true;
}
void
Terminal::select_text(vte::grid::column_t start_col,
vte::grid::row_t start_row,
vte::grid::column_t end_col,
vte::grid::row_t end_row)
{
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(vte::platform::ClipboardType::PRIMARY,
vte::platform::ClipboardFormat::TEXT);
emit_selection_changed();
invalidate_rows(start_row, end_row);
}
void
Terminal::select_empty(vte::grid::column_t col,
vte::grid::row_t row)
{
select_text(col, row, col, row);
}
static void
remove_process_timeout_source(void)
{
if (process_timeout_tag == 0)
return;
_vte_debug_print(VTE_DEBUG_TIMEOUT, "Removing process timeout\n");
g_source_remove (process_timeout_tag);
process_timeout_tag = 0;
}
static void
add_update_timeout(vte::terminal::Terminal* that)
{
if (update_timeout_tag == 0) {
_vte_debug_print (VTE_DEBUG_TIMEOUT,
"Starting update timeout\n");
update_timeout_tag =
g_timeout_add_full (GDK_PRIORITY_REDRAW,
VTE_UPDATE_TIMEOUT,
update_timeout, NULL,
NULL);
}
if (!in_process_timeout) {
remove_process_timeout_source();
}
if (that->m_active_terminals_link == nullptr) {
_vte_debug_print (VTE_DEBUG_TIMEOUT,
"Adding terminal to active list\n");
that->m_active_terminals_link = g_active_terminals =
g_list_prepend(g_active_terminals, that);
}
}
void
Terminal::reset_update_rects()
{
g_array_set_size(m_update_rects, 0);
m_invalidated_all = FALSE;
}
static bool
remove_from_active_list(vte::terminal::Terminal* that)
{
if (that->m_active_terminals_link == nullptr ||
that->m_update_rects->len != 0)
return false;
_vte_debug_print(VTE_DEBUG_TIMEOUT, "Removing terminal from active list\n");
g_active_terminals = g_list_delete_link(g_active_terminals, that->m_active_terminals_link);
that->m_active_terminals_link = nullptr;
return true;
}
static void
stop_processing(vte::terminal::Terminal* that)
{
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 &&
update_timeout_tag != 0) {
_vte_debug_print(VTE_DEBUG_TIMEOUT, "Removing update timeout\n");
g_source_remove (update_timeout_tag);
update_timeout_tag = 0;
}
}
static void
remove_update_timeout(vte::terminal::Terminal* that)
{
that->reset_update_rects();
stop_processing(that);
}
static void
add_process_timeout(vte::terminal::Terminal* that)
{
_vte_debug_print(VTE_DEBUG_TIMEOUT,
"Adding terminal to active list\n");
that->m_active_terminals_link = g_active_terminals =
g_list_prepend(g_active_terminals, that);
if (update_timeout_tag == 0 &&
process_timeout_tag == 0) {
_vte_debug_print(VTE_DEBUG_TIMEOUT,
"Starting process timeout\n");
process_timeout_tag =
g_timeout_add (VTE_DISPLAY_TIMEOUT,
process_timeout, NULL);
}
}
void
Terminal::start_processing()
{
if (!is_processing())
add_process_timeout(this);
}
void
Terminal::emit_pending_signals()
{
auto const freezer = vte::glib::FreezeObjectNotify{m_terminal};
emit_adjustment_changed();
if (m_pending_changes & vte::to_integral(PendingChanges::TITLE)) {
if (m_window_title != m_window_title_pending) {
m_window_title.swap(m_window_title_pending);
_vte_debug_print(VTE_DEBUG_SIGNALS,
"Emitting `window-title-changed'.\n");
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();
}
if (m_pending_changes & vte::to_integral(PendingChanges::CWD)) {
if (m_current_directory_uri != m_current_directory_uri_pending) {
m_current_directory_uri.swap(m_current_directory_uri_pending);
_vte_debug_print(VTE_DEBUG_SIGNALS,
"Emitting `current-directory-uri-changed'.\n");
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();
}
if (m_pending_changes & vte::to_integral(PendingChanges::CWF)) {
if (m_current_file_uri != m_current_file_uri_pending) {
m_current_file_uri.swap(m_current_file_uri_pending);
_vte_debug_print(VTE_DEBUG_SIGNALS,
"Emitting `current-file-uri-changed'.\n");
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_pending_changes = 0;
/* Flush any pending "inserted" signals. */
if (m_cursor_moved_pending) {
_vte_debug_print(VTE_DEBUG_SIGNALS,
"Emitting `cursor-moved'.\n");
g_signal_emit(freezer.get(), signals[SIGNAL_CURSOR_MOVED], 0);
m_cursor_moved_pending = false;
}
if (m_text_modified_flag) {
_vte_debug_print(VTE_DEBUG_SIGNALS,
"Emitting buffered `text-modified'.\n");
emit_text_modified();
m_text_modified_flag = false;
}
if (m_text_inserted_flag) {
_vte_debug_print(VTE_DEBUG_SIGNALS,
"Emitting buffered `text-inserted'\n");
emit_text_inserted();
m_text_inserted_flag = false;
}
if (m_text_deleted_flag) {
_vte_debug_print(VTE_DEBUG_SIGNALS,
"Emitting buffered `text-deleted'\n");
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();
}
_vte_debug_print(VTE_DEBUG_SIGNALS,
"Emitting `contents-changed'.\n");
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) >= VTE_BELL_MINIMUM_TIME_DIFFERENCE) {
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;
}
}
void
Terminal::time_process_incoming()
{
g_timer_reset(process_timer);
process_incoming();
auto elapsed = g_timer_elapsed(process_timer, NULL) * 1000;
gssize target = VTE_MAX_PROCESS_TIME / elapsed * m_input_bytes;
m_max_input_bytes = (m_max_input_bytes + target) / 2;
}
bool
Terminal::process(bool emit_adj_changed)
{
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 (VTE_MAX_PROCESS_TIME) {
time_process_incoming();
} else {
process_incoming();
}
m_input_bytes = 0;
} else
emit_pending_signals();
return is_active;
}
/* 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 vte#270.
*/
static void
unref_active_terminals(GList* list)
{
g_list_free_full(list, GDestroyNotify(g_object_unref));
}
static auto
ref_active_terminals() noexcept
{
GList* list = nullptr;
for (auto l = g_active_terminals; l != nullptr; l = l->next) {
auto that = reinterpret_cast(l->data);
list = g_list_prepend(list, g_object_ref(that->vte_terminal()));
}
return std::unique_ptr{list, &unref_active_terminals};
}
/* This function is called after DISPLAY_TIMEOUT ms.
* It makes sure initial output is never delayed by more than DISPLAY_TIMEOUT
*/
static gboolean
process_timeout (gpointer data) noexcept
try
{
GList *l, *next;
gboolean again;
in_process_timeout = TRUE;
_vte_debug_print (VTE_DEBUG_WORK, "<");
_vte_debug_print (VTE_DEBUG_TIMEOUT,
"Process timeout: %d active\n",
g_list_length(g_active_terminals));
auto death_grip = ref_active_terminals();
for (l = g_active_terminals; l != NULL; l = next) {
auto that = reinterpret_cast(l->data);
bool active;
next = l->next;
if (l != g_active_terminals) {
_vte_debug_print (VTE_DEBUG_WORK, "T");
}
// FIXMEchpe find out why we don't emit_adjustment_changed() here!!
active = that->process(false);
if (!active) {
remove_from_active_list(that);
}
}
_vte_debug_print (VTE_DEBUG_WORK, ">");
if (g_active_terminals != nullptr && update_timeout_tag == 0) {
again = TRUE;
} else {
_vte_debug_print(VTE_DEBUG_TIMEOUT,
"Stopping process timeout\n");
process_timeout_tag = 0;
again = FALSE;
}
in_process_timeout = FALSE;
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 */
vte::base::Chunk::prune();
}
return again;
}
catch (...)
{
vte::log_exception();
return true; // false?
}
bool
Terminal::invalidate_dirty_rects_and_process_updates()
{
if (G_UNLIKELY(!widget_realized()))
return false;
if (G_UNLIKELY (!m_update_rects->len))
return false;
#if VTE_GTK == 3
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_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 */
gtk_widget_queue_draw_region(m_widget, region);
cairo_region_destroy (region);
#elif VTE_GTK == 4
gtk_widget_queue_draw(m_widget); // FIXMEgtk4
#endif
return true;
}
static gboolean
update_repeat_timeout (gpointer data)
{
GList *l, *next;
bool again;
in_update_timeout = TRUE;
_vte_debug_print (VTE_DEBUG_WORK, "[");
_vte_debug_print (VTE_DEBUG_TIMEOUT,
"Repeat timeout: %d active\n",
g_list_length(g_active_terminals));
auto death_grip = ref_active_terminals();
for (l = g_active_terminals; l != NULL; l = next) {
auto that = reinterpret_cast(l->data);
next = l->next;
if (l != g_active_terminals) {
_vte_debug_print (VTE_DEBUG_WORK, "T");
}
that->process(true);
again = that->invalidate_dirty_rects_and_process_updates();
if (!again) {
remove_from_active_list(that);
}
}
_vte_debug_print (VTE_DEBUG_WORK, "]");
/* 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) {
_vte_debug_print(VTE_DEBUG_TIMEOUT,
"Stopping update timeout\n");
update_timeout_tag = 0;
again = false;
} else {
update_timeout_tag =
g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE,
VTE_UPDATE_REPEAT_TIMEOUT,
update_repeat_timeout, NULL,
NULL);
again = true;
}
in_update_timeout = FALSE;
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 */
vte::base::Chunk::prune();
}
return FALSE; /* If we need to go again, we already have a new timer for that. */
}
static gboolean
update_timeout (gpointer data) noexcept
try
{
GList *l, *next;
in_update_timeout = TRUE;
_vte_debug_print (VTE_DEBUG_WORK, "{");
_vte_debug_print (VTE_DEBUG_TIMEOUT,
"Update timeout: %d active\n",
g_list_length(g_active_terminals));
remove_process_timeout_source();
for (l = g_active_terminals; l != NULL; l = next) {
auto that = reinterpret_cast(l->data);
next = l->next;
if (l != g_active_terminals) {
_vte_debug_print (VTE_DEBUG_WORK, "T");
}
that->process(true);
that->invalidate_dirty_rects_and_process_updates();
}
_vte_debug_print (VTE_DEBUG_WORK, "}");
/* 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_IDLE,
VTE_UPDATE_REPEAT_TIMEOUT,
update_repeat_timeout, NULL,
NULL);
in_update_timeout = FALSE;
return FALSE;
}
catch (...)
{
vte::log_exception();
return true; // false?
}
bool
Terminal::write_contents_sync (GOutputStream *stream,
VteWriteFlags flags,
GCancellable *cancellable,
GError **error)
{
return _vte_ring_write_contents (m_screen->row_data,
stream, flags,
cancellable, error);
}
/*
* Buffer search
*/
/* TODO Add properties & signals */
/*
* Terminal::search_set_regex:
* @regex: (allow-none): a #VteRegex, or %nullptr
* @flags: PCRE2 match flags, or 0
*
* Sets the regex to search for. Unsets the search regex when passed %nullptr.
*/
bool
Terminal::search_set_regex (vte::base::RefPtr&& regex,
uint32_t flags)
{
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;
}
bool
Terminal::search_set_wrap_around(bool wrap)
{
if (wrap == m_search_wrap_around)
return false;
m_search_wrap_around = wrap;
return true;
}
bool
Terminal::search_rows(pcre2_match_context_8 *match_context,
pcre2_match_data_8 *match_data,
vte::grid::row_t start_row,
vte::grid::row_t end_row,
bool backward)
{
int start, end;
long start_col, end_col;
VteCharAttributes *ca;
GArray *attrs;
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_SIZE, PCRE2_SIZE, 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_CHECK | PCRE2_NOTEMPTY | PCRE2_PARTIAL_SOFT /* FIXME: HARD? */,
match_data,
match_context);
if (r == PCRE2_ERROR_NOMATCH) {
g_string_free (row_text, TRUE);
return false;
}
// FIXME: handle partial matches (PCRE2_ERROR_PARTIAL)
if (r < 0) {
g_string_free (row_text, TRUE);
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)) {
g_string_free (row_text, TRUE);
return false;
}
start = so;
end = eo;
/* Fetch text again, with attributes */
g_string_free(row_text, TRUE);
if (!m_search_attrs)
m_search_attrs = g_array_new (FALSE, TRUE, sizeof (VteCharAttributes));
attrs = m_search_attrs;
row_text = get_text(start_row, 0,
end_row, 0,
false /* block */,
true /* wrap */,
attrs);
ca = &g_array_index (attrs, VteCharAttributes, start);
start_row = ca->row;
start_col = ca->column;
ca = &g_array_index (attrs, VteCharAttributes, end - 1);
end_row = ca->row;
end_col = ca->column + ca->columns;
g_string_free (row_text, TRUE);
select_text(start_col, start_row, end_col, end_row);
/* Quite possibly the math here should not access the scroll values directly... */
auto const value = m_screen->scroll_delta;
auto const page_size = m_row_count;
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;
}
bool
Terminal::search_rows_iter(pcre2_match_context_8 *match_context,
pcre2_match_data_8 *match_data,
vte::grid::row_t start_row,
vte::grid::row_t end_row,
bool backward)
{
const VteRowData *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;
}
bool
Terminal::search_find (bool backward)
{
vte::grid::row_t buffer_start_row, buffer_end_row;
vte::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 = vte::take_freeable(pcre2_match_data_create_8(256 /* should be plenty */,
nullptr /* general context */));
buffer_start_row = _vte_ring_delta (m_screen->row_data);
buffer_end_row = _vte_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);
last_end_row = MIN (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.get(), match_data.get(),
buffer_start_row, last_start_row, backward))
goto found;
if (m_search_wrap_around &&
search_rows_iter(match_context.get(), match_data.get(),
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.get(), match_data.get(),
last_end_row, buffer_end_row, backward))
goto found;
if (m_search_wrap_around &&
search_rows_iter(match_context.get(), match_data.get(),
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:
return match_found;
}
/*
* 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
*/
bool
Terminal::set_input_enabled (bool enabled)
{
if (enabled == m_input_enabled)
return false;
m_input_enabled = enabled;
auto context = gtk_widget_get_style_context(m_widget);
/* FIXME: maybe hide cursor when input disabled, too? */
if (enabled) {
if (m_has_focus)
widget()->im_focus_in();
gtk_style_context_remove_class (context, VTE_STYLE_CLASS_READ_ONLY);
} else {
im_reset();
if (m_has_focus)
widget()->im_focus_out();
disconnect_pty_write();
_vte_byte_array_clear(m_outgoing);
gtk_style_context_add_class (context, VTE_STYLE_CLASS_READ_ONLY);
}
return true;
}
std::optional>
Terminal::process_word_char_exceptions(std::string_view str_view) const noexcept
{
auto str = str_view.data();
auto array = std::vector{};
array.reserve(g_utf8_strlen(str, -1));
for (auto const* p = str; *p; p = g_utf8_next_char(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;
}
#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);
}
#endif
return array;
}
/*
* 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
*/
bool
Terminal::set_word_char_exceptions(std::optional stropt)
{
if (auto array = process_word_char_exceptions(stropt ? stropt.value() : WORD_CHAR_EXCEPTIONS_DEFAULT)) {
m_word_char_exceptions = *array;
return true;
}
return false;
}
void
Terminal::set_clear_background(bool setting)
{
if (m_clear_background == setting)
return;
m_clear_background = setting;
invalidate_all();
}
} // namespace terminal
} // namespace vte