[vte/wip/egmont/bidi: 4/76] vte-34-selection-big-rewrite-v3.patch



commit 54555ff921d344ae9655f6bcf8b12798ae81a3f5
Author: Egmont Koblinger <egmont gmail com>
Date:   Sun Oct 7 14:15:55 2018 +0200

    vte-34-selection-big-rewrite-v3.patch

 src/vte.cc         | 1016 ++++++++++++++++++++++++++--------------------------
 src/vteaccess.cc   |    9 +-
 src/vtegtk.cc      |    2 +-
 src/vteinternal.hh |   31 +-
 src/vtetypes.cc    |   73 +++-
 src/vtetypes.hh    |   57 ++-
 6 files changed, 631 insertions(+), 557 deletions(-)
---
diff --git a/src/vte.cc b/src/vte.cc
index f73594bd..bd27c5a6 100644
--- a/src/vte.cc
+++ b/src/vte.cc
@@ -27,7 +27,6 @@
 #include <sys/param.h> /* howmany() */
 #include <errno.h>
 #include <fcntl.h>
-#include <math.h>
 #ifdef HAVE_SYS_TERMIOS_H
 #include <sys/termios.h>
 #endif
@@ -305,8 +304,35 @@ Terminal::invalidate_row(vte::grid::row_t row)
 void
 Terminal::invalidate(vte::grid::span const& s)
 {
-        invalidate_rows(s.start_row(),
-                        s.end_column() < 0 ? s.end_row() - 1 : s.end_row());
+        if (!s.empty())
+                invalidate_rows(s.start_row(), s.last_row());
+}
+
+/* Invalidates the XOR area of the two spans */
+void
+Terminal::invalidate_xor(vte::grid::span const& a, vte::grid::span const& b, bool block)
+{
+        if (a.empty() || b.empty() || a.start() >= b.end() || b.start() >= a.end()) {
+                /* One or both are empty (invalidate() will figure out which), or disjoint intervals. */
+                invalidate (a);
+                invalidate (b);
+                return;
+        }
+
+        if (block) {
+                /* We could optimize when the columns don't change, probably not worth it. */
+                invalidate_rows (std::min (a.start_row(), b.start_row()),
+                                 std::max (a.last_row(),  b.last_row()));
+        } else {
+                if (a.start() != b.start()) {
+                        invalidate_rows (std::min (a.start_row(), b.start_row()),
+                                         std::max (a.start_row(), b.start_row()));
+                }
+                if (a.end() != b.end()) {
+                        invalidate_rows (std::min (a.last_row(), b.last_row()),
+                                         std::max (a.last_row(), b.last_row()));
+                }
+        }
 }
 
 void
@@ -725,21 +751,17 @@ Terminal::emit_hyperlink_hover_uri_changed(const GdkRectangle *bbox)
 void
 Terminal::deselect_all()
 {
-       if (m_has_selection) {
-                gint sy, ey;
-
+        if (!m_selection_resolved.empty()) {
                _vte_debug_print(VTE_DEBUG_SELECTION,
                                "Deselecting all text.\n");
 
-               m_has_selection = FALSE;
+                m_selection_origin = m_selection_last = vte::grid::halfcoords (-1, -1, 1);
+                resolve_selection();
+
                /* Don't free the current selection, as we need to keep
                 * hold of it for async copying from the clipboard. */
 
                emit_selection_changed();
-
-               sy = m_selection_start.row;
-               ey = m_selection_end.row;
-                invalidate_rows(sy, ey);
        }
 }
 
@@ -1530,6 +1552,84 @@ Terminal::confine_grid_coords(vte::grid::coords const& rowcol) const
                                  CLAMP(rowcol.column(), 0, m_column_count - 1));
 }
 
+/*
+ * Track mouse click and drag positions (the "origin" and "last" coordinates) with half cell accuracy,
+ * that is, know whether the event occurred over the left or right half of the cell.
+ * This is required because some selection modes care about the cell over which the event occurred,
+ * while some care about the closest boundary between cells.
+ *
+ * Storing the actual view coordinates would become problematic when the font size changes (bug 756058),
+ * and would cause too much work when the mouse moves within the half cell.
+ *
+ * Left margin or anything further to the left is denoted by column -1's right half,
+ * right margin or anything further to the right is denoted by column m_column_count's left half.
+ */
+vte::grid::halfcoords
+Terminal::selection_grid_halfcoords_from_view_coords(vte::view::coords const& pos) const
+{
+        vte::grid::row_t row = pixel_to_row(pos.y);
+        vte::grid::halfcolumn_t halfcolumn;
+
+        if (pos.x < 0) {
+                halfcolumn.set_column(-1);
+                halfcolumn.set_half(1);
+        } else if (pos.x >= m_column_count * m_cell_width) {
+                halfcolumn.set_column(m_column_count);
+                halfcolumn.set_half(0);
+        } else {
+                halfcolumn.set_column(pos.x / m_cell_width);
+                halfcolumn.set_half((pos.x * 2 / m_cell_width) % 2);
+        }
+
+        return vte::grid::halfcoords(row, halfcolumn);
+}
+
+/*
+ * Called on Shift+Click to continue (extend or shrink) the previous selection.
+ * Swaps the two endpoints of the selection if needed, so that m_selection_origin
+ * contains the new fixed point and m_selection_last is the newly dragged end.
+ * In block mode it might even switch to the other two corners.
+ * As per GTK+'s generic selection behavior, retains the origin and last
+ * endpoints if the Shift+click happened inside the selection.
+ */
+void
+Terminal::selection_maybe_swap_endpoints(vte::view::coords const& pos,
+                                         enum vte_selection_type type /* FIXME or use m_selection_type? */,
+                                         bool block /* FIXME or use m_selection_block_mode? */)
+{
+        if (m_selection_resolved.empty())
+                return;
+
+        vte::grid::halfcoords current = selection_grid_halfcoords_from_view_coords (pos);
+
+        if (block) {
+                if ((current.row() <= m_selection_origin.row() && m_selection_origin.row() < 
m_selection_last.row()) ||
+                    (current.row() >= m_selection_origin.row() && m_selection_origin.row() > 
m_selection_last.row())) {
+                        auto tmp = m_selection_origin.row();
+                        m_selection_origin.set_row(m_selection_last.row());
+                        m_selection_last.set_row(tmp);
+                }
+                if ((current.halfcolumn() <= m_selection_origin.halfcolumn() && 
m_selection_origin.halfcolumn() < m_selection_last.halfcolumn()) ||
+                    (current.halfcolumn() >= m_selection_origin.halfcolumn() && 
m_selection_origin.halfcolumn() > m_selection_last.halfcolumn())) {
+                        auto tmp = m_selection_origin.halfcolumn();
+                        m_selection_origin.set_halfcolumn(m_selection_last.halfcolumn());
+                        m_selection_last.set_halfcolumn(tmp);
+                }
+        } else {
+                if ((current <= m_selection_origin && m_selection_origin < m_selection_last) ||
+                    (current >= m_selection_origin && m_selection_origin > m_selection_last)) {
+                        auto tmp = m_selection_origin;
+                        m_selection_origin = m_selection_last;
+                        m_selection_last = tmp;
+                }
+        }
+
+        _vte_debug_print(VTE_DEBUG_SELECTION,
+                         "Selection maybe swap endpoints: origin=%s last=%s\n",
+                         m_selection_origin.to_string(),
+                         m_selection_last.to_string());
+}
+
 bool
 Terminal::rowcol_from_event(GdkEvent *event,
                                       long *column,
@@ -3625,7 +3725,7 @@ Terminal::process_incoming()
                }
                /* Deselect the current selection if its contents are changed
                 * by this insertion. */
