SymmetricSelectionModel: Optimize selection

Operate on selection ranges not on indices

Author: ales-erjavec

Orange/widgets/unsupervised/owdistancematrix.py

@@ -168,12 +168,12 @@ def settings_from_widget(self, widget, *args):
         context = widget.current_context
         if context is not None:
             context.annotation = widget.annot_combo.currentText()
-            context.selection = widget.tableview.selectionModel().selected_items()
+            context.selection = widget.tableview.selectionModel().selectedItems()
 
     def settings_to_widget(self, widget, *args):
         context = widget.current_context
         widget.annotation_idx = context.annotations.index(context.annotation)
-        widget.tableview.selectionModel().set_selected_items(context.selection)
+        widget.tableview.selectionModel().setSelectedItems(context.selection)
 
 
 class OWDistanceMatrix(widget.OWWidget):
@@ -245,7 +245,7 @@ def set_distances(self, distances):
         self.distances = distances
         self.tablemodel.set_data(self.distances)
         self.selection = []
-        self.tableview.selectionModel().set_selected_items([])
+        self.tableview.selectionModel().clear()
 
         self.items = items = distances is not None and distances.row_items
         annotations = ["None", "Enumerate"]
@@ -291,7 +291,7 @@ def _update_labels(self):
             var = self.annot_combo.model()[self.annotation_idx]
             column, _ = self.items.get_column_view(var)
             labels = [var.str_val(value) for value in column]
-        saved_selection = self.tableview.selectionModel().selected_items()
+        saved_selection = self.tableview.selectionModel().selectedIndices()
         self.tablemodel.set_labels(labels, var, column)
         if labels:
             self.tableview.horizontalHeader().show()
@@ -305,7 +305,7 @@ def _update_labels(self):
     def commit(self):
         sub_table = sub_distances = None
         if self.distances is not None:
-            inds = self.tableview.selectionModel().selected_items()
+            inds = self.tableview.selectionModel().selectedItems()
             if inds:
                 sub_distances = self.distances.submatrix(inds)
                 if self.distances.axis and isinstance(self.items, Table):

Orange/widgets/utils/itemselectionmodel.py

