Example #1
0
    def select(self, selection, flags):
        if isinstance(selection, QModelIndex):
            selection = QItemSelection(selection, selection)

        model = self.model()
        indexes = selection.indexes()
        sel_inds = {ind.row() for ind in indexes} | \
                   {ind.column() for ind in indexes}
        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)
Example #2
0
 def selectvars(varlist, command=selmodel.ClearAndSelect):
     indices = [data.domain.index(var) for var in varlist]
     itemsel = QItemSelection()
     for ind in indices:
         midx = model.index(ind)
         itemsel.select(midx, midx)
     selmodel.select(itemsel, command)
Example #3
0
 def _set_selection(self):
     selection = QItemSelection()
     index = self.tableview.model().index
     for row, col in self.selection:
         sel = index(row + 2, col + 2)
         selection.select(sel, sel)
     self.tableview.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect)
Example #4
0
    def _vizrank_select(self):
        model = self.vizrank.rank_table.model()
        if not model.rowCount():
            return
        selection = QItemSelection()

        # This flag is needed because data in the model could be
        # filtered by a feature and therefore selection could not be found
        selection_in_model = False
        if self.selection:
            sel_names = sorted(name for name, _ in self.selection)
            for i in range(model.rowCount()):
                # pylint: disable=protected-access
                names = sorted(x.name for x in model.data(
                    model.index(i, 0), CorrelationRank._AttrRole))
                if names == sel_names:
                    selection.select(model.index(i, 0),
                                     model.index(i, model.columnCount() - 1))
                    selection_in_model = True
                    break
        if not selection_in_model:
            selection.select(model.index(0, 0),
                             model.index(0, model.columnCount() - 1))
        self.vizrank.rank_table.selectionModel().select(
            selection, QItemSelectionModel.ClearAndSelect)
Example #5
0
 def set_selection(self, selection):
     if selection:
         sel = QItemSelection()
         for row in selection:
             index = self.conc_view.model().index(row, 0)
             sel.select(index, index)
         self.conc_view.selectionModel().select(sel,
             QItemSelectionModel.SelectCurrent | QItemSelectionModel.Rows)
Example #6
0
 def select_correct(self):
     """Select the diagonal elements of the matrix"""
     selection = QItemSelection()
     n = self.tablemodel.rowCount()
     for i in range(2, n):
         index = self.tablemodel.index(i, i)
         selection.select(index, index)
     self.tableview.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect)
Example #7
0
    def selectFiltered(self):
        if not self.data:
            return
        itemSelection = QItemSelection()

        index = self.treeWidget.model().sourceModel().index
        mapFromSource = self.treeWidget.model().mapFromSource
        for i, row in enumerate(self.cells):
            if not self.rowFiltered(i):
                itemSelection.select(mapFromSource(index(i, 0)), mapFromSource(index(i, 0)))
        self.treeWidget.selectionModel().select(itemSelection, QItemSelectionModel.Select | QItemSelectionModel.Rows)
Example #8
0
 def select_wrong(self):
     """Select the off-diagonal elements of the matrix"""
     selection = QItemSelection()
     n = self.tablemodel.rowCount()
     for i in range(2, n):
         for j in range(i + 1, n):
             index = self.tablemodel.index(i, j)
             selection.select(index, index)
             index = self.tablemodel.index(j, i)
             selection.select(index, index)
     self.tableview.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect)
Example #9
0
 def __restore_selection(self):
     """Restore the selection on the table view from saved settings."""
     selection_model = self.table_view.selectionModel()
     selection = QItemSelection()
     if len(self.selected_rows):
         for row in self.model.mapFromSourceRows(self.selected_rows):
             selection.append(QItemSelectionRange(
                 self.model.index(row, 0),
                 self.model.index(row, self.model.columnCount() - 1)
             ))
     selection_model.select(selection, QItemSelectionModel.ClearAndSelect)
        def select(model, selection_model, selected_items):
            all_items = list(model)
            try:
                indices = [all_items.index(item) for item in selected_items]
            except:
                indices = []
            selection = QItemSelection()
            for ind in indices:
                index = model.index(ind)
                selection.select(index, index)

            selection_model.select(selection, QItemSelectionModel.Select)
