[vte/wip/egmont/bidi: 7/16] ringview: Add RingView infrastructure



commit 3b4f120b7ebe2c8acb73d34421cf9b7bd72eca37
Author: Egmont Koblinger <egmont gmail com>
Date:   Sat Jun 1 15:12:32 2019 +0200

    ringview: Add RingView infrastructure
    
    The RingView extracts the contents of the currently visible area plus
    context lines up to the next hard newline (or a safety limit).
    
    This can be used to perform display related tweaks, such as BiDi.

 src/debug.cc       |   1 +
 src/debug.h        |   3 +-
 src/meson.build    |   2 +
 src/ringview.cc    | 229 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/ringview.hh    |  96 ++++++++++++++++++++++
 src/vte.cc         |  53 ++++++++++++-
 src/vteinternal.hh |   7 ++
 src/vterowdata.cc  |   9 +++
 src/vterowdata.hh  |   1 +
 src/widget.cc      |   2 +
 10 files changed, 400 insertions(+), 3 deletions(-)
---
diff --git a/src/debug.cc b/src/debug.cc
index afbd7413..e8dd8d08 100644
--- a/src/debug.cc
+++ b/src/debug.cc
@@ -57,6 +57,7 @@ _vte_debug_init(void)
     { "hyperlink",    VTE_DEBUG_HYPERLINK    },
     { "modes",        VTE_DEBUG_MODES        },
     { "emulation",    VTE_DEBUG_EMULATION    },
+    { "ringview",     VTE_DEBUG_RINGVIEW     },
     { "bidi",         VTE_DEBUG_BIDI         },
   };
 
diff --git a/src/debug.h b/src/debug.h
index 92d9d0f9..8601dad0 100644
--- a/src/debug.h
+++ b/src/debug.h
@@ -64,7 +64,8 @@ typedef enum {
         VTE_DEBUG_HYPERLINK     = 1 << 24,
         VTE_DEBUG_MODES         = 1 << 25,
         VTE_DEBUG_EMULATION     = 1 << 26,
-        VTE_DEBUG_BIDI          = 1 << 27,
+        VTE_DEBUG_RINGVIEW      = 1 << 27,
+        VTE_DEBUG_BIDI          = 1 << 28,
 } VteDebugFlags;
 
 void _vte_debug_init(void);
diff --git a/src/meson.build b/src/meson.build
index 29046b77..6b97aaec 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -70,6 +70,8 @@ libvte_common_sources = debug_sources + modes_sources + parser_sources + utf8_so
   'refptr.hh',
   'ring.cc',
   'ring.hh',
+  'ringview.cc',
+  'ringview.hh',
   'utf8.cc',
   'utf8.hh',
   'vte.cc',