-               if (m_has_selection) {
+                if (!m_selection_resolved.empty()) {
                         //FIXMEchpe: this is atrocious
                        auto selection = get_selected_text();
                        if ((selection == nullptr) ||
@@ -4923,6 +5023,14 @@ Terminal::is_same_class(vte::grid::column_t acol,
        VteCell const* pcell = nullptr;
        bool word_char;
        if ((pcell = find_charcell(acol, arow)) != nullptr && pcell->c != 0) {
+                /* Group together if they're fragments of the very same character (not just character value) 
*/
+                if (arow == brow) {
+                        vte::grid::column_t a2 = acol, b2 = bcol;
+                        while (a2 > 0 && find_charcell(a2, arow)->attr.fragment()) a2--;
+                        while (b2 > 0 && find_charcell(b2, brow)->attr.fragment()) b2--;
+                        if (a2 == b2) return true;
+                }
+
                word_char = is_word_char(_vte_unistr_get_base(pcell->c));
 
                /* Lets not group non-wordchars together (bug #25290) */
@@ -4950,31 +5058,328 @@ Terminal::line_is_wrappable(vte::grid::row_t row) const
        return rowdata && rowdata->attr.soft_wrapped;
 }
 
+/*
+ * Convert the mouse click or drag location (left or right half of a cell) into a selection endpoint (a 
boundary between
+ * characters), extending the selection according to the current mode, in the direction given in the @after 
parameter.
+ *
+ * All four selection modes require different strategies.
+ *
+ * In char mode, what matters is which vertical character boundary is closer, taking multi-cell characters 
(CJKs, TABs) into account.
+ * Given the string "abcdef", if the user clicks on the boundary between "a" and "b" (perhaps on the right 
half of "a", perhaps on
+ * the left half of "b"), and moves the mouse to the boundary between "e" and "f" (perhaps a bit over "e", 
perhaps a bit over "f"),
+ * the selection should be "bcde". By dragging the mouse back to approximately the click location, it is 
possible to select the
+ * empty string. This is the common sense behavior impemented by basically every graphical toolkit 
(unfortunately not by many
+ * terminal emulators), and also the one we go for.
+ *
+ * Word mode is the trickiest one. Many implementations have weird corner case bugs (e.g. don't highlight a 
word if you
+ * double click on the second half of its last letter, or even highlight it if you click on the first half 
of the following space).
+ * I think it is expected that double-clicking anywhere over a word (including the first half of its first 
letter, or the
+ * last half of its last letter), but over no other character, selects this entire word. By dragging the 
mouse it's not possible to
+ * select nothing, the word (or non-word character) initially clicked on is always part of the selection. 
(An exception is when
+ * clicking occurred over the margin, or an unused cell in a soft-wrapped row (due to CJK wrapping).) Also, 
for symmetry reasons,
+ * the word (or non-word character) under the current mouse location is also always selected.
+ *
+ * Line (paragraph) mode is conceptually quite similar to word mode (the cell, thus the entire row under the 
click's location
+ * is always included), but is much easier to implement.
+ *
+ * In block mode, similarly to char mode, we care about vertical character boundary. (This is somewhat 
debatable, as results in
+ * asymmetrical behavior along the two axes: a rectangle can disappear by becoming zero wide, but not zero 
high.)
+ * We cannot take care of CJKs at the endpoints now because CJKs can cross the boundary in any included row. 
Taking care of them
+ * needs to go to cell_is_selected(). We don't care about used vs. unused cells either. The event coordinate 
is simply rounded
+ * to the nearest vertical cell boundary.
+ */
+vte::grid::coords
+Terminal::resolve_selection_endpoint(vte::grid::halfcoords rowcolhalf, bool after) const
+{
+        vte::grid::row_t row = rowcolhalf.row();
+        /* col points to an actual cell now. At the end of this method it'll point to a boundary. */
+        vte::grid::column_t col = rowcolhalf.halfcolumn().column();
+        vte::grid::half_t half = rowcolhalf.halfcolumn().half();  /* 0 for left half, 1 for right half of 
the cell */
+        VteRowData const* rowdata;
+        VteCell const* cell;
+        int len;
+
+        if (m_selection_block_mode) {
+                /* Just find the nearest cell boundary within the line, not caring about CJKs, unused cells, 
or wrapping at EOL.
+                 * The @after parameter is unused in this mode. */
+                col += half;
+                col = CLAMP (col, 0, m_column_count);
+        } else {
+                switch (m_selection_type) {
+                case selection_type_char:
+                        /* Find the nearest actual character boundary, taking CJKs and TABs into account.
+                         * If at least halfway through the first unused cell, or over the right margin
+                         * then wrap to the beginning of the next line.
+                         * The @after parameter is unused in this mode. */
+                        if (col < 0) {
+                                col = 0;
+                        } else if (col >= m_column_count) {
+                                /* If on the right padding, select the entire line including a possible 
newline character.
+                                 * This way if a line is fully filled and ends in a newline, there's only a 
half cell width
+                                 * for which the line is selected without the newline, but at least there's 
a way to include
+                                 * the newline by moving the mouse to the right (bug 724253). */
+                                col = 0;
+                                row++;
+                        } else {
+                                vte::grid::column_t char_begin, char_end;  /* cell boundaries */
+                                rowdata = find_row_data(row);
+                                if (rowdata && col < rowdata->len) {
+                                        /* Clicked over a used cell. Check for multi-cell characters. */
+                                        char_begin = col;
+                                        while (char_begin > 0) {
+                                                cell = _vte_row_data_get (rowdata, char_begin);
+                                                if (!cell->attr.fragment()) break;
+                                                char_begin--;
+                                        }
+                                        cell = _vte_row_data_get (rowdata, char_begin);
+                                        char_end = char_begin + cell->attr.columns();
+                                } else {
+                                        /* Clicked over unused area. Just go with cell boundaries. */
+                                        char_begin = col;
+                                        char_end = char_begin + 1;
+                                }
+                                /* Which boundary is closer? */
+                                if (col * 2 + half < char_begin + char_end)
+                                        col = char_begin;
+                                else
+                                        col = char_end;
+
+                                /* Maybe wrap to the beginning of the next line. */
+                                if (col > (rowdata ? rowdata->len : 0)) {
+                                        col = 0;
+                                        row++;
+                                }
+                        }
+                        break;
+
+                case selection_type_word:
+                        /* Initialization for the cumbersome cases where the click didn't occur over an 
actual used cell. */
+                        rowdata = find_row_data(row);
+                        if (col < 0) {
+                                /* Clicked over the left margin.
+                                 * If within a word (that is, the first letter in this row, and the last 
letter of the previous row
+                                 * belong to the same word) then select the letter according to the 
direction and continue expanding.
+                                 * Otherwise stop, the boundary is here before the first letter. */
+                                if ((rowdata = find_row_data(row - 1)) != nullptr &&
+                                    rowdata->attr.soft_wrapped &&
+                                    (len = rowdata->len) > 0 &&
+                                    is_same_class(len - 1, row - 1, 0, row) /* invalidates rowdata! */) {
+                                        if (!after) {
+                                                col = len - 1;
+                                                row--;
+                                        } else {
+                                                col = 0;
+                                        }
+                                } else {
+                                        col = 0;  /* end-exclusive */
+                                        break;
+                                }
+                        } else if (col >= (rowdata ? rowdata->len : 0)) {
+                                /* Clicked over the right margin, or right unused area.
+                                 * If within a word (that is, the last letter in this row, and the first 
letter of the next row
+                                 * belong to the same word) then select the letter according to the 
direction and continue expanding.
+                                 * Otherwise, if the row is soft-wrapped and we're over the unused area 
(which can happen if a CJK wrapped)
+                                 * or over the right margin, then stop, the boundary is wrapped to the 
beginning of the next row.
+                                 * Otherwise select the newline only and stop. */
+                                if ((rowdata = find_row_data(row)) != nullptr &&
+                                    rowdata->attr.soft_wrapped &&
+                                    (len = rowdata->len) > 0 &&
+                                    is_same_class(len - 1, row, 0, row + 1) /* invalidates rowdata! */) {
+                                        if (!after) {
+                                                col = len - 1;
+                                        } else {
+                                                col = 0;
+                                                row++;
+                                        }
+                                } else if ((rowdata = find_row_data(row)) != nullptr &&
+                                           rowdata->attr.soft_wrapped) {
+                                        col = 0;  /* end-exclusive */
+                                        row++;
+                                        break;
+                                } else {
+                                        if (!after) {
+                                                col = rowdata ? rowdata->len : 0;  /* end-exclusive */
+                                        } else {
+                                                col = 0;  /* end-exclusive */
+                                                row++;
+                                        }
+                                        break;
+                                }
+                        }
+
+                        /* Expand in the given direction. */
+                        if (!after) {
+                                /* Keep selecting to the left (and then up) as long as the next character we
+                                 * look at is of the same class as the current start point. */
+                                while (true) {
+                                        /* Back up within the row. */
+                                        for (; col > 0; col--) {
+                                                if (!is_same_class(col - 1, row, col, row)) {
+                                                        break;
+                                                }
+                                        }
+                                        if (col > 0) {
+                                                /* We hit a stopping point, so stop. */
+                                                break;
+                                        }
+                                        rowdata = find_row_data(row - 1);
+                                        if (!rowdata || !rowdata->attr.soft_wrapped) {
+                                                /* Reached a hard newline. */
+                                                break;
+                                        }
+                                        len = rowdata->len;
+                                        /* len might be smaller than m_column_count if a CJK wrapped */
+                                        if (!is_same_class(len - 1, row - 1, col, row) /* invalidates 
rowdata! */) {
+                                                break;
+                                        }
+                                        /* Move on to the previous line. */
+                                        col = len - 1;
+                                        row--;
+                                }
+                        } else {
+                                /* Keep selecting to the right (and then down) as long as the next character 
we
+                                 * look at is of the same class as the current end point. */
+                                while (true) {
+                                        rowdata = find_row_data(row);
+                                        if (!rowdata) {
+                                                break;
+                                        }
+                                        len = rowdata->len;
+                                        bool soft_wrapped = rowdata->attr.soft_wrapped;
+                                        /* Move forward within the row. */
+                                        for (; col < len - 1; col++) {
+                                                if (!is_same_class(col, row, col + 1, row) /* invalidates 
rowdata! */) {
+                                                        break;
+                                                }
+                                        }
+                                        if (col < len - 1) {
+                                                /* We hit a stopping point, so stop. */
+                                                break;
+                                        }
+                                        if (!soft_wrapped) {
+                                                /* Reached a hard newline. */
+                                                break;
+                                        }
+                                        if (!is_same_class(col, row, 0, row + 1)) {
+                                                break;
+                                        }
+                                        /* Move on to the next line. */
+                                        col = 0;
+                                        row++;
+                                }
+                                col++;  /* col points to an actual cell, we need end-exclusive instead. */
+                        }
+                        break;
+
+                case selection_type_line:
+                        if (!after) {
+                                /* Back up as far as we can go. */
+                                while (_vte_ring_contains (m_screen->row_data, row - 1) &&
+                                       line_is_wrappable(row - 1)) {
+                                        row--;
+                                }
+                        } else {
+                                /* Move forward as far as we can go. */
+                                while (_vte_ring_contains (m_screen->row_data, row) &&
+                                       line_is_wrappable(row)) {
+                                        row++;
+                                }
+                                row++;  /* One more row, since the column is 0. */
+                        }
+                        col = 0;
+                        break;
+                }
+        }
+
+        return vte::grid::coords (row, col);
+}
+
+/*
+ * Creates the selection's span from the origin and last coordinates.
+ * Takes the endpoints in swapped order if necessary. In block mode it might even switch to the other two 
corners.
+ * In word & line (paragraph) modes it extends the selection accordingly.
+ * Also makes sure to invalidate the regions that changed, and update m_selecting_had_delta.
+ *
+ * FIXMEegmont it always resolves both endpoints. With a bit of extra bookkeeping it could usually
+ * just resolve the moving one.
+ */
+void
+Terminal::resolve_selection()
+{
+        if (m_selection_origin.row() < 0 || m_selection_last.row() < 0) {
+                invalidate (m_selection_resolved);
+                m_selection_resolved.clear();
+                _vte_debug_print(VTE_DEBUG_SELECTION, "Selection resolved to %s.\n", 
m_selection_resolved.to_string());
+                return;
+        }
+
+        auto m_selection_resolved_old = m_selection_resolved;
+
+        if (m_selection_block_mode) {
+                vte::grid::row_t top    = std::min (m_selection_origin.row(), m_selection_last.row());
+                vte::grid::row_t bottom = std::max (m_selection_origin.row(), m_selection_last.row());
+                vte::grid::halfcolumn_t left  = std::min (m_selection_origin.halfcolumn(), 
m_selection_last.halfcolumn());
+                vte::grid::halfcolumn_t right = std::max (m_selection_origin.halfcolumn(), 
m_selection_last.halfcolumn());
+
+                vte::grid::coords topleft     = resolve_selection_endpoint (vte::grid::halfcoords (top,    
left),  false);
+                vte::grid::coords bottomright = resolve_selection_endpoint (vte::grid::halfcoords (bottom, 
right), true);
+
+                if (topleft.column() == bottomright.column()) {
+                        m_selection_resolved.clear();
+                } else {
+                        m_selection_resolved.set (topleft, bottomright);
+                }
+        } else {
+                vte::grid::halfcoords a = std::min (m_selection_origin, m_selection_last);
+                vte::grid::halfcoords b = std::max (m_selection_origin, m_selection_last);
+
+                m_selection_resolved.set (resolve_selection_endpoint (a, false),
+                                          resolve_selection_endpoint (b, true));
+        }
+
+        if (!m_selection_resolved.empty())
+                m_selecting_had_delta = true;
+
+        _vte_debug_print(VTE_DEBUG_SELECTION, "Selection resolved to %s.\n", 
m_selection_resolved.to_string());
+
+        invalidate_xor (m_selection_resolved_old, m_selection_resolved, m_selection_block_mode);
+}
+
+void
+Terminal::modify_selection (vte::view::coords pos)
+{
+        g_assert (m_selecting);
+
+        vte::grid::halfcoords current = selection_grid_halfcoords_from_view_coords (pos);
+
+        if (current == m_selection_last)
+                return;
+
+        _vte_debug_print(VTE_DEBUG_SELECTION,
+                         "Selection dragged to %s.\n",
+                         current.to_string());
+
+        m_selection_last = current;
+        resolve_selection();
+}
+
 /* Check if a cell is selected or not. */
-// FIXMEchpe: replace this by just using vte::grid::span for selection and then this simply becomes 
.contains()
 bool
 Terminal::cell_is_selected(vte::grid::column_t col,
                                      vte::grid::row_t row) const
 {
-       /* If there's nothing selected, it's an easy question to answer. */
-       if (!m_has_selection)
-               return false;
-
-       /* If the selection is obviously bogus, then it's also very easy. */
-       auto const& ss = m_selection_start;
-       auto const& se = m_selection_end;
-       if ((ss.row < 0) || (se.row < 0)) {
-               return false;
-       }
-
-       /* Now it boils down to whether or not the point is between the
-        * begin and endpoint of the selection. */
         if (m_selection_block_mode) {
-                return (row >= ss.row && row <= se.row &&
-                        col >= ss.col && col <= se.col);
+                /* In block mode, make sure CJKs and TABs aren't cut in half. */
+                while (col > 0) {
+                        VteCell const* cell = find_charcell(col, row);
+                        if (!cell || !cell->attr.fragment())
+                                break;
+                        col--;
+                }
+                return m_selection_resolved.box_contains (vte::grid::coords (row, col));
         } else {
-                return ((row > ss.row || (row == ss.row && col >= ss.col)) &&
-                        (row < se.row || (row == se.row && col <= se.col)));
+                /* In normal modes, resolve_selection() made sure to generate such boundaries for 
m_selection_resolved. */
+                return m_selection_resolved.contains (vte::grid::coords (row, col));
         }
 }
 
@@ -5509,7 +5914,7 @@ Terminal::widget_clipboard_cleared(GtkClipboard *clipboard_)
 
        if (clipboard_ == m_clipboard[VTE_SELECTION_PRIMARY]) {
                if (m_selection_owned[VTE_SELECTION_PRIMARY] &&
-                    m_has_selection) {
+                    !m_selection_resolved.empty()) {
                        _vte_debug_print(VTE_DEBUG_SELECTION, "Lost selection.\n");
                        deselect_all();
                }
@@ -5656,7 +6061,7 @@ Terminal::get_text(vte::grid::row_t start_row,
                attr.column = col;
                pcell = NULL;
                if (row_data != NULL) {
-                        while (col <= line_last_column &&
+                        while (col < line_last_column &&
                                (pcell = _vte_row_data_get (row_data, col))) {
 
                                attr.column = col;
@@ -5736,7 +6141,7 @@ Terminal::get_text_displayed(bool wrap,
                                        GArray *attributes)
 {
         return get_text(first_displayed_row(), 0,
-                        last_displayed_row() + 1, -1,
+                        last_displayed_row() + 1, 0,
                         false /* block */, wrap,
                         attributes);
 }
@@ -5749,7 +6154,7 @@ Terminal::get_text_displayed_a11y(bool wrap,
                                             GArray *attributes)
 {
         return get_text(m_screen->scroll_delta, 0,
-                        m_screen->scroll_delta + m_row_count - 1 + 1, -1,
+                        m_screen->scroll_delta + m_row_count - 1 + 1, 0,
                         false /* block */, wrap,
                         attributes);
 }
@@ -5757,10 +6162,10 @@ Terminal::get_text_displayed_a11y(bool wrap,
 GString*
 Terminal::get_selected_text(GArray *attributes)
 {
-       return get_text(m_selection_start.row,
-                        m_selection_start.col,
-                        m_selection_end.row,
-                        m_selection_end.col,
+        return get_text(m_selection_resolved.start_row(),
+                        m_selection_resolved.start_column(),
+                        m_selection_resolved.end_row(),
+                        m_selection_resolved.end_column(),
                         m_selection_block_mode,
                         true /* wrap */,
                         attributes);
@@ -6043,7 +6448,6 @@ Terminal::widget_copy(VteSelection sel,
 
         if (selection == nullptr) {
                 g_array_free(attributes, TRUE);
-                m_has_selection = FALSE;
                 m_selection_owned[sel] = false;
                 return;
         }
@@ -6057,8 +6461,8 @@ Terminal::widget_copy(VteSelection sel,
 
        g_array_free (attributes, TRUE);
 
-       if (sel == VTE_SELECTION_PRIMARY)
-               m_has_selection = TRUE;
+//     if (sel == VTE_SELECTION_PRIMARY)
+//             m_has_selection = TRUE;  // FIXME
 
        /* Place the text on the clipboard. */
         _vte_debug_print(VTE_DEBUG_SELECTION,
@@ -6097,12 +6501,6 @@ Terminal::widget_paste(GdkAtom board)
         m_paste_request.request_text(clip, &Terminal::widget_paste_received, this);
 }
 
-void
-Terminal::invalidate_selection()
-{
-        invalidate_rows(m_selection_start.row, m_selection_end.row);
-}
-
 /* Confine coordinates into the visible area. Padding is already subtracted. */
 void
 Terminal::confine_coordinates(long *xp,
@@ -6135,54 +6533,42 @@ Terminal::confine_coordinates(long *xp,
        *yp = y;
 }
 
-/* Start selection at the location of the event. */
+/* 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(long x,
-                                    long y,
-                                    enum vte_selection_type type)
+Terminal::start_selection (vte::view::coords pos,
+                           enum vte_selection_type type)
 {
        if (m_selection_block_mode)
                type = selection_type_char;
 
-       /* Confine coordinates into the visible area. (#563024, #722635c7) */
-       confine_coordinates(&x, &y);
+        m_selection_origin = m_selection_last = selection_grid_halfcoords_from_view_coords(pos);
 
-       /* Record that we have the selection, and where it started. */
-       m_has_selection = TRUE;
-       m_selection_last.x = x;
-       m_selection_last.y = scroll_delta_pixel() + y;
-
-       /* Decide whether or not to restart on the next drag. */
+       /* Decide whether or not to restart on the next drag. FIXME this description is bad */
        switch (type) {
-       case selection_type_char:
+       case selection_type_char:  // FIXME this should only go for non-block mode
                /* Restart selection once we register a drag. */
-               m_selecting_restart = TRUE;
-               m_has_selection = FALSE;
                m_selecting_had_delta = FALSE;
-
-               m_selection_origin = m_selection_last;
                break;
        case selection_type_word:
        case selection_type_line:
                /* Mark the newly-selected areas now. */
-               m_selecting_restart = FALSE;
-               m_has_selection = FALSE;
-               m_selecting_had_delta = FALSE;
+               m_selecting_had_delta = FALSE;  // FIXME why not TRUE?
                break;
        }
 
        /* Record the selection type. */
        m_selection_type = type;
        m_selecting = TRUE;
-       m_selecting_after_threshold = FALSE;
+        m_will_select_after_threshold = FALSE;
 
        _vte_debug_print(VTE_DEBUG_SELECTION,
-                         "Selection started at (%ld,%ld).\n",
-                         m_selection_start.col,
-                         m_selection_start.row);
+                         "Selection started at %s.\n",
+                         m_selection_origin.to_string());
 
         /* Take care of updating the display. */
-        extend_selection(x, y, false, true);
+        resolve_selection();
 
        /* Temporarily stop caring about input from the child. */
        disconnect_pty_read();
@@ -6193,8 +6579,7 @@ Terminal::maybe_end_selection()
 {
        if (m_selecting) {
                /* Copy only if something was selected. */
-               if (m_has_selection &&
-                   !m_selecting_restart &&
+                if (!m_selection_resolved.empty() &&
                    m_selecting_had_delta) {
                         widget_copy(VTE_SELECTION_PRIMARY, VTE_FORMAT_TEXT);
                        emit_selection_changed();
@@ -6207,395 +6592,12 @@ Terminal::maybe_end_selection()
                return true;
        }
 
-        if (m_selecting_after_threshold)
+        if (m_will_select_after_threshold)
                 return true;
 
         return false;
 }
 
-static long
-math_div (long a, long b)
-{
-       if (G_LIKELY (a >= 0))
-               return a / b;
-       else
-               return (a / b) - 1;
-}
-
-/* Helper */
-void
-Terminal::extend_selection_expand()
-{
-       long i, j;
-       const VteCell *cell;
-       VteVisualPosition *sc, *ec;
-
-       if (m_selection_block_mode)
-               return;
-
-       sc = &m_selection_start;
-       ec = &m_selection_end;
-
-       /* Extend the selection to handle end-of-line cases, word, and line
-        * selection.  We do this here because calculating it once is cheaper
-        * than recalculating for each cell as we render it. */
-
-       /* Handle end-of-line at the start-cell. */
-       VteRowData const* rowdata = find_row_data(sc->row);
-       if (rowdata != NULL) {
-               /* Find the last non-empty character on the first line. */
-               for (i = _vte_row_data_length (rowdata); i > 0; i--) {
-                       cell = _vte_row_data_get (rowdata, i - 1);
-                       if (cell->attr.fragment() || cell->c != 0)
-                               break;
-               }
-       } else {
-                i = 0;
-       }
-        if (sc->col > i) {
-                if (m_selection_type == selection_type_char) {
-                        /* If the start point is neither over the used cells, nor over the first
-                         * unused one, then move it to the next line. This way you can still start
-                         * selecting at the newline character by clicking over the first unused cell.
-                         * See bug 725909. */
-                        sc->col = -1;
-                        sc->row++;
-                } else if (m_selection_type == selection_type_word) {
-                        sc->col = i;
-                }
-        }
-        sc->col = find_start_column(sc->col, sc->row);
-
-       /* Handle end-of-line at the end-cell. */
-       rowdata = find_row_data(ec->row);
-       if (rowdata != NULL) {
-               /* Find the last non-empty character on the last line. */
-               for (i = _vte_row_data_length (rowdata); i > 0; i--) {
-                       cell = _vte_row_data_get (rowdata, i - 1);
-                       if (cell->attr.fragment() || cell->c != 0)
-                               break;
-               }
-               /* If the end point is to its right, then extend the
-                * endpoint to the beginning of the next row. */
-               if (ec->col >= i) {
-                       ec->col = -1;
-                       ec->row++;
-               }
-       } else {
-               /* Snap to the beginning of the next line, only if
-                * selecting anything of this row. */
-               if (ec->col >= 0) {
-                       ec->col = -1;
-                       ec->row++;
-               }
-       }
-       ec->col = find_end_column(ec->col, ec->row);
-
-       /* Now extend again based on selection type. */
-       switch (m_selection_type) {
-       case selection_type_char:
-               /* Nothing more to do. */
-               break;
-       case selection_type_word:
-               /* Keep selecting to the left as long as the next character we
-                * look at is of the same class as the current start point. */
-               i = sc->col;
-               j = sc->row;
-               while (_vte_ring_contains (m_screen->row_data, j)) {
-                       /* Get the data for the row we're looking at. */
-                       rowdata = _vte_ring_index(m_screen->row_data, j);
-                       if (rowdata == NULL) {
-                               break;
-                       }
-                       /* Back up. */
-                       for (i = (j == sc->row) ?
-                                sc->col :
-                                m_column_count;
-                            i > 0;
-                            i--) {
-                               if (is_same_class(
-                                                  i - 1,
-                                                  j,
-                                                  i,
-                                                  j)) {
-                                       sc->col = i - 1;
-                                       sc->row = j;
-                               } else {
-                                       break;
-                               }
-                       }
-                       if (i > 0) {
-                               /* We hit a stopping point, so stop. */
-                               break;
-                       } else {
-                               if (line_is_wrappable(j - 1) &&
-                                   is_same_class(
-                                                  m_column_count - 1,
-                                                  j - 1,
-                                                  0,
-                                                  j)) {
-                                       /* Move on to the previous line. */
-                                       j--;
-                                       sc->col = m_column_count - 1;
-                                       sc->row = j;
-                               } else {
-                                       break;
-                               }
-                       }
-               }
-               /* Keep selecting to the right as long as the next character we
-                * look at is of the same class as the current end point. */
-               i = ec->col;
-               j = ec->row;
-               while (_vte_ring_contains (m_screen->row_data, j)) {
-                       /* Get the data for the row we're looking at. */
-                       rowdata = _vte_ring_index(m_screen->row_data, j);
-                       if (rowdata == NULL) {
-                               break;
-                       }
-                       /* Move forward. */
-                       for (i = (j == ec->row) ?
-                                ec->col :
-                                0;
-                            i < m_column_count - 1;
-                            i++) {
-                               if (is_same_class(
-                                                  i,
-                                                  j,
-                                                  i + 1,
-                                                  j)) {
-                                       ec->col = i + 1;
-                                       ec->row = j;
-                               } else {
-                                       break;
-                               }
-                       }
-                       if (i < m_column_count - 1) {
-                               /* We hit a stopping point, so stop. */
-                               break;
-                       } else {
-                               if (line_is_wrappable(j) &&
-                                   is_same_class(
-                                                  m_column_count - 1,
-                                                  j,
-                                                  0,
-                                                  j + 1)) {
-                                       /* Move on to the next line. */
-                                       j++;
-                                       ec->col = 0;
-                                       ec->row = j;
-                               } else {
-                                       break;
-                               }
-                       }
-               }
-               break;
-       case selection_type_line:
-               /* Extend the selection to the beginning of the start line. */
-               sc->col = 0;
-               /* Now back up as far as we can go. */
-               j = sc->row;
-               while (_vte_ring_contains (m_screen->row_data, j - 1) &&
-                      line_is_wrappable(j - 1)) {
-                       j--;
-                       sc->row = j;
-               }
-               /* And move forward as far as we can go. */
-                if (ec->col < 0) {
-                        /* If triple clicking on an unused area, ec already points
-                         * to the beginning of the next line after the second click.
-                         * Go back to the actual row we're at. See bug 725909. */
-                        ec->row--;
-                }
-               j = ec->row;
-               while (_vte_ring_contains (m_screen->row_data, j) &&
-                      line_is_wrappable(j)) {
-                       j++;
-                       ec->row = j;
-               }
-               /* Make sure we include all of the last line by extending
-                * to the beginning of the next line. */
-               ec->row++;
-               ec->col = -1;
-               break;
-       }
-}
-
-/* Extend selection to include the given event coordinates. */
-void
-Terminal::extend_selection(long x,
-                                     long y,
-                                     bool always_grow,
-                                     bool force)
-{
-       long residual;
-       long row;
-        vte::view::coords *origin, *last, *start, *end;
-       VteVisualPosition old_start, old_end, *sc, *ec, *so, *eo;
-       gboolean invalidate_selected = FALSE;
-       gboolean had_selection;
-
-       /* Confine coordinates into the visible area. (#563024, #722635c7) */
-       confine_coordinates(&x, &y);
-
-       old_start = m_selection_start;
-       old_end = m_selection_end;
-       so = &old_start;
-       eo = &old_end;
-
-       /* If we're restarting on a drag, then mark this as the start of
-        * the selected block. */
-       if (m_selecting_restart) {
-               deselect_all();
-               invalidate_selected = TRUE;
-               _vte_debug_print(VTE_DEBUG_SELECTION,
-                               "Selection delayed start at (%ld,%ld).\n",
-                               m_selection_origin.x / m_cell_width,
-                               m_selection_origin.y / m_cell_height);
-       }
-
-       /* Recognize that we've got a selected block. */
-       had_selection = m_has_selection;
-       m_has_selection = TRUE;
-       m_selecting_had_delta = TRUE;
-       m_selecting_restart = FALSE;
-
-       /* If we're not in always-grow mode, update the last location of
-        * the selection. */
-       last = &m_selection_last;
-
-       /* Map the origin and last selected points to a start and end. */
-       origin = &m_selection_origin;
-       if (m_selection_block_mode) {
-               last->x = x;
-               last->y = scroll_delta_pixel() + y;
-
-               /* We don't support always_grow in block mode */
-               if (always_grow)
-                       invalidate_selection();
-
-               if (origin->y <= last->y) {
-                       /* The origin point is "before" the last point. */
-                       start = origin;
-                       end = last;
-               } else {
-                       /* The last point is "before" the origin point. */
-                       start = last;
-                       end = origin;
-               }
-       } else {
-               if (!always_grow) {
-                       last->x = x;
-                       last->y = scroll_delta_pixel() + y;
-               }
-
-               if ((origin->y / m_cell_height < last->y / m_cell_height) ||
-                   ((origin->y / m_cell_height == last->y / m_cell_height) &&
-                    (origin->x / m_cell_width < last->x / m_cell_width ))) {
-                       /* The origin point is "before" the last point. */
-                       start = origin;
-                       end = last;
-               } else {
-                       /* The last point is "before" the origin point. */
-                       start = last;
-                       end = origin;
-               }
-
-               /* Extend the selection by moving whichever end of the selection is
-                * closer to the new point. */
-               if (always_grow) {
-                       /* New endpoint is before existing selection. */
-                        row = pixel_to_row(y);
-                       if ((row < start->y / m_cell_height) ||
-                           ((row == start->y / m_cell_height) &&
-                            (x / m_cell_width < start->x / m_cell_width))) {
-                               start->x = x;
-                               start->y = scroll_delta_pixel() + y;
-                       } else {
-                               /* New endpoint is after existing selection. */
-                               end->x = x;
-                               end->y = scroll_delta_pixel() + y;
-                       }
-               }
-       }
-
-#if 0
-       _vte_debug_print(VTE_DEBUG_SELECTION,
-                       "Selection is (%ld,%ld) to (%ld,%ld).\n",
-                       start->x, start->y, end->x, end->y);
-#endif
-
-       /* Recalculate the selection area in terms of cell positions. */
-
-       sc = &m_selection_start;
-       ec = &m_selection_end;
-
-       sc->row = MAX (0, start->y / m_cell_height);
-       ec->row = MAX (0, end->y   / m_cell_height);
-
-       /* Sort x using row cell coordinates */
-       if ((m_selection_block_mode || sc->row == ec->row) && (start->x > end->x)) {
-                vte::view::coords *tmp;
-               tmp = start;
-               start = end;
-               end = tmp;
-       }
-
-       /* We want to be more lenient on the user with their column selection.
-        * We round to the closest logical position (positions are located between
-        * cells).  But we don't want to fully round.  So we divide the cell
-        * width into three parts.  The side parts round to their nearest
-        * position.  The middle part is always inclusive in the selection.
-        *
-        * math_div and no MAX, to allow selecting no cells in the line,
-        * ie. ec->col = -1, which is essentially equal to copying the
-        * newline from previous line but no chars from current line. */
-       residual = (m_cell_width + 1) / 3;
-       sc->col = math_div (start->x + residual, m_cell_width);
-       ec->col = math_div (end->x - residual, m_cell_width);
-
-       extend_selection_expand();
-
-       if (!invalidate_selected && !force &&
-           0 == memcmp (sc, so, sizeof (*sc)) &&
-           0 == memcmp (ec, eo, sizeof (*ec)))
-               /* No change */
-               return;
-
-       /* Invalidate */
-
-       if (had_selection) {
-
-               if (m_selection_block_mode) {
-                        /* Update the selection area diff in block mode.
-                         * We could optimize when the columns don't change, probably not worth it. */
-                        invalidate_rows(std::min(sc->row, so->row), std::max(ec->row, eo->row));
-               } else {
-                       /* Update the selection area diff in non-block mode. */
-
-                       /* The before band */
-                        // FIXMEegmont simplify these conditions when sc becomes a grid:coords.
-                        if (sc->row != so->row || sc->col != so->col)
-                                invalidate_rows(std::min(sc->row, so->row),
-                                                std::max(sc->row, so->row));
-                       /* The after band */
-                        if (ec->row != eo->row || ec->col != eo->col)
-                                invalidate_rows(std::min(ec->row, eo->row),
-                                                std::max(ec->row, eo->row));
-               }
-       }
-
-       if (invalidate_selected || !had_selection) {
-               _vte_debug_print(VTE_DEBUG_SELECTION, "Invalidating selection.");
-               invalidate_selection();
-       }
-
-       _vte_debug_print(VTE_DEBUG_SELECTION,
-                       "Selection changed to "
-                       "(%ld,%ld) to (%ld,%ld).\n",
-                       sc->col, sc->row, ec->col, ec->row);
-}
-
 /*
  * Terminal::select_all:
  *
@@ -6606,14 +6608,10 @@ Terminal::select_all()
 {
        deselect_all();
 
-       m_has_selection = TRUE;
        m_selecting_had_delta = TRUE;
-       m_selecting_restart = FALSE;
 
-       m_selection_start.row = _vte_ring_delta (m_screen->row_data);
-       m_selection_start.col = 0;
-       m_selection_end.row = _vte_ring_next (m_screen->row_data);
-       m_selection_end.col = -1;
+        m_selection_resolved.set (vte::grid::coords (_vte_ring_delta (m_screen->row_data), 0),
+                                  vte::grid::coords (_vte_ring_next (m_screen->row_data), 0));
 
        _vte_debug_print(VTE_DEBUG_SELECTION, "Selecting *all* text.\n");
 
@@ -6678,7 +6676,7 @@ Terminal::autoscroll()
                        x = m_column_count * m_cell_width;
                }
                /* Extend selection to cover the newly-scrolled area. */
-                extend_selection(x, y, false, true);
+                modify_selection(vte::view::coords(x, y));
        } else {
                /* Stop autoscrolling. */
                m_mouse_autoscroll_tag = 0;
@@ -6729,22 +6727,21 @@ Terminal::widget_motion_notify(GdkEventMotion *event)
 
        switch (event->type) {
        case GDK_MOTION_NOTIFY:
-               if (m_selecting_after_threshold) {
+                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(m_mouse_last_position.x,
-                                        m_mouse_last_position.y,
+                        start_selection(vte::view::coords(m_mouse_last_position.x, m_mouse_last_position.y),
                                         selection_type_char);
                }
 
                if (m_selecting &&
                     (m_mouse_handled_buttons & 1) != 0) {
                        _vte_debug_print(VTE_DEBUG_EVENTS, "Mousing drag 1.\n");
-                       extend_selection(pos.x, pos.y, false, false);
+                        modify_selection(pos);
 
                        /* Start scrolling if we need to. */
                        if (pos.y < 0 || pos.y >= m_view_usable_extents.height()) {
@@ -6815,10 +6812,7 @@ Terminal::widget_button_press(GdkEventButton *event)
                                /* If the user hit shift, then extend the
                                 * selection instead. */
                                if ((m_modifiers & GDK_SHIFT_MASK) &&
-                                   (m_has_selection ||
-                                    m_selecting_restart) &&
-                                   !cell_is_selected(rowcol.column(),
-                                                      rowcol.row())) {
+                                    !m_selection_resolved.empty()) {
                                        extend_selecting = TRUE;
                                } else {
                                        start_selecting = TRUE;
@@ -6826,16 +6820,17 @@ Terminal::widget_button_press(GdkEventButton *event)
                        }
                        if (start_selecting) {
                                deselect_all();
-                               m_selecting_after_threshold = TRUE;
+                                m_will_select_after_threshold = TRUE;
                                 m_selection_block_mode = !!(m_modifiers & GDK_CONTROL_MASK);
                                handled = true;
                        }
                        if (extend_selecting) {
-                               extend_selection(pos.x, pos.y, !m_selecting_restart, true);
                                /* 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, m_selection_type, 
m_selection_block_mode);
+                                modify_selection(pos);
                                handled = true;
                        }
                        break;
@@ -6877,13 +6872,13 @@ Terminal::widget_button_press(GdkEventButton *event)
                                  rowcol.to_string());
                switch (event->button) {
                case 1:
-                       if (m_selecting_after_threshold) {
-                               start_selection(pos.x, pos.y,
+                        if (m_will_select_after_threshold) {
+                                start_selection(pos,
                                                 selection_type_char);
                                handled = true;
                        }
                         if ((m_mouse_handled_buttons & 1) != 0) {
-                               start_selection(pos.x, pos.y,
+                                start_selection(pos,
                                                 selection_type_word);
                                handled = true;
                        }
@@ -6902,7 +6897,7 @@ Terminal::widget_button_press(GdkEventButton *event)
                switch (event->button) {
                case 1:
                         if ((m_mouse_handled_buttons & 1) != 0) {
-                               start_selection(pos.x, pos.y,
+                                start_selection(pos,
                                                 selection_type_line);
                                handled = true;
                        }
@@ -6973,7 +6968,7 @@ Terminal::widget_button_release(GdkEventButton *event)
                 m_mouse_pressed_buttons &= ~(1 << (event->button - 1));
 
        m_mouse_last_position = pos;
-       m_selecting_after_threshold = false;
+        m_will_select_after_threshold = false;
 
         set_pointer_autohidden(false);
         hyperlink_hilite_update();
@@ -7373,6 +7368,7 @@ Terminal::screen_set_size(VteScreen *screen_,
        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);
@@ -7407,11 +7403,13 @@ Terminal::screen_set_size(VteScreen *screen_,
         markers[1] = &below_viewport;
         markers[2] = &below_current_paragraph;
         markers[3] = &screen_->cursor;
-        if (m_has_selection) {
-                /* selection_end is inclusive, make it non-inclusive, see bug 722635. */
-                m_selection_end.col++;
-                markers[4] = &m_selection_start;
-                markers[5] = &m_selection_end;
+        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;
@@ -7439,9 +7437,9 @@ Terminal::screen_set_size(VteScreen *screen_,
                }
        }
 
-       if (m_has_selection) {
-               /* Make selection_end inclusive again, see above. */
-               m_selection_end.col--;
+        if (!m_selection_resolved.empty()) {
+                m_selection_resolved.set (vte::grid::coords (selection_start.row, selection_start.col),
+                                          vte::grid::coords (selection_end.row, selection_end.col));
        }
 
        /* Figure out new insert and scroll deltas */
@@ -9858,18 +9856,10 @@ Terminal::reset(bool clear_tabstops,
         /* Reset the visual bits of selection on hard reset, see bug 789954. */
         if (clear_history) {
                 deselect_all();
-                m_has_selection = FALSE;
                 m_selecting = FALSE;
-                m_selecting_restart = FALSE;
                 m_selecting_had_delta = FALSE;
-                memset(&m_selection_origin, 0,
-                       sizeof(m_selection_origin));
-                memset(&m_selection_last, 0,
-                       sizeof(m_selection_last));
-                memset(&m_selection_start, 0,
-                       sizeof(m_selection_start));
-                memset(&m_selection_end, 0,
-                       sizeof(m_selection_end));
+                m_selection_origin = m_selection_last = vte::grid::halfcoords(-1, -1, 1);
+                m_selection_resolved.clear();
         }
 
        /* Reset mouse motion events. */
@@ -9989,10 +9979,8 @@ Terminal::select_text(vte::grid::column_t start_col,
 
        m_selection_type = selection_type_char;
        m_selecting_had_delta = true;
-       m_selection_start.col = start_col;
-       m_selection_start.row = start_row;
-       m_selection_end.col = end_col;
-       m_selection_end.row = end_row;
+        m_selection_resolved.set (vte::grid::coords (start_row, start_col),
+                                  vte::grid::coords (end_row, end_col));
         widget_copy(VTE_SELECTION_PRIMARY, VTE_FORMAT_TEXT);
        emit_selection_changed();
 
@@ -10003,7 +9991,7 @@ void
 Terminal::select_empty(vte::grid::column_t col,
                                  vte::grid::row_t row)
 {
-        select_text(col, row, col - 1, row);
+        select_text(col, row, col, row);
 }
 
 static void
@@ -10547,7 +10535,7 @@ Terminal::search_rows(pcre2_match_context_8 *match_context,
        gdouble value, page_size;
 
        auto row_text = get_text(start_row, 0,
-                                 end_row, -1,
+                                 end_row, 0,
                                  false /* block */,
                                  true /* wrap */,
                                  nullptr);
@@ -10598,7 +10586,7 @@ Terminal::search_rows(pcre2_match_context_8 *match_context,
                m_search_attrs = g_array_new (FALSE, TRUE, sizeof (VteCharAttributes));
        attrs = m_search_attrs;
        row_text = get_text(start_row, 0,
-                            end_row, -1,
+                            end_row, 0,
                             false /* block */,
                             true /* wrap */,
                             attrs);
@@ -10608,7 +10596,7 @@ Terminal::search_rows(pcre2_match_context_8 *match_context,
        start_col = ca->column;
        ca = &g_array_index (attrs, VteCharAttributes, end - 1);
        end_row = ca->row;
-       end_col = ca->column + ca->columns - 1 /* select_text is end-inclusive */;
+        end_col = ca->column + ca->columns;
 
        g_string_free (row_text, TRUE);
 
@@ -10691,9 +10679,9 @@ Terminal::search_find (bool backward)
        buffer_start_row = _vte_ring_delta (m_screen->row_data);
        buffer_end_row = _vte_ring_next (m_screen->row_data);
 
-       if (m_has_selection) {
-               last_start_row = m_selection_start.row;
-               last_end_row = m_selection_end.row + 1;
+        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;
@@ -10711,9 +10699,9 @@ Terminal::search_find (bool backward)
                    search_rows_iter (match_context, match_data,
                                       last_end_row, buffer_end_row, backward))
                        goto found;
-               if (m_has_selection) {
+                if (!m_selection_resolved.empty()) {
                        if (m_search_wrap_around)
-                           select_empty(m_selection_start.col, m_selection_start.row);
+                            select_empty(m_selection_resolved.start_column(), 
m_selection_resolved.start_row());
                        else
                            select_empty(-1, buffer_start_row - 1);
                }
@@ -10726,11 +10714,11 @@ Terminal::search_find (bool backward)
                    search_rows_iter (match_context, match_data,
                                       buffer_start_row, last_start_row, backward))
                        goto found;
-               if (m_has_selection) {
+                if (!m_selection_resolved.empty()) {
                        if (m_search_wrap_around)
-                                select_empty(m_selection_end.col + 1, m_selection_end.row);
+                                select_empty(m_selection_resolved.end_column() + 1 /* ? */, 
m_selection_resolved.end_row());
                        else
-                                select_empty(-1, buffer_end_row);
+                                select_empty(-1 /* or 0 ? */, buffer_end_row);
                }
                 match_found = false;
        }
diff --git a/src/vteaccess.cc b/src/vteaccess.cc
index b6155af1..1851e077 100644
--- a/src/vteaccess.cc
+++ b/src/vteaccess.cc
@@ -1421,14 +1421,11 @@ vte_terminal_accessible_get_selection(AtkText *text, gint selection_number,
 
         auto impl = IMPL_FROM_WIDGET(widget);
 
-       if (!impl->m_has_selection || impl->m_selection[VTE_SELECTION_PRIMARY] == nullptr)
+        if (impl->m_selection_resolved.empty() || impl->m_selection[VTE_SELECTION_PRIMARY] == nullptr)
                return NULL;
 
-        auto start_sel = impl->m_selection_start;
-        auto end_sel = impl->m_selection_end;
-
-       *start_offset = offset_from_xy (priv, start_sel.col, start_sel.row);
-       *end_offset = offset_from_xy (priv, end_sel.col, end_sel.row);
+        *start_offset = offset_from_xy (priv, impl->m_selection_resolved.start_column(), 
impl->m_selection_resolved.start_row());
+        *end_offset = offset_from_xy (priv, impl->m_selection_resolved.end_column(), 
impl->m_selection_resolved.end_row());
 
        return g_strdup(impl->m_selection[VTE_SELECTION_PRIMARY]->str);
 }
diff --git a/src/vtegtk.cc b/src/vtegtk.cc
index 194837f4..ea8b3208 100644
--- a/src/vtegtk.cc
+++ b/src/vtegtk.cc
@@ -3918,7 +3918,7 @@ gboolean
 vte_terminal_get_has_selection(VteTerminal *terminal)
 {
        g_return_val_if_fail(VTE_IS_TERMINAL(terminal), FALSE);
-       return IMPL(terminal)->m_has_selection;
+        return !IMPL(terminal)->m_selection_resolved.empty();
 }
 
 /**
diff --git a/src/vteinternal.hh b/src/vteinternal.hh
index 6bb39548..817141e2 100644
--- a/src/vteinternal.hh
+++ b/src/vteinternal.hh
@@ -423,22 +423,19 @@ public:
         std::u32string m_word_char_exceptions;
 
        /* Selection information. */
-        gboolean m_has_selection;
         gboolean m_selecting;
-        gboolean m_selecting_after_threshold;
-        gboolean m_selecting_restart;
+        gboolean m_will_select_after_threshold;
         gboolean m_selecting_had_delta;
-        gboolean m_selection_block_mode;
+        gboolean m_selection_block_mode;  // FIXMEegmont move it into a 4th value in vte_selection_type?
         enum vte_selection_type m_selection_type;
-        vte::view::coords m_selection_origin, m_selection_last;
-        VteVisualPosition m_selection_start, m_selection_end;
+        vte::grid::halfcoords m_selection_origin, m_selection_last;
+        vte::grid::span m_selection_resolved;
 
        /* Clipboard data information. */
-        // FIXMEchpe check if this can make m_has_selection obsolete!
         bool m_selection_owned[LAST_VTE_SELECTION];
         VteFormat m_selection_format[LAST_VTE_SELECTION];
         bool m_changing_selection;
-        GString *m_selection[LAST_VTE_SELECTION];
+        GString *m_selection[LAST_VTE_SELECTION];  // FIXMEegmont rename this so that m_selection_resolved 
can become m_selection?
         GtkClipboard *m_clipboard[LAST_VTE_SELECTION];
 
         ClipboardTextRequestGtk<Terminal> m_paste_request;
@@ -675,8 +672,8 @@ public:
         void invalidate_rows(vte::grid::row_t row_start,
                              vte::grid::row_t row_end /* inclusive */);
         void invalidate(vte::grid::span const& s);
+        void invalidate_xor(vte::grid::span const& a, vte::grid::span const& b, bool block);
         void invalidate_match_span();
-        void invalidate_selection();
         void invalidate_all();
 
         void reset_update_rects();
@@ -726,6 +723,8 @@ public:
         vte::view::coords view_coords_from_grid_coords(vte::grid::coords const& rowcol) const;
         vte::grid::coords grid_coords_from_view_coords(vte::view::coords const& pos) const;
 
+        vte::grid::halfcoords selection_grid_halfcoords_from_view_coords(vte::view::coords const& pos) const;
+        void selection_maybe_swap_endpoints(vte::view::coords const& pos, enum vte_selection_type type, bool 
block);  // FIXME move elsewhere?
         bool view_coords_visible(vte::view::coords const& pos) const;
         bool grid_coords_visible(vte::grid::coords const& rowcol) const;
 
@@ -944,20 +943,16 @@ public:
         GString* attributes_to_html(GString* text_string,
                                     GArray* attrs);
 
-        void start_selection(long x,
-                             long y,
-                             enum vte_selection_type selection_type);
+        void start_selection(vte::view::coords pos,
+                             enum vte_selection_type type);
         bool maybe_end_selection();
 
-        void extend_selection_expand();
-        void extend_selection(long x,
-                              long y,
-                              bool always_grow,
-                              bool force);
-
         void select_all();
         void deselect_all();
 
+        vte::grid::coords resolve_selection_endpoint(vte::grid::halfcoords rowcolhalf, bool after) const;
+        void resolve_selection();
+        void modify_selection(vte::view::coords pos);
         bool cell_is_selected(vte::grid::column_t col,
                               vte::grid::row_t) const;
 
diff --git a/src/vtetypes.cc b/src/vtetypes.cc
index f5c30b15..c657cc25 100644
--- a/src/vtetypes.cc
+++ b/src/vtetypes.cc
@@ -23,10 +23,8 @@
 
 #include <type_traits>
 
-static_assert(std::is_pod<vte::grid::coords>::value, "vte::grid::coords not POD");
 static_assert(sizeof(vte::grid::coords) == 2 * sizeof(long), "vte::grid::coords size wrong");
 
-static_assert(std::is_pod<vte::grid::span>::value, "vte::grid::span not POD");
 static_assert(sizeof(vte::grid::span) == 4 * sizeof(long), "vte::grid::span size wrong");
 
 static_assert(std::is_pod<vte::view::coords>::value, "vte::view::coords not POD");
@@ -104,6 +102,14 @@ vte::grid::coords::to_string() const
         return buf;
 }
 
+char const*
+vte::grid::halfcoords::to_string() const
+{
+        char *buf = debug_get_buf();
+        g_snprintf(buf, DEBUG_STRING_SIZE, "halfgrid[%ld,%ld%c]", row(), halfcolumn().column(), 
halfcolumn().half() ? 'R' : 'L');
+        return buf;
+}
+
 char const*
 vte::grid::span::to_string() const
 {
@@ -203,6 +209,61 @@ test_grid_coords (void)
 #endif
 }
 
+static void
+test_grid_halfcoords (void)
+{
+        /* Default constructor */
+        halfcoords p1;
+
+        /* Construction and assignment */
+
+        halfcoords p2(16, halfcolumn_t(32, 1));
+        g_assert_cmpint(p2.row(), ==, 16);
+        g_assert_cmpint(p2.halfcolumn().column(), ==, 32);
+        g_assert_cmpint(p2.halfcolumn().half(), ==, 1);
+
+        /* Comparision operators */
+
+        halfcoords a (10, halfcolumn_t(20, 1));
+        halfcoords a2(10, halfcolumn_t(20, 1));
+        halfcoords b (10, halfcolumn_t(21, 0));
+        halfcoords c (10, halfcolumn_t(21, 1));
+        halfcoords d (10, halfcolumn_t(22, 0));
+        halfcoords e (11, halfcolumn_t( 5, 0));
+
+        g_assert_true (a <= a2);
+        g_assert_false(a <  a2);
+        g_assert_false(a >  a2);
+        g_assert_true (a >= a2);
+
+        g_assert_true (a <= b);
+        g_assert_true (a <  b);
+        g_assert_false(a >  b);
+        g_assert_false(a >= b);
+
+        g_assert_true (b <= c);
+        g_assert_true (b <  c);
+        g_assert_false(b >  c);
+        g_assert_false(b >= c);
+
+        g_assert_true (c <= d);
+        g_assert_true (c <  d);
+        g_assert_false(c >  d);
+        g_assert_false(c >= d);
+
+        g_assert_true (d <= e);
+        g_assert_true (d <  e);
+        g_assert_false(d >  e);
+        g_assert_false(d >= e);
+
+#ifdef VTE_DEBUG
+        /* to_string() */
+        g_assert_cmpstr(halfcoords(16, 32, 0).to_string(), ==, "halfgrid[16,32L]");
+        g_assert_cmpstr(halfcoords(16, 32, 1).to_string(), ==, "halfgrid[16,32R]");
+#endif
+}
+
+
 static void
 test_grid_span (void)
 {
@@ -294,6 +355,13 @@ test_grid_span (void)
         g_assert_false(s8.box_contains(coords(33, 24)));
         g_assert_false(s8.box_contains(coords(33, 42)));
 
+        /* last_row */
+        span s9(16, 16, 32, 0);
+        g_assert_cmpint(s9.last_row(), ==, 31);
+
+        span s10(16, 16, 32, 1);
+        g_assert_cmpint(s10.last_row(), ==, 32);
+
 #ifdef VTE_DEBUG
         /* to_string() */
         g_assert_cmpstr(vte::grid::span(17, 42, 18, 3).to_string(), ==, "grid[(17,42), (18,3))");
@@ -376,6 +444,7 @@ main(int argc, char *argv[])
         g_test_init (&argc, &argv, nullptr);
 
         g_test_add_func("/vte/c++/grid/coords", test_grid_coords);
+        g_test_add_func("/vte/c++/grid/halfcoords", test_grid_halfcoords);
         g_test_add_func("/vte/c++/grid/span", test_grid_span);
         g_test_add_func("/vte/c++/color/rgb", test_color_rgb);
         g_test_add_func("/vte/c++/view/coords", test_view_coords);
diff --git a/src/vtetypes.hh b/src/vtetypes.hh
index e1bb775d..4092e43f 100644
--- a/src/vtetypes.hh
+++ b/src/vtetypes.hh
@@ -36,31 +36,53 @@ namespace grid {
 
         typedef long row_t;
         typedef long column_t;
+        typedef int half_t;
 
-        struct coords {
+        struct coords : public std::pair<row_t, column_t> {
         public:
+                using base_type = std::pair<row_t, column_t>;
+
                 coords() = default;
-                coords(row_t r, column_t c) : m_row(r), m_column(c) { }
+                coords(row_t r, column_t c) : base_type{r, c} { }
+
+                inline void set_row(row_t r)       { first = r;  }
+                inline void set_column(column_t c) { second = c; }
 
-                inline void set_row(row_t r)       { m_row = r; }
-                inline void set_column(column_t c) { m_column = c; }
+                inline row_t row()       const { return first;  }
+                inline column_t column() const { return second; }
 
-                inline row_t row()       const { return m_row; }
-                inline column_t column() const { return m_column; }
+                IFDEF_DEBUG(char const* to_string() const);
+        };
 
-                inline bool operator == (coords const& rhs) const { return m_row == rhs.m_row && m_column == 
rhs.m_column; }
-                inline bool operator != (coords const& rhs) const { return m_row != rhs.m_row || m_column != 
rhs.m_column; }
+        struct halfcolumn_t : public std::pair<column_t, half_t> {
+        public:
+                using base_type = std::pair<column_t, half_t>;
 
-                inline bool operator <  (coords const& rhs) const { return m_row < rhs.m_row || (m_row == 
rhs.m_row && m_column <  rhs.m_column); }
-                inline bool operator <= (coords const& rhs) const { return m_row < rhs.m_row || (m_row == 
rhs.m_row && m_column <= rhs.m_column); }
-                inline bool operator >  (coords const& rhs) const { return m_row > rhs.m_row || (m_row == 
rhs.m_row && m_column >  rhs.m_column); }
-                inline bool operator >= (coords const& rhs) const { return m_row > rhs.m_row || (m_row == 
rhs.m_row && m_column >= rhs.m_column); }
+                halfcolumn_t() = default;
+                halfcolumn_t(column_t c, half_t h) : base_type{c, h} { }
 
-                IFDEF_DEBUG(char const* to_string() const);
+                inline void set_column(column_t c) { first = c;  }
+                inline void set_half(half_t h)     { second = h; }
 
-        private:
-                row_t m_row;
-                column_t m_column;
+                inline column_t column() const { return first;  }
+                inline half_t half()     const { return second; }
+        };
+
+        struct halfcoords : public std::pair<row_t, halfcolumn_t> {
+        public:
+                using base_type = std::pair<row_t, halfcolumn_t>;
+
+                halfcoords() = default;
+                halfcoords(row_t r, halfcolumn_t hc) : base_type{r, hc} { }
+                halfcoords(row_t r, column_t c, half_t h) : base_type{r, halfcolumn_t(c, h)} { }
+
+                inline void set_row(row_t r)                { first = r;   }
+                inline void set_halfcolumn(halfcolumn_t hc) { second = hc; }
+
+                inline row_t row()               const { return first;  }
+                inline halfcolumn_t halfcolumn() const { return second; }
+
+                IFDEF_DEBUG(char const* to_string() const);
         };
 
         /* end is exclusive (or: start and end point to boundaries between cells) */
@@ -81,6 +103,8 @@ namespace grid {
                 inline coords const& end()   const { return m_end; }
                 inline row_t start_row()       const { return m_start.row(); }
                 inline row_t end_row()         const { return m_end.row(); }
+                /* Get the last row that actually contains characters belonging to this span. */
+                inline row_t last_row()        const { return m_end.column() > 0 ? m_end.row() : m_end.row() 
- 1; }
                 inline column_t start_column() const { return m_start.column(); }
                 inline column_t end_column()   const { return m_end.column(); }
 
@@ -89,6 +113,7 @@ namespace grid {
                 inline explicit operator bool() const { return !empty(); }
 
                 inline bool contains(coords const& p) const { return m_start <= p && p < m_end; }
+                // FIXME make "block" a member of the span? Or subclasses for regular and block spans?
                 inline bool box_contains(coords const& p) const { return m_start.row() <= p.row() && p.row() 
<= m_end.row() &&
                                                                          m_start.column() <= p.column() && 
p.column() < m_end.column(); }
 


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