Example #11
0
 def _vizrank_select(self):
     model = self.vizrank.rank_table.model()
     selection = QItemSelection()
     names = sorted(x.name for x in self.selection)
     for i in range(model.rowCount()):
         # pylint: disable=protected-access
         if sorted(x.name for x in model.data(
                 model.index(i, 0), CorrelationRank._AttrRole)) == names:
             selection.select(model.index(i, 0), model.index(i, 1))
             self.vizrank.rank_table.selectionModel().select(
                 selection, QItemSelectionModel.ClearAndSelect)
             break
Example #12
0
 def update_selection(self, words):
     nonlocal model, proxymodel
     selection = QItemSelection()
     for i, (_, word) in enumerate(model):
         if word in words:
             index = proxymodel.mapFromSource(model.index(i, 1))
             selection.select(index, index)
     self.__nope = True
     self.clearSelection()
     self.selectionModel().select(
         selection,
         QItemSelectionModel.Select | QItemSelectionModel.Rows)
     self.__nope = False
Example #13
0
    def move_rows(self, view, rows, offset):
        model = view.model()
        newrows = [min(max(0, row + offset), len(model) - 1) for row in rows]

        for row, newrow in sorted(zip(rows, newrows), reverse=offset > 0):
            model[row], model[newrow] = model[newrow], model[row]

        selection = QItemSelection()
        for nrow in newrows:
            index = model.index(nrow, 0)
            selection.select(index, index)
        view.selectionModel().select(
            selection, QItemSelectionModel.ClearAndSelect)
Example #14
0
 def __restore_selection(self):
     """Restore the selection on the table view from saved settings."""
     selection_model = self.table_view.selectionModel()
     selection = QItemSelection()
     # self.selected_rows can be list or numpy.array, thus
     # pylint: disable=len-as-condition
     if len(self.selected_rows):
         for row in self.model.mapFromSourceRows(self.selected_rows):
             selection.append(QItemSelectionRange(
                 self.model.index(row, 0),
                 self.model.index(row, self.model.columnCount() - 1)
             ))
     selection_model.select(selection, QItemSelectionModel.ClearAndSelect)
def select_rows(rows: List[int], widget: OWFeatureStatistics):
    """Since the widget sorts the rows, selecting rows isn't trivial."""
    indices = widget.model.mapToSourceRows(rows)

    selection = QItemSelection()
    for idx in indices:
        selection.append(QItemSelectionRange(
            widget.model.index(idx, 0),
            widget.model.index(idx, widget.model.columnCount() - 1)
        ))

    widget.table_view.selectionModel().select(
        selection, QItemSelectionModel.ClearAndSelect)
Example #16
0
    def set_selection(self):
        view = self.doc_list
        if len(self.selection):
            selection = QItemSelection()

            for row in self.selection:
                selection.append(
                    QItemSelectionRange(
                        view.model().index(row, 0),
                        view.model().index(row, 0)
                    )
                )
            view.selectionModel().select(
                selection, QItemSelectionModel.ClearAndSelect)
Example #17
0
def select_rows(view, row_indices, command=QItemSelectionModel.ClearAndSelect):
    """
    Select rows in view.

    :param QAbstractItemView view:
    :param row_indices: Integer indices of rows to select.
    :param command: QItemSelectionModel.SelectionFlags
    """
    selmodel = view.selectionModel()
    model = view.model()
    selection = QItemSelection()
    for row in row_indices:
        index = model.index(row, 0)
        selection.select(index, index)
    selmodel.select(selection, command | QItemSelectionModel.Rows)
    def test_selection(self):
        self.send_signal("Corpus", self.corpus)
        widget = self.widget
        widget.controls.word.setText("of")
        view = self.widget.conc_view

        # Select one row, two are selected, one document on the output
        view.selectRow(1)
        self.assertEqual({ind.row() for ind in view.selectedIndexes()},
                         {0, 1})
        self.assertEqual(self.get_output("Selected Documents"),
                         self.corpus[[1]])

        # Select a single row
        view.selectRow(3)
        self.assertEqual({ind.row() for ind in view.selectedIndexes()},
                         {3})
        self.assertEqual(self.get_output("Selected Documents"),
                         self.corpus[[4]])

        # Add a "double" row, three are selected, two documents on the output
        selection_model = view.selectionModel()
        selection = QItemSelection()
        ind00 = widget.model.index(0, 0)
        selection.select(ind00, ind00)
        selection_model.select(selection, selection_model.Select)
        self.assertEqual({ind.row() for ind in view.selectedIndexes()},
                         {0, 1, 3})
        self.assertEqual(self.get_output("Selected Documents"),
                         self.corpus[[1, 4]])

        # Clear selection by clicking outside
        ind_10 = widget.model.index(-1, 0)
        selection_model.select(ind_10, selection_model.Select)
        self.assertIsNone(self.get_output("Selected Documents"))

        # Selected rows emptied after word change
        view.selectRow(3)
        self.assertTrue(view.selectedIndexes())
        widget.controls.word.setText("o")
        self.assertFalse(view.selectedIndexes())