diff --git a/src/ringview.cc b/src/ringview.cc
new file mode 100644
index 00000000..42035476
--- /dev/null
+++ b/src/ringview.cc
@@ -0,0 +1,229 @@
+/*
+ * Copyright © 2018–2019 Egmont Koblinger
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <config.h>
+
+#include "debug.h"
+#include "vtedefines.hh"
+#include "vteinternal.hh"
+
+using namespace vte::base;
+
+RingView::RingView()
+{
+        m_ring = nullptr;
+        m_start = m_len = m_width = 0;
+        m_rows_alloc_len = 0;
+
+        m_invalid = true;
+        m_paused = true;
+}
+
+RingView::~RingView()
+{
+        pause();
+}
+
+/* Pausing a RingView frees up pretty much all of its memory.
+ *
+ * This is to be used when the terminal is unlikely to be painted or interacted with
+ * in the near future, e.g. the widget is unmapped. Not to be called too frequently,
+ * in order to avoid memory fragmentation.
+ *
+ * The RingView is resumed automatically on demand.
+ */
+void
+RingView::pause()
+{
+        int i;
+
+        if (m_paused)
+                return;
+
+        _vte_debug_print (VTE_DEBUG_RINGVIEW, "Ringview: pause, freeing %d rows.\n",
+                                              m_rows_alloc_len);
+
+        for (i = 0; i < m_rows_alloc_len; i++) {
+                _vte_row_data_fini(m_rows[i]);
+                g_free (m_rows[i]);
+        }
+        g_free (m_rows);
+        m_rows_alloc_len = 0;
+
+        m_invalid = true;
+        m_paused = true;
+}
+
+/* Allocate (again) the required memory. */
+void
+RingView::resume()
+{
+        g_assert_cmpint (m_len, >=, 1);
+
+        /* +16: A bit of arbitrary heuristics to likely prevent a quickly following
+         * realloc for the required context lines. */
+        m_rows_alloc_len = m_len + 16;
+        m_rows = (VteRowData **) g_malloc (sizeof (VteRowData *) * m_rows_alloc_len);
+        for (int i = 0; i < m_rows_alloc_len; i++) {
+                m_rows[i] = (VteRowData *) g_malloc (sizeof (VteRowData));
+                _vte_row_data_init (m_rows[i]);
+        }
+
+        _vte_debug_print (VTE_DEBUG_RINGVIEW, "Ringview: resume, allocating %d rows\n",
+                                              m_rows_alloc_len);
+
+        m_paused = false;
+}
+
+void
+RingView::set_ring(Ring *ring)
+{
+        if (G_LIKELY (ring == m_ring))
+                return;
+
+        m_ring = ring;
+        m_invalid = true;
+}
+
+void
+RingView::set_width(vte::grid::column_t width)
+{
+        if (G_LIKELY (width == m_width))
+                return;
+
+        m_width = width;
+        m_invalid = true;
+}
+
+void
+RingView::set_rows(vte::grid::row_t start, vte::grid::row_t len)
+{
+        /* Force at least 1 row, see bug 134. */
+        len = MAX(len, 1);
+
+        if (start == m_start && len == m_len)
+                return;
+
+        /* With per-pixel scrolling, the desired viewport often shrinks by
+         * one row at one end, and remains the same at the other end.
+         * Save work by just keeping the current valid data in this case. */
+        if (!m_invalid && start >= m_start && start + len <= m_start + m_len)
+                return;
+
+        /* m_rows is expanded on demand in update() */
+
+        m_start = start;
+        m_len = len;
+        m_invalid = true;
+}
+
+VteRowData const*
+RingView::get_row(vte::grid::row_t row) const
+{
+        g_assert_cmpint(row, >=, m_top);
+        g_assert_cmpint(row, <, m_top + m_rows_len);
+
+        return m_rows[row - m_top];
+}
+
+void
+RingView::update()
+{
+        if (!m_invalid)
+                return;
+        if (m_paused)
+                resume();
+
+        /* Find the beginning of the topmost paragraph.
+         *
+         * Extract at most VTE_RINGVIEW_PARAGRAPH_LENGTH_MAX context rows.
+         * If this safety limit is reached then together with the first
+         * non-context row this paragraph fragment is already longer
+         * than VTE_RINGVIEW_PARAGRAPH_LENGTH_MAX lines, and thus the
+         * BiDi code will skip it. */
+        vte::grid::row_t row = m_start;
+        const VteRowData *row_data;
+
+        _vte_debug_print (VTE_DEBUG_RINGVIEW, "Ringview: updating for [%ld..%ld] (%ld rows).\n",
+                                              m_start, m_start + m_len - 1, m_len);
+
+        int i = VTE_RINGVIEW_PARAGRAPH_LENGTH_MAX;
+        while (i--) {
+                if (!m_ring->is_soft_wrapped(row - 1))
+                        break;
+                row--;
+        }
+
+        /* Extract the data beginning at the found row.
+         *
+         * Extract at most VTE_RINGVIEW_PARAGRAPH_LENGTH_MAX rows
+         * beyond the end of the specified area. Again, if this safety
+         * limit is reached then together with the last non-context row
+         * this paragraph fragment is already longer than
+         * VTE_RINGVIEW_PARAGRAPH_LENGTH_MAX lines, and thus the
+         * BiDi code will skip it. */
+        m_top = row;
+        m_rows_len = 0;
+        while (row < m_start + m_len + VTE_RINGVIEW_PARAGRAPH_LENGTH_MAX) {
+                if (G_UNLIKELY (m_rows_len == m_rows_alloc_len)) {
+                        /* Don't realloc too aggressively. */
+                        m_rows_alloc_len = std::max(m_rows_alloc_len + 1, m_rows_alloc_len * 5 / 4 /* 
whatever */);
+                        _vte_debug_print (VTE_DEBUG_RINGVIEW, "Ringview: reallocate to %d rows\n",
+                                                              m_rows_alloc_len);
+                        m_rows = (VteRowData **) g_realloc (m_rows, sizeof (VteRowData *) * 
m_rows_alloc_len);
+                        for (int j = m_rows_len; j < m_rows_alloc_len; j++) {
+                                m_rows[j] = (VteRowData *) g_malloc (sizeof (VteRowData));
+                                _vte_row_data_init (m_rows[j]);
+                        }
+                }
+
+                row_data = _vte_ring_contains(m_ring, row) ? m_ring->index(row) : nullptr;
+                if (G_LIKELY (row_data != nullptr)) {
+                        _vte_row_data_copy (row_data, m_rows[m_rows_len]);
+                } else {
+                        _vte_row_data_clear (m_rows[m_rows_len]);
+                }
+                m_rows_len++;
+                row++;
+
+                /* Once the bottom of the specified area is reached, stop at a hard newline. */
+                if (row >= m_start + m_len && (!row_data || !row_data->attr.soft_wrapped))
+                        break;
+        }
+
+        _vte_debug_print (VTE_DEBUG_RINGVIEW, "Ringview: extracted %ld+%ld context lines: [%ld..%ld] (%d 
rows).\n",
+                                              m_start - m_top, (m_top + m_rows_len) - (m_start + m_len),
+                                              m_top, m_top + m_rows_len - 1, m_rows_len);
+
+        /* Loop through paragraphs of the extracted text, and do whatever we need to do on each paragraph. */
+        auto top = m_top;
+        row = top;
+        while (row < m_top + m_rows_len) {
+                row_data = m_rows[row - m_top];
+                if (!row_data->attr.soft_wrapped || row == m_top + m_rows_len - 1) {
+                        /* Found a paragraph from @top to @row, inclusive. */
+
+                        /* Doing BiDi, syntax highlighting etc. come here in the future. */
+
+                        top = row + 1;
+                }
+                row++;
+        }
+
+        m_invalid = false;
+}
diff --git a/src/ringview.hh b/src/ringview.hh
new file mode 100644
index 00000000..6c68241a
--- /dev/null
+++ b/src/ringview.hh
@@ -0,0 +1,96 @@
+/*
+ * Copyright © 2018–2019 Egmont Koblinger
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#pragma once
+
+#include <glib.h>
+
+#include "ring.hh"
+#include "vterowdata.hh"
+#include "vtetypes.hh"
+#include "vteunistr.h"
+
+namespace vte {
+
+namespace base {  // FIXME ???
+
+/*
+ * RingView provides a "view" to a continuous segment of the Ring (or stream),
+ * typically the user visible area.
+ *
+ * It computes additional data that are needed to display the contents (or handle
+ * user events such as mouse click), but not needed for the terminal emulation logic.
+ * In order to save tons of resources, these data are computed when the Ring's
+ * contents are about to be displayed, rather than whenever they change.
+ *
+ * For computing these data, context lines (outside of the specified region of the
+ * Ring) are also taken into account up to the next hard newline or a safety limit.
+ *
+ * Currently RingView is used for BiDi: to figure out which logical character is
+ * mapped to which visual position.
+ *
+ * Future possible uses include "highlight all" for the search match, and
+ * syntax highlighting. URL autodetection might also be ported to this
+ * infrastructure one day.
+ */
+class RingView {
+public:
+        RingView();
+        ~RingView();
+
+        // prevent accidents
+        RingView(RingView& o) = delete;
+        RingView(RingView const& o) = delete;
+        RingView(RingView&& o) = delete;
+        RingView& operator= (RingView& o) = delete;
+        RingView& operator= (RingView const& o) = delete;
+        RingView& operator= (RingView&& o) = delete;
+
+        void set_ring(Ring *ring);
+        void set_rows(vte::grid::row_t start, vte::grid::row_t len);
+        void set_width(vte::grid::column_t width);
+        vte::grid::column_t get_width() const { return m_width; }
+
+        inline void invalidate() { m_invalid = true; }
+        void update();
+        void pause();
+
+        VteRowData const* get_row(vte::grid::row_t row) const;
+
+private:
+        Ring *m_ring;
+
+        VteRowData **m_rows;
+        int m_rows_len;
+        int m_rows_alloc_len;
+
+        vte::grid::row_t m_top;  /* the row of the Ring corresponding to m_rows[0] */
+
+        vte::grid::row_t m_start;
+        vte::grid::row_t m_len;
+        vte::grid::column_t m_width;
+
+        bool m_invalid;
+        bool m_paused;
+
+        void resume();
+};
+
+}; /* namespace base */
+
+}; /* namespace vte */
diff --git a/src/vte.cc b/src/vte.cc
index d225c1d5..8afc4fc1 100644
--- a/src/vte.cc
+++ b/src/vte.cc
@@ -41,6 +41,7 @@
 #include "vtedraw.hh"
 #include "reaper.hh"
 #include "ring.hh"