@@ -1,5 +1,7 @@
-from itertools import chain, product, groupby
-from typing import List, Tuple, Iterable, Optional, Union
+from itertools import chain, starmap, product, groupby, islice
+from functools import reduce
+from operator import itemgetter
+from typing import List, Tuple, Iterable, Sequence, Optional, Union
 
 from AnyQt.QtCore import (
     QModelIndex, QAbstractItemModel, QItemSelectionModel, QItemSelection,
@@ -169,39 +171,95 @@ def ranges(indices):
         yield start, end + 1
 
 
+def merge_ranges(
+        ranges: Iterable[Tuple[int, int]]
+) -> Sequence[Tuple[int, int]]:
+    def merge_range_seq_accum(
+            accum: List[Tuple[int, int]], r: Tuple[int, int]
+    ) -> List[Tuple[int, int]]:
+        last_start, last_stop = accum[-1]
+        r_start, r_stop = r
+        assert last_start <= r_start
+        if r_start <= last_stop:
+            # merge into last
+            accum[-1] = last_start, max(last_stop, r_stop)
+        else:
+            # push a new (disconnected) range interval
+            accum.append(r)
+        return accum
+
+    ranges = sorted(ranges, key=itemgetter(0))
+    if ranges:
+        return reduce(merge_range_seq_accum, islice(ranges, 1, None),
+                      [ranges[0]])
+    else:
+        return []
+
+
+def qitemselection_select_range(
+        selection: QItemSelection,
+        model: QAbstractItemModel,
+        rows: range,
+        columns: range
+) -> None:
+    assert rows.step == 1 and columns.step == 1
+    selection.select(
+        model.index(rows.start, columns.start),
+        model.index(rows.stop - 1, columns.stop - 1)
+    )
+
+
 class SymmetricSelectionModel(QItemSelectionModel):
-    def select(self, selection, flags):
+    """
+    Item selection model ensuring the selection is symmetric
+
+    """
+    def select(self, selection: Union[QItemSelection, QModelIndex],
+               flags: QItemSelectionModel.SelectionFlags) -> None:
+        def to_ranges(rngs: Iterable[Tuple[int, int]]) -> Sequence[range]:
+            return list(starmap(range, rngs))
         if isinstance(selection, QModelIndex):
             selection = QItemSelection(selection, selection)
 
+        if flags & QItemSelectionModel.Current:  # no current selection support
+            flags &= ~QItemSelectionModel.Current
+        if flags & QItemSelectionModel.Toggle:  # no toggle support either
+            flags &= ~QItemSelectionModel.Toggle
+            flags |= QItemSelectionModel.Select
+
         model = self.model()
-        indexes = selection.indexes()
-        sel_inds = {ind.row() for ind in indexes} | \
-                   {ind.column() for ind in indexes}
+        rows, cols = selection_blocks(selection)
+        sym_ranges = to_ranges(merge_ranges(chain(rows, cols)))
         if flags == QItemSelectionModel.ClearAndSelect:
-            selected = set()
-        else:
-            selected = {ind.row() for ind in self.selectedIndexes()}
-        if flags & QItemSelectionModel.Select:
-            selected |= sel_inds
-        elif flags & QItemSelectionModel.Deselect:
-            selected -= sel_inds
-        new_selection = QItemSelection()
-        regions = list(ranges(sorted(selected)))
-        for r_start, r_end in regions:
-            for c_start, c_end in regions:
-                top_left = model.index(r_start, c_start)
-                bottom_right = model.index(r_end - 1, c_end - 1)
-                new_selection.select(top_left, bottom_right)
-        QItemSelectionModel.select(self, new_selection,
-                                   QItemSelectionModel.ClearAndSelect)
-
-    def selected_items(self):
-        return list({ind.row() for ind in self.selectedIndexes()})
-
-    def set_selected_items(self, inds):
-        index = self.model().index
+            # extend ranges in `selection` to symmetric selection
+            # row/columns.
+            selection = QItemSelection()
+            for rows, cols in product(sym_ranges, sym_ranges):
+                qitemselection_select_range(selection, model, rows, cols)
+        elif flags & (QItemSelectionModel.Select |
+                      QItemSelectionModel.Deselect):
+            # extend ranges in sym_ranges to span all current rows/columns
+            rows_current, cols_current = selection_blocks(self.selection())
+            ext_selection = QItemSelection()
+            for rrange, crange in product(sym_ranges, sym_ranges):
+                qitemselection_select_range(selection, model, rrange, crange)
+            for rrange, crange in product(sym_ranges, to_ranges(cols_current)):
+                qitemselection_select_range(selection, model, rrange, crange)
+            for rrange, crange in product(to_ranges(rows_current), sym_ranges):
+                qitemselection_select_range(selection, model, rrange, crange)
+            selection.merge(ext_selection, QItemSelectionModel.Select)
+        super().select(selection, flags)
+
+    def selectedItems(self) -> Sequence[int]:
+        """Return the indices of the the symmetric selection."""
+        ranges_ = starmap(range, selection_rows(self.selection()))
+        return sorted(chain.from_iterable(ranges_))
+
+    def setSelectedItems(self, inds: Iterable[int]):
+        """Set and select the `inds` indices"""
+        model = self.model()
         selection = QItemSelection()
-        for i in inds:
-            selection.select(index(i, i), index(i, i))
+        sym_ranges = to_ranges(ranges(inds))
+        for rows, cols in product(sym_ranges, sym_ranges):
+            qitemselection_select_range(selection, model, rows, cols)
         self.select(selection, QItemSelectionModel.ClearAndSelect)

Orange/widgets/utils/tests/test_itemselectionmodel.py

@@ -4,14 +4,15 @@
 from AnyQt.QtCore import QItemSelectionModel
 from AnyQt.QtGui import QStandardItemModel
 
-from Orange.widgets.utils.itemselectionmodel import BlockSelectionModel
+from Orange.widgets.utils.itemselectionmodel import BlockSelectionModel, \
+    SymmetricSelectionModel
 
 
 def selected(sel: QItemSelectionModel) -> Set[Tuple[int, int]]:
     return set((r.row(), r.column()) for r in sel.selectedIndexes())
 
 
-class BlockSelectionModelTest(TestCase):
+class TestBlockSelectionModel(TestCase):
     def test_blockselectionmodel(self):
         model = QStandardItemModel()
         model.setRowCount(4)
@@ -27,3 +28,23 @@ def test_blockselectionmodel(self):
         self.assertSetEqual(selected(sel), {(1, 1)})
         sel.select(model.index(3, 3), BlockSelectionModel.ClearAndSelect)
         self.assertSetEqual(selected(sel), {(3, 3)})
+
+
+class TestSymmetricSelectionModel(TestCase):
+    def test_symmetricselectionmodel(self):
+        model = QStandardItemModel()
+        model.setRowCount(4)
+        model.setColumnCount(4)
+        sel = SymmetricSelectionModel(model)
+        sel.select(model.index(0, 0), BlockSelectionModel.Select)
+        self.assertSetEqual(selected(sel), {(0, 0)})
+        sel.select(model.index(0, 2), BlockSelectionModel.Select)
+        self.assertSetEqual(selected(sel), {(0, 0), (0, 2), (2, 0), (2, 2)})
+        sel.select(model.index(0, 0), BlockSelectionModel.Deselect)
+        self.assertSetEqual(selected(sel), {(2, 2)})
+        sel.select(model.index(2, 3), BlockSelectionModel.ClearAndSelect)
+        self.assertSetEqual(selected(sel), {(2, 2), (2, 3), (3, 2), (3, 3)})
+
+        self.assertSetEqual(set(sel.selectedItems()), {2, 3})
+        sel.setSelectedItems([1, 2])
+        self.assertSetEqual(set(sel.selectedItems()), {1, 2})