Example #19
0
 def word_clicked(self, word):
     """Called from JavaScript"""
     if not word:
         self.selected_words.clear()
         return ''
     selection = QItemSelection()
     for i, row in enumerate(self.tablemodel):
         for j, val in enumerate(row):
             if val == word:
                 index = self.tablemodel.index(i, j)
                 selection.select(index, index)
     if word not in self.selected_words:
         self.selected_words.add(word)
         self.tableview.selectionModel().select(
             selection, QItemSelectionModel.Select | QItemSelectionModel.Rows)
         return 'selected'
     else:
         self.selected_words.remove(word)
         self.tableview.selectionModel().select(
             selection, QItemSelectionModel.Deselect | QItemSelectionModel.Rows)
         return ''
Example #20
0
    def set_selection(self):
        if len(self.selected_rows) and len(self.selected_cols):
            view = self.tabs.currentWidget()
            model = view.model()
            if model.rowCount() <= self.selected_rows[-1] or \
                    model.columnCount() <= self.selected_cols[-1]:
                return

            selection = QItemSelection()
            rowranges = list(ranges(self.selected_rows))
            colranges = list(ranges(self.selected_cols))

            for rowstart, rowend in rowranges:
                for colstart, colend in colranges:
                    selection.append(
                        QItemSelectionRange(
                            view.model().index(rowstart, colstart),
                            view.model().index(rowend - 1, colend - 1)
                        )
                    )
            view.selectionModel().select(
                selection, QItemSelectionModel.ClearAndSelect)
Example #21
0
 def select(self, selection, flags):
     # which rows have been selected
     indexes = selection.indexes() if isinstance(selection, QItemSelection) \
               else [selection]
     # prevent crashing when deleting the connection
     if not indexes:
         super().select(selection, flags)
         return
     # indexes[0].row() == -1 indicates clicking outside of the table
     if len(indexes) == 1 and indexes[0].row() == -1:
         self.clear()
         return
     word_index = self.model().word_index
     selected_docs = {word_index[index.row()][0] for index in indexes}
     selected_rows = [
         row_index for row_index, (doc_index, _) in enumerate(word_index)
         if doc_index in selected_docs]
     selection = QItemSelection()
     # select all rows belonging to the selected document
     for row in selected_rows:
         index = self.model().index(row, 0)
         selection.select(index, index)
     super().select(selection, flags)
Example #22
0
    def commit(self, selection: QItemSelection) -> None:
        """Commit the selected tree to output."""
        selected_indices = selection.indexes()

        if not len(selected_indices):
            self.selected_index = None
            self.Outputs.tree.send(None)
            return

        # We only allow selecting a single tree so there will always be one index
        self.selected_index = selected_indices[0].row()

        tree = self.rf_model.trees[self.selected_index]
        tree.instances = self.instances
        tree.meta_target_class_index = self.target_class_index
        tree.meta_size_calc_idx = self.size_calc_idx
        tree.meta_depth_limit = self.depth_limit

        self.Outputs.tree.send(tree)