+#include "ringview.hh"
 #include "caps.hh"
 #include "widget.hh"
 
@@ -1730,6 +1731,8 @@ Terminal::selection_maybe_swap_endpoints(vte::view::coords const& pos)
         if (m_selection_resolved.empty())
                 return;
 
+        ringview_update();
+
         auto current = selection_grid_halfcoords_from_view_coords (pos);
 
         if (m_selection_block_mode) {
@@ -3940,6 +3943,11 @@ Terminal::process_incoming()
                queue_contents_changed();
        }
 
+        /* BiDi properties might have changed, even when !modified.
+         * emit_pending_signals() requires the ringview to be updated. */
+        m_ringview.invalidate();
+        ringview_update();
+
        emit_pending_signals();
 
        if (invalidated_text) {
@@ -5581,6 +5589,8 @@ Terminal::modify_selection (vte::view::coords const& pos)
 {
         g_assert (m_selecting);
 
+        ringview_update();
+
         auto current = selection_grid_halfcoords_from_view_coords (pos);
 
         if (current == m_selection_last)
@@ -6975,6 +6985,8 @@ Terminal::widget_motion_notify(GdkEventMotion *event)
 {
        bool handled = false;
 
+        ringview_update();
+
         GdkEvent* base_event = reinterpret_cast<GdkEvent*>(event);
         auto pos = view_coords_from_event(base_event);
         auto rowcol = grid_coords_from_view_coords(pos);
@@ -7040,6 +7052,8 @@ Terminal::widget_button_press(GdkEventButton *event)
        bool handled = false;
        gboolean start_selecting = FALSE, extend_selecting = FALSE;
 
+        ringview_update();
+
         GdkEvent* base_event = reinterpret_cast<GdkEvent*>(event);
         auto pos = view_coords_from_event(base_event);
         auto rowcol = grid_coords_from_view_coords(pos);
@@ -7189,6 +7203,8 @@ Terminal::widget_button_release(GdkEventButton *event)
 {
        bool handled = false;
 
+        ringview_update();
+
         GdkEvent* base_event = reinterpret_cast<GdkEvent*>(event);
         auto pos = view_coords_from_event(base_event);
         auto rowcol = grid_coords_from_view_coords(pos);
@@ -7306,6 +7322,8 @@ Terminal::widget_focus_out(GdkEventFocus *event)
 void
 Terminal::widget_enter(GdkEventCrossing *event)
 {
+        ringview_update();
+
         GdkEvent* base_event = reinterpret_cast<GdkEvent*>(event);
         auto pos = view_coords_from_event(base_event);
 
@@ -7323,6 +7341,8 @@ Terminal::widget_enter(GdkEventCrossing *event)
 void
 Terminal::widget_leave(GdkEventCrossing *event)
 {
+        ringview_update();
+
         GdkEvent* base_event = reinterpret_cast<GdkEvent*>(event);
         auto pos = view_coords_from_event(base_event);
 
@@ -8202,6 +8222,12 @@ Terminal::widget_size_allocate(GtkAllocation *allocation)
        }
 }
 
+void
+Terminal::widget_unmap()
+{
+        m_ringview.pause();
+}
+
 void
 Terminal::widget_unrealize()
 {
@@ -8994,6 +9020,19 @@ Terminal::draw_cells_with_attributes(struct _vte_draw_text_request *items,
        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.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
@@ -9466,6 +9505,8 @@ Terminal::widget_draw(cairo_t *cr)
         if (region == NULL)
                 return;
 
+        ringview_update();
+
         allocated_width = get_allocated_width();
         allocated_height = get_allocated_height();
 
@@ -9598,7 +9639,8 @@ Terminal::widget_scroll(GdkEventScroll *event)
        int button;
 
         GdkEvent *base_event = reinterpret_cast<GdkEvent*>(event);
-        auto rowcol = confined_grid_coords_from_event(base_event);
+
+//        ringview_update();  // needed?
 
        read_modifiers(base_event);
 
@@ -9633,6 +9675,8 @@ Terminal::widget_scroll(GdkEventScroll *event)
                                "Scroll application by %d lines, smooth scroll delta set back to %f\n",
                                cnt, m_mouse_smooth_scroll_delta);
 
+                auto rowcol = confined_grid_coords_from_event(base_event);
+
                button = cnt > 0 ? 5 : 4;
                if (cnt < 0)
                        cnt = -cnt;
@@ -10477,8 +10521,13 @@ Terminal::process(bool emit_adj_changed)
                         process_incoming();
                 }
                 m_input_bytes = 0;
-        } else
+        } else {
+                // FIXMEegmont why is it needed here, and is this the best place?
+                // Without this, sudden two-finger kinetic scrolls result in crash.
+                ringview_update();
+
                 emit_pending_signals();
+        }
 
         return is_active;
 }
diff --git a/src/vteinternal.hh b/src/vteinternal.hh
index 27d503dd..0c36f832 100644
--- a/src/vteinternal.hh
+++ b/src/vteinternal.hh
@@ -25,6 +25,7 @@
 #include "vtedraw.hh"
 #include "reaper.hh"
 #include "ring.hh"
+#include "ringview.hh"
 #include "buffer.h"
 #include "parser.hh"
 #include "parser-glue.hh"
@@ -616,6 +617,9 @@ public:
         const char *m_hyperlink_hover_uri; /* data is owned by the ring */
         long m_hyperlink_auto_id;
 
+        /* RingView and friends */
+        vte::base::RingView m_ringview;
+
         /* BiDi parameters outside of ECMA and DEC private modes */
         guint m_bidi_rtl : 1;
 
@@ -752,6 +756,7 @@ public:
         void widget_constructed();
         void widget_realize();
         void widget_unrealize();
+        void widget_unmap();
         void widget_style_updated();
         void widget_focus_in(GdkEventFocus *event);
         void widget_focus_out(GdkEventFocus *event);
@@ -1330,6 +1335,8 @@ public:
                                    vte::parser::StringTokeniser::const_iterator& token,
                                    vte::parser::StringTokeniser::const_iterator const& endtoken) noexcept;
 