Example #23
0
 def __cell_entered(self, model_index):
     if self.__clicked_cell is None:
         return
     index = self.table_model.index
     selection = None
     i_end, j_end = model_index.row(), model_index.column()
     i_start, j_start = self.__clicked_cell
     i_start, i_end = sorted([i_start, i_end])
     j_start, j_end = sorted([j_start, j_end])
     if i_start >= self._n_leading_rows and j_start >= self._n_leading_cols:
         i_start = (i_start - self._n_leading_rows) // self._n_agg_func * \
             self._n_agg_func + self._n_leading_rows
         i_end = (i_end - self._n_leading_rows) // self._n_agg_func * \
             self._n_agg_func + self._n_leading_rows + self._n_agg_func - 1
         start, end = index(i_start, j_start), index(i_end, j_end)
         selection = QItemSelection(start, end)
     if selection is not None:
         self.selectionModel().select(selection,
                                      QItemSelectionModel.ClearAndSelect)
     self.selection_changed.emit()
 def test_discrete_editor_rename_selected_items_action(self):
     w = DiscreteVariableEditor()
     v = Categorical("C", ("a", "b", "c"), (("A", "1"), ("B", "b")), False)
     w.set_data_categorical(v, [])
     action = w.rename_selected_items
     view = w.values_edit
     model = view.model()
     selmodel = view.selectionModel()  # type: QItemSelectionModel
     selmodel.select(QItemSelection(model.index(0, 0), model.index(1, 0)),
                     QItemSelectionModel.ClearAndSelect)
     # trigger the action, then find the active popup, and simulate entry
     spy = QSignalSpy(w.variable_changed)
     with patch.object(QComboBox, "setVisible", return_value=None) as m:
         action.trigger()
         m.assert_called()
     cb = view.findChild(QComboBox)
     cb.setCurrentText("BA")
     view.commitData(cb)
     self.assertEqual(model.index(0, 0).data(Qt.EditRole), "BA")
     self.assertEqual(model.index(1, 0).data(Qt.EditRole), "BA")
     self.assertSequenceEqual(list(spy), [[]],
                              'variable_changed should emit exactly once')
Example #25
0
    def set_rf(self, model=None):
        """When a different forest is given."""
        self.closeContext()
        self.clear()
        self.rf_model = model

        if model is not None:
            self.forest = self._get_forest_adapter(self.rf_model)
            self.forest_model[:] = self.forest.trees
            self.instances = model.instances

            self._update_info_box()
            self._update_target_class_combo()
            self._update_depth_slider()

        self.openContext(model)
        # Restore item selection
        if self.selected_index is not None:
            index = self.list_view.model().index(self.selected_index)
            selection = QItemSelection(index, index)
            self.list_view.selectionModel().select(
                selection, QItemSelectionModel.ClearAndSelect)
Example #26
0
    def test_discrete_editor_merge_action(self):
        """
        This function check whether results of dialog have effect on
        merging the attributes. The dialog itself is tested separately.
        """
        w = DiscreteVariableEditor()
        v = Categorical("C", ("a", "b", "c"),
                        (("A", "1"), ("B", "b")))
        w.set_data_categorical(v, [0, 0, 0, 1, 1, 2])

        view = w.values_edit
        model = view.model()
        selmodel = view.selectionModel()  # type: QItemSelectionModel
        selmodel.select(
            QItemSelection(model.index(0, 0), model.index(1, 0)),
            QItemSelectionModel.ClearAndSelect
        )

        # trigger the action, then find the active popup, and simulate entry
        w.merge_items.trigger()

        self.assertEqual(model.index(0, 0).data(Qt.EditRole), "other")
        self.assertEqual(model.index(1, 0).data(Qt.EditRole), "other")
Example #27
0
    def test_discrete_editor_merge_action(self):
        w = DiscreteVariableEditor()
        v = Categorical("C", ("a", "b", "c"), (("A", "1"), ("B", "b")))
        w.set_data(v)
        action = w.merge_items
        self.assertFalse(action.isEnabled())
        view = w.values_edit
        model = view.model()
        selmodel = view.selectionModel()  # type: QItemSelectionModel
        selmodel.select(QItemSelection(model.index(0, 0), model.index(1, 0)),
                        QItemSelectionModel.ClearAndSelect)
        self.assertTrue(action.isEnabled())
        # trigger the action, then find the active popup, and simulate entry
        spy = QSignalSpy(w.variable_changed)
        w.merge_items.trigger()
        cb = w.findChild(QComboBox)
        cb.setCurrentText("BA")
        cb.activated[str].emit("BA")
        cb.close()
        self.assertEqual(model.index(0, 0).data(Qt.EditRole), "BA")
        self.assertEqual(model.index(1, 0).data(Qt.EditRole), "BA")

        self.assertSequenceEqual(list(spy), [[]],
                                 'variable_changed should emit exactly once')
Example #28
0
 def set_selected_items(self, inds):
     index = self.model().index
     selection = QItemSelection()
     for i in inds:
         selection.select(index(i, i), index(i, i))
     self.select(selection, QItemSelectionModel.ClearAndSelect)
Example #29
0
    def autoSelection(self):
        selModel = self.ranksView.selectionModel()
        rowCount = self.ranksModel.rowCount()
        columnCount = self.ranksModel.columnCount()
        model = self.ranksProxyModel

        if self.selectMethod == OWRank.SelectNone:
            selection = QItemSelection()
        elif self.selectMethod == OWRank.SelectAll:
            selection = QItemSelection(
                model.index(0, 0),
                model.index(rowCount - 1, columnCount - 1)
            )
        elif self.selectMethod == OWRank.SelectNBest:
            nSelected = min(self.nSelected, rowCount)
            selection = QItemSelection(
                model.index(0, 0),
                model.index(nSelected - 1, columnCount - 1)
            )
        else:
            selection = QItemSelection()
            if len(self.selected_rows):
                selection = QItemSelection()
                for row in self.selected_rows:
                    selection.append(QItemSelectionRange(
                        model.index(row, 0), model.index(row, columnCount - 1)))

        selModel.select(selection, QItemSelectionModel.ClearAndSelect)
Example #30
0
    def test_resorting_and_selection(self):
        def sortby(col):
            model.sort(col)
            view.horizontalHeader().sectionClicked.emit(col)
            QApplication.processEvents()

        Names, Values, Gain = range(3)

        w = self.widget

        data = Table("heart_disease")
        self.send_signal(w.Inputs.data, data)
        self.wait_until_finished()

        first4 = set(
            sorted((var.name for var in data.domain.attributes),
                   key=str.lower)[:4])

        view = w.ranksView
        model = w.ranksModel
        selModel = view.selectionModel()
        columnCount = model.columnCount()

        w.selectionMethod = w.SelectNBest
        w.nSelected = 4

        # Sort by gain ratio, store selection
        sortby(Gain)
        gain_sel_4 = w.selected_attrs[:]
        self.assertEqual(len(gain_sel_4), 4)

        # Sort by names or number of values: selection unchanged
        sortby(Values)
        self.assertEqual(w.selected_attrs[:], gain_sel_4)

        sortby(Names)
        self.assertEqual(w.selected_attrs[:], gain_sel_4)

        # Select first four (alphabetically)
        w.selectionMethod = w.SelectManual
        selection = QItemSelection(model.index(0, 0),
                                   model.index(3, columnCount - 1))
        selModel.select(selection, QItemSelectionModel.ClearAndSelect)
        # Sanity check
        self.assertEqual({var.name for var in w.selected_attrs}, first4)

        # Manual sorting: sorting by score does not change selection
        sortby(Gain)
        self.assertEqual({var.name for var in w.selected_attrs}, first4)

        # Sort by first four, again
        sortby(Names)
        # Sanity check
        self.assertEqual({var.name for var in w.selected_attrs}, first4)

        w.selectionMethod = w.SelectNBest
        # Sanity check
        self.assertEqual({var.name for var in w.selected_attrs}, first4)

        # Sorting by gain must change selection
        sortby(Gain)
        self.assertEqual(set(w.selected_attrs), set(gain_sel_4))
Example #31
0
    def _select_rows(self):
        model = self.view.model()
        n_rows, n_columns = model.rowCount(), model.columnCount()
        if self.sel_method == SelectionMethods.NONE:
            selection = QItemSelection()
        elif self.sel_method == SelectionMethods.ALL:
            selection = QItemSelection(model.index(0, 0),
                                       model.index(n_rows - 1, n_columns - 1))
        elif self.sel_method == SelectionMethods.MANUAL:
            selection = QItemSelection()
            for i in range(n_rows):
                word = model.data(model.index(i, 0))
                if word in self.selected_words:
                    _selection = QItemSelection(model.index(i, 0),
                                                model.index(i, n_columns - 1))
                    selection.merge(_selection, QItemSelectionModel.Select)
        elif self.sel_method == SelectionMethods.N_BEST:
            n_sel = min(self.n_selected, n_rows)
            selection = QItemSelection(model.index(0, 0),
                                       model.index(n_sel - 1, n_columns - 1))
        else:
            raise NotImplementedError

        self.view.selectionModel().select(selection,
                                          QItemSelectionModel.ClearAndSelect)