+        void ringview_update();
+
         /* Sequence handlers */
         bool m_line_wrapped; // signals line wrapped from character insertion
         // Note: inlining the handlers seems to worsen the performance, so we don't do that
diff --git a/src/vterowdata.cc b/src/vterowdata.cc
index 09a75976..217a8b2f 100644
--- a/src/vterowdata.cc
+++ b/src/vterowdata.cc
@@ -175,6 +175,15 @@ void _vte_row_data_shrink (VteRowData *row, gulong max_len)
                row->len = max_len;
 }
 
+// FIXME swap the two params a la memcpy?
+void _vte_row_data_copy (const VteRowData *src, VteRowData *dst)
+{
+        _vte_row_data_ensure (dst, src->len);
+        dst->len = src->len;
+        dst->attr = src->attr;
+        memcpy(dst->cells, src->cells, src->len * sizeof (src->cells[0]));
+}
+
 /* Get the length, ignoring trailing empty cells (with a custom background color). */
 guint16 _vte_row_data_nonempty_length (const VteRowData *row)
 {
diff --git a/src/vterowdata.hh b/src/vterowdata.hh
index 12cbf311..10b76b6a 100644
--- a/src/vterowdata.hh
+++ b/src/vterowdata.hh
@@ -80,6 +80,7 @@ void _vte_row_data_append (VteRowData *row, const VteCell *cell);
 void _vte_row_data_remove (VteRowData *row, gulong col);
 void _vte_row_data_fill (VteRowData *row, const VteCell *cell, gulong len);
 void _vte_row_data_shrink (VteRowData *row, gulong max_len);
+void _vte_row_data_copy (const VteRowData *src, VteRowData *dst);
 guint16 _vte_row_data_nonempty_length (const VteRowData *row);
 
 G_END_DECLS
diff --git a/src/widget.cc b/src/widget.cc
index 331ddba9..5af5d47c 100644
--- a/src/widget.cc
+++ b/src/widget.cc
@@ -334,6 +334,8 @@ Widget::size_allocate(GtkAllocation* allocation) noexcept
 void
 Widget::unmap() noexcept
 {
+        m_terminal->widget_unmap();
+
         if (m_event_window)
                 gdk_window_hide(m_event_window);
 }


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]