Example #32
0
    def select(self, selection, flags):
        """Reimplemented."""
        if isinstance(selection, QModelIndex):
            selection = QItemSelection(selection, selection)

        if not self.__selectBlocks:
            super().select(selection, flags)
            return

        model = self.model()

        def to_ranges(spans):
            return list(range(*r) for r in spans)

        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

        if flags == QItemSelectionModel.ClearAndSelect:
            # extend selection ranges in `selection` to span all row/columns
            sel_rows = selection_rows(selection)
            sel_cols = selection_columns(selection)
            selection = QItemSelection()
            for row_range, col_range in \
                    itertools.product(to_ranges(sel_rows), to_ranges(sel_cols)):
                selection.select(
                    model.index(row_range.start, col_range.start),
                    model.index(row_range.stop - 1, col_range.stop - 1)
                )
        elif flags & (QItemSelectionModel.Select |
                      QItemSelectionModel.Deselect):
            # extend all selection ranges in `selection` with the full current
            # row/col spans
            rows, cols = selection_blocks(self.selection())
            sel_rows = selection_rows(selection)
            sel_cols = selection_columns(selection)
            ext_selection = QItemSelection()
            for row_range, col_range in \
                    itertools.product(to_ranges(rows), to_ranges(sel_cols)):
                ext_selection.select(
                    model.index(row_range.start, col_range.start),
                    model.index(row_range.stop - 1, col_range.stop - 1)
                )
            for row_range, col_range in \
                    itertools.product(to_ranges(sel_rows), to_ranges(cols)):
                ext_selection.select(
                    model.index(row_range.start, col_range.start),
                    model.index(row_range.stop - 1, col_range.stop - 1)
                )
            selection.merge(ext_selection, QItemSelectionModel.Select)
        super().select(selection, flags)
Example #33
0
    def select(self, selection, flags):
        """Reimplemented."""
        if isinstance(selection, QModelIndex):
            selection = QItemSelection(selection, selection)

        model = self.model()
        indexes = self.selectedIndexes()

        rows = set(ind.row() for ind in indexes)
        cols = set(ind.column() for ind in indexes)

        if flags & QItemSelectionModel.Select and \
                not flags & QItemSelectionModel.Clear and self.__selectBlocks:
            indexes = selection.indexes()
            sel_rows = set(ind.row() for ind in indexes).union(rows)
            sel_cols = set(ind.column() for ind in indexes).union(cols)

            selection = QItemSelection()

            for r_start, r_end in ranges(sorted(sel_rows)):
                for c_start, c_end in ranges(sorted(sel_cols)):
                    top_left = model.index(r_start, c_start)
                    bottom_right = model.index(r_end - 1, c_end - 1)
                    selection.select(top_left, bottom_right)
        elif self.__selectBlocks and flags & QItemSelectionModel.Deselect:
            indexes = selection.indexes()

            def to_ranges(indices):
                return list(range(*r) for r in ranges(indices))

            selected_rows = to_ranges(sorted(rows))
            selected_cols = to_ranges(sorted(cols))

            desel_rows = to_ranges(set(ind.row() for ind in indexes))
            desel_cols = to_ranges(set(ind.column() for ind in indexes))

            selection = QItemSelection()

            # deselection extended vertically
            for row_range, col_range in \
                    itertools.product(selected_rows, desel_cols):
                selection.select(
                    model.index(row_range.start, col_range.start),
                    model.index(row_range.stop - 1, col_range.stop - 1)
                )
            # deselection extended horizontally
            for row_range, col_range in \
                    itertools.product(desel_rows, selected_cols):
                selection.select(
                    model.index(row_range.start, col_range.start),
                    model.index(row_range.stop - 1, col_range.stop - 1)
                )

        QItemSelectionModel.select(self, selection, flags)
Example #34
0
 def _set_selected_words(self, indices: List[int]):
     selection = QItemSelection()
     sel_model: QItemSelectionModel = self.words_view.selectionModel()
     for i in indices:
         selection.append(QItemSelectionRange(self.words_model.index(i, 0)))
     sel_model.select(selection, QItemSelectionModel.ClearAndSelect)
Example #35
0
 def select_tree(self, idx: int) -> None:
     list_view = self.widget.list_view
     index = list_view.model().index(idx)
     selection = QItemSelection(index, index)
     list_view.selectionModel().select(selection, QItemSelectionModel.ClearAndSelect)
Example #36
0
 def itsel(self, rows):
     sel = QItemSelection()
     for row in rows:
         index = self.store.proxy.index(row, 0)
         sel.select(index, index)
     return sel
Example #37
0
    def select(self, selection, flags):
        """Reimplemented."""
        if isinstance(selection, QModelIndex):
            selection = QItemSelection(selection, selection)

        if not self.__selectBlocks:
            super().select(selection, flags)
            return

        model = self.model()

        def to_ranges(spans):
            return list(range(*r) for r in spans)

        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

        if flags == QItemSelectionModel.ClearAndSelect:
            # extend selection ranges in `selection` to span all row/columns
            sel_rows = selection_rows(selection)
            sel_cols = selection_columns(selection)
            selection = QItemSelection()
            for row_range, col_range in \
                    itertools.product(to_ranges(sel_rows), to_ranges(sel_cols)):
                selection.select(
                    model.index(row_range.start, col_range.start),
                    model.index(row_range.stop - 1, col_range.stop - 1)
                )
        elif flags & (QItemSelectionModel.Select |
                      QItemSelectionModel.Deselect):
            # extend all selection ranges in `selection` with the full current
            # row/col spans
            rows, cols = selection_blocks(self.selection())
            sel_rows = selection_rows(selection)
            sel_cols = selection_columns(selection)
            ext_selection = QItemSelection()
            for row_range, col_range in \
                    itertools.product(to_ranges(rows), to_ranges(sel_cols)):
                ext_selection.select(
                    model.index(row_range.start, col_range.start),
                    model.index(row_range.stop - 1, col_range.stop - 1)
                )
            for row_range, col_range in \
                    itertools.product(to_ranges(sel_rows), to_ranges(cols)):
                ext_selection.select(
                    model.index(row_range.start, col_range.start),
                    model.index(row_range.stop - 1, col_range.stop - 1)
                )
            selection.merge(ext_selection, QItemSelectionModel.Select)
        super().select(selection, flags)
Example #38
0
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))
Example #39
0
 def set_selected_items(self, inds):
     index = self.model().index
     selection = QItemSelection()
     for i in inds:
         selection.select(index(i, i), index(i, i))
     self.select(selection, QItemSelectionModel.ClearAndSelect)
Example #40
0
    def _select_rows(self):
        proxy_model = self.view.model()
        n_rows, n_columns = proxy_model.rowCount(), proxy_model.columnCount()
        if self.sel_method == SelectionMethods.NONE:
            selection = QItemSelection()
        elif self.sel_method == SelectionMethods.ALL:
            selection = QItemSelection(
                proxy_model.index(0, 0),
                proxy_model.index(n_rows - 1, n_columns - 1))
        elif self.sel_method == SelectionMethods.MANUAL:
            selection = QItemSelection()
            new_sel = []
            for row in self.selected_rows:
                if row < n_rows:
                    new_sel.append(row)
                    _selection = QItemSelection(
                        self.model.index(row, 0),
                        self.model.index(row, n_columns - 1))
                    selection.merge(
                        proxy_model.mapSelectionFromSource(_selection),
                        QItemSelectionModel.Select,
                    )
            # selected rows must be updated when the same dataset with less rows
            # appear at the input - it is not handled by selectionChanged
            # in cases when all selected rows missing in new table
            self.selected_rows = new_sel
        elif self.sel_method == SelectionMethods.N_BEST:
            n_sel = min(self.n_selected, n_rows)
            selection = QItemSelection(
                proxy_model.index(0, 0),
                proxy_model.index(n_sel - 1, n_columns - 1))
        else:
            raise NotImplementedError

        self.view.selectionModel().select(selection,
                                          QItemSelectionModel.ClearAndSelect)