Пример #1
0
    def on_selectionChanged(self):
        """
        Runs when cells are selected in the Header. This selects columns in the data table when the header is clicked,
        and then calls selectAbove()
        """
        # Check focus so we don't get recursive loop, since headers trigger selection of data cells and vice versa
        if self.hasFocus():
            dataView = self.parent().dataView

            # Set selection mode so selecting one row or column at a time adds to selection each time
            if (
                    self.orientation == Qt.Horizontal
            ):  # This case is for the horizontal header
                # Get the header's selected columns
                selection = self.selectionModel().selection()

                # Removes the higher levels so that only the lowest level of the header affects the data table selection
                last_row_ix = self.pgdf.dataframe.columns.nlevels - 1
                last_col_ix = self.model().columnCount() - 1
                higher_levels = QtCore.QItemSelection(
                    self.model().index(0, 0),
                    self.model().index(last_row_ix - 1, last_col_ix),
                )
                selection.merge(higher_levels, QtCore.QItemSelectionModel.Deselect)

                # Select the cells in the data view
                dataView.selectionModel().select(
                    selection,
                    QtCore.QItemSelectionModel.Columns
                    | QtCore.QItemSelectionModel.ClearAndSelect,
                )
            if self.orientation == Qt.Vertical:
                selection = self.selectionModel().selection()

                last_row_ix = self.model().rowCount() - 1
                last_col_ix = self.pgdf.dataframe.index.nlevels - 1
                higher_levels = QtCore.QItemSelection(
                    self.model().index(0, 0),
                    self.model().index(last_row_ix, last_col_ix - 1),
                )
                selection.merge(higher_levels, QtCore.QItemSelectionModel.Deselect)

                dataView.selectionModel().select(
                    selection,
                    QtCore.QItemSelectionModel.Rows
                    | QtCore.QItemSelectionModel.ClearAndSelect,
                )

        self.selectAbove()
Пример #2
0
    def select(self, selection, command):
        '''
        overwrite the select function
        selection is either a QModelIndex, (handled normally),
        or a QItemSelection
        '''
        if isinstance(selection, QtCore.QModelIndex):
            QtCore.QItemSelectionModel.select(self, selection, command)
            return
        if len(selection.indexes()) > 2:
            LOGGER.debug("restricting appointment selection to 2 items")
            new_selection = QtCore.QItemSelection()
            new_selection.append(
                QtCore.QItemSelectionRange(selection.indexes()[0]))
            new_selection.append(
                QtCore.QItemSelectionRange(selection.last().indexes()[0]))
            selection = new_selection

        # now some openmolar specific code... I want scheduled appointment
        # to take priority
        if len(selection.indexes()) == 2:
            index1, index2 = selection.indexes()
            app1 = index1.model().data(index1, QtCore.Qt.UserRole)
            app2 = index2.model().data(index2, QtCore.Qt.UserRole)
            swap_required = app1.unscheduled and not app2.unscheduled
            LOGGER.debug("swap required = %s", swap_required)
            if swap_required:
                selection.swap(0, 1)
            if app1.dent == app2.dent:
                # joint appointments are dumb if dentist is the same!
                selection.removeAt(1)

        # send via base class
        QtCore.QItemSelectionModel.select(self, selection, command)
Пример #3
0
    def _sync_api_selection_to_grid(self, rows: T.List[int],
                                    changed: bool) -> None:
        if self._collect_rows() == self._api.subs.selected_indexes:
            return

        self.setUpdatesEnabled(False)

        self.selectionModel().selectionChanged.disconnect(
            self._sync_grid_selection_to_api)

        selection = QtCore.QItemSelection()
        for row in self._api.subs.selected_indexes:
            idx = self.model().index(row, 0)
            selection.select(idx, idx)

        self.selectionModel().clear()

        if self._api.subs.selected_indexes:
            first_row = self._api.subs.selected_indexes[0]
            cell_index = self.model().index(first_row, 0)
            self.setCurrentIndex(cell_index)
            self.scrollTo(cell_index)

        self.selectionModel().select(
            selection,
            QtCore.QItemSelectionModel.Rows
            | QtCore.QItemSelectionModel.Current
            | QtCore.QItemSelectionModel.Select,
        )

        self.selectionModel().selectionChanged.connect(
            self._sync_grid_selection_to_api)

        self.setUpdatesEnabled(True)
Пример #4
0
    def select(self, selection, command):
        '''
        overwrite the select function
        selection is either a QModelIndex, (handled normally),
        or a QItemSelection
        '''
        self.is_reversed = False
        LOGGER.debug("DoubleRowSelectionModel.select %s,%s", selection,
                     command)
        if isinstance(selection, QtCore.QModelIndex):
            LOGGER.debug("Model Index selected")
        elif len(selection.indexes()) >= 2:
            LOGGER.debug("restricting appointment selection to 2 items")
            new_selection = QtCore.QItemSelection()
            index1 = selection.indexes()[0]
            index2 = self.currentIndex()
            if index2.row() == index1.row():
                index2 = selection.last().indexes()[-1]
                self.is_reversed = True
            new_selection.append(QtCore.QItemSelectionRange(index1))
            new_selection.append(QtCore.QItemSelectionRange(index2))
            selection = new_selection
        else:
            for index in selection.indexes():
                LOGGER.debug("index = %s", index)

        QtCore.QItemSelectionModel.select(self, selection, command)
Пример #5
0
 def onOpenMeasurementLog(self, traceCreationList):
     """Called when traceui emits signal to open the corresponding measurement log entry"""
     self.show()
     self.raise_()
     self.activateWindow()
     measurementDict = self.measurementModel.container.measurementDict
     measurements = self.measurementModel.measurements
     selection = QtCore.QItemSelection()
     self.measurementTableView.selectionModel().select(
         selection, QtCore.QItemSelectionModel.Clear)  #clear selection
     leftInd = None
     for traceCreation in traceCreationList:
         measurement = measurementDict.get(traceCreation)
         row = measurements.index(
             measurement) if measurement in measurements else -1
         if row >= 0:
             leftInd = self.measurementModel.index(row, 0)
             rightInd = self.measurementModel.index(
                 row,
                 self.measurementModel.columnCount() - 1)
             selection.select(
                 leftInd,
                 rightInd)  #add the specified measurement to the selection
     self.measurementTableView.selectionModel().select(
         selection,
         QtCore.QItemSelectionModel.Select)  #select full selection
     if leftInd:
         self.measurementTableView.scrollTo(
             leftInd)  #scroll to left column of last measurement in list
     self.measurementTableView.setFocus(True)
Пример #6
0
 def save_entry(self, apply_capitalization=False):
     new_row = self.editor.entry()
     new_id = self.model.create_entry(
         apply_capitalization=apply_capitalization, **new_row)
     self.table.update()
     if DEBUG:
         sys.stdout.write(("new_id {0}".format(new_id)) + os.linesep)
     for row in range(self.model.rowCount()):
         new_index = self.table.model().index(row, 0)
         if self.model.data(new_index) == new_id:
             if DEBUG:
                 sys.stdout.write(
                     ("new_index {0}, row {1}".format(new_index, row)) +
                     os.linesep)
             break
     else:
         row = None
         if DEBUG:
             sys.stdout.write("row not found" + os.linesep)
     if row is not None:
         selection = core.QItemSelection()
         selection.append(
             core.QItemSelectionRange(
                 self.table.model().index(new_index.row(), 0),
                 self.table.model().index(
                     new_index.row(),
                     self.table.model().columnCount() - 1)))
         self.table.selectionModel().select(
             selection, core.QItemSelectionModel.ClearAndSelect)
         self.table.scrollTo(new_index)
     self.editor.update_completer(new_row['activity'])
     self._db.save_changes()
     self.update_interface()
     core.QTimer.singleShot(0, partial(self.clear_entry, False))
 def load_checklists(self, checklists: typing.List[models.CheckList]):
     self.checklists_tv.selectionModel().select(
         QtCore.QItemSelection(), QtCore.QItemSelectionModel.Clear)
     self.model.clear()
     self.model.setHorizontalHeaderLabels([
         i.name.replace('_', ' ').capitalize() for i in ChecklistModelColumn
     ])
     for row_index, checklist in enumerate(checklists):
         checklist: models.CheckList
         identifier_item = QtGui.QStandardItem(str(checklist.identifier))
         identifier_item.setData(
             checklist,
             role=CustomDataRoles.CHECKLIST_DOWNLOADER_IDENTIFIER.value)
         self.model.setItem(row_index,
                            ChecklistModelColumn.IDENTIFIER.value,
                            identifier_item)
         self.model.setItem(row_index, ChecklistModelColumn.NAME.value,
                            QtGui.QStandardItem(checklist.name))
         self.model.setItem(
             row_index, ChecklistModelColumn.DATASET_TYPE.value,
             QtGui.QStandardItem(checklist.dataset_type.value))
         self.model.setItem(
             row_index, ChecklistModelColumn.APPLICABLE_TO.value,
             QtGui.QStandardItem(checklist.validation_artifact_type.value))
     # self.checklists_tv.setModel(self.model)
     self.checklists_tv.setColumnHidden(
         ChecklistModelColumn.IDENTIFIER.value, True)
     header = self.checklists_tv.header()
     header.setSectionResizeMode(1, QtWidgets.QHeaderView.ResizeToContents)
Пример #8
0
 def selectImage(self, row):
     sel_model = self.ui.images_tbl.selectionModel()
     index1 = self.image_model.index(row, 0)
     index2 = self.image_model.index(row, ImagesModel.COLUMNS - 1)
     sel_model.select(
         QtCore.QItemSelection(index1, index2),
         QtCore.QItemSelectionModel.ClearAndSelect
         | QtCore.QItemSelectionModel.Current)
Пример #9
0
 def select_all(self):
     row_count = self.filter_model.rowCount()
     column_count = self.filter_model.columnCount()
     topLeft = self.filter_model.index(0, 0)
     bottomRight = self.filter_model.index(row_count - 1, column_count - 1)
     selection = QtCore.QItemSelection(topLeft, bottomRight)
     self.view.selectionModel().select(selection,
                                       QtCore.QItemSelectionModel.Select)
Пример #10
0
 def _handle_select_all_measurements(self):
     row_count = self._measurement_model.rowCount()
     column_count = self._measurement_model.columnCount()
     topLeft = self._measurement_model.index(0, 0)
     bottomRight = self._measurement_model.index(row_count - 1,
                                                 column_count - 1)
     selection = QtCore.QItemSelection(topLeft, bottomRight)
     self.measurement_view.view.selectionModel().select(
         selection, QtCore.QItemSelectionModel.Select)
Пример #11
0
    def _apply_selection_to_full_row(self):
        rows = list()
        selection = QtCore.QItemSelection()
        for idx in self.selectedIndexes():
            if idx.row() not in rows:
                rows.append(idx.row())
                selection.append(QtWidgets.QItemSelectionRange(idx))

        self.selectionModel().select(selection,
                                     QtCore.QItemSelectionModel.Rows | QtCore.QItemSelectionModel.ClearAndSelect)
Пример #12
0
    def __select_row(self, row_idx):
        left_idx = self.model.index(row_idx, 0, QtCore.QModelIndex())
        right_idx = self.model.index(row_idx, self.model.columnCount() - 1)
        row_selection = QtCore.QItemSelection()
        row_selection.select(left_idx, right_idx)

        self.selection_model.setCurrentIndex(
            left_idx, QtCore.QItemSelectionModel.Rows)
        self.selection_model.select(
            row_selection, QtCore.QItemSelectionModel.Select)
Пример #13
0
 def __updateSelectionInView(self, page):
     """ Makes the current selection in internal widget used to display the
     data values """
     selModel = self._tableView.selectionModel()
     if selModel is not None:
         pageSize = self._pagingInfo.pageSize
         m = self._pageItemModel
         sel = qtc.QItemSelection()
         for row in range(page * pageSize, (page + 1) * pageSize):
             if row in self._selection:
                 sel.append(
                     qtc.QItemSelectionRange(
                         m.index(row % pageSize, 0),
                         m.index(row % pageSize,
                                 m.columnCount() - 1)))
         allSel = qtc.QItemSelection(
             m.index(0, 0), m.index(pageSize - 1,
                                    m.columnCount() - 1))
         selModel.select(allSel, qtc.QItemSelectionModel.Deselect)
         if not sel.isEmpty():
             selModel.select(sel, qtc.QItemSelectionModel.Select)
Пример #14
0
 def _move(self, rows: List[int], diff: int) -> None:
     for row in rows:
         item = self.to_model.takeItem(row, 0)
         self.to_model.removeRow(row)
         self.to_model.insertRow(row + diff, item)
     selection = C.QItemSelection()
     for row in rows:
         index = self.to_model.index(row + diff, 0)
         selection.select(index, index)
     self.to_list.selectionModel().select(
         selection, C.QItemSelectionModel.ClearAndSelect)
     self.load_pictures_task.run()
Пример #15
0
    def select_by_colnames(self, cnames):
        new_selection = QtCore.QItemSelection()
        flags = (QtCore.QItemSelectionModel.Select
                 | QtCore.QItemSelectionModel.Rows)
        for c in cnames:
            index = self.model().match(self.model().index(0, 0),
                                       TwoLevelTreeModel.SubDataRole, c, 1,
                                       QtCore.Qt.MatchRecursive)
            for ind in index:
                new_selection.select(ind, ind)

        self.selectionModel().clearSelection()
        self.selectionModel().select(new_selection, flags)
Пример #16
0
    def onModelItemsReordered(self):
        new_selection = QtCore.QItemSelection()
        new_index = QtCore.QModelIndex()
        for item in self.model().lastDroppedItems:
            row = self.model().rowForItem(item)
            if row is None:
                continue
            new_index = self.model().index(row, 0, QtCore.QModelIndex())
            new_selection.select(new_index, new_index)

        self.clearSelection()
        flags = QtCore.QItemSelectionModel.ClearAndSelect | \
                QtCore.QItemSelectionModel.Rows | \
                QtCore.QItemSelectionModel.Current
        self.select(new_selection, flags)
        self.setCurrentIndex(new_index, flags)
Пример #17
0
 def set_chosen_2nd_slot(self, slot):
     '''
     user has clicked on a secondary slot - we need to switch the
     appointments over!
     '''
     LOGGER.debug("set_chosen_2nd_slot %s", slot)
     model = self.appointment_model.selection_model
     selection = model.selection()
     selection.swap(0, 1)
     model.select(selection, model.ClearAndSelect)
     self.selection_changed(
         self.appointment_model.selection_model.selection())
     self.appointment_model.selection_model.emitSelectionChanged(
         selection, QtCore.QItemSelection())
     slot.is_primary = True
     self.set_chosen_slot(slot)
     self.chosen_slot_changed.emit()
Пример #18
0
 def set_selected_appointments(self, selected_apps):
     '''
     programatically make a selection (to sync with other ways of selecting
     an appointment, eg pt_diary)
     '''
     selection = QtCore.QItemSelection()
     # for app in sorted(selected_apps,
     #                   key=lambda x: x.unscheduled, reverse=True):
     for app in selected_apps:
         LOGGER.debug("Need to reselect appointment %s", app)
         try:
             row = self.items.index(app)
             index = self.index(row)
             selection.append(QtCore.QItemSelectionRange(index))
         except ValueError:  # app not in list
             pass
     self.selection_model.select(selection,
                                 QtCore.QItemSelectionModel.Select)
Пример #19
0
 def lines_updated_restore_selection(self):
     selection_model = self.selectionModel()
     indexes = [
         self.log_model.index_from_revid(revid)
         for revid in self.lines_updated_selection
     ]
     selection_model.clear()
     if self.lines_updated_selection_current:
         current_index = self.log_model.index_from_revid(
             self.lines_updated_selection_current)
         if current_index:
             self.setCurrentIndex(current_index)
     if not len(indexes) == 0 and indexes[0]:
         if not indexes[1]:
             indexes[1] = indexes[0]
         selection = QtCore.QItemSelection(*indexes)
         selection_model.select(selection,
                                (QtCore.QItemSelectionModel.SelectCurrent
                                 | QtCore.QItemSelectionModel.Rows))
Пример #20
0
 def select_tree_item(self, item):
     selectionModel = self.classTree.selectionModel()
     flags = QtCore.QItemSelectionModel.Select | QtCore.QItemSelectionModel.Rows
     selected = QtCore.QItemSelection()
     if item.parent() is None:
         index = self.classModel.indexFromItem(item)
     else:
         category_item = item.parent()
         rows = category_item.rowCount()
         category_index = self.classModel.indexFromItem(category_item)
         row = 0
         for i in range(rows):
             child = category_item.child(i, 0)
             if child.data(0) == item.data(0):
                 row = i
                 break
         index = self.classModel.index(row, 0, category_index)
     selectionModel.clearSelection()
     selectionModel.select(index, flags)
     self.classTree.setCurrentIndex(index)
Пример #21
0
    def _el_group_view_sel_change(self, selected, deselected):
        if self._selection_disable:
            return

        sm = self.el_group_view.view.selectionModel()
        rows = [r.row() for r in sm.selectedRows()]

        m_ids = set()
        for r in rows:
            m_ids = m_ids.union(set(self._electrode_groups[r].measurement_ids))

        sm = self.measurement_view.view.selectionModel()
        self._selection_disable = True
        sm.clear()
        for i in m_ids:
            column_count = self._measurement_model.columnCount()
            topLeft = self._measurement_model.index(i, 0)
            bottomRight = self._measurement_model.index(i, column_count - 1)
            selection = QtCore.QItemSelection(topLeft, bottomRight)
            sm.select(selection, QtCore.QItemSelectionModel.Select)
        self._selection_disable = False
Пример #22
0
    def move_contrib_row_up(self):
        if (self.contributorModel.rowCount() < 2):
            TDBUtil.make_msgbox("", "need at least 2 rows to move",
                                QtWidgets.QMessageBox.Information)
            return
        sel_idxs = self.tableViewContributor.selectedIndexes()
        if (len(sel_idxs) > 0):
            curr_row_model_index = sel_idxs[0]
            active_row = curr_row_model_index.row()
            active_col = curr_row_model_index.column()
            if (active_row == 0):
                print("Top most row - cannot move further")
                return
            curr_item_list = self.contributorModel.takeRow(active_row)
            self.contributorModel.insertRow(active_row - 1, curr_item_list)
            #selection code
            sel_model = self.tableViewContributor.selectionModel()

            # recompute mi from model
            print("---------")
            print("({},{})".format(active_row, active_col))
            print("({},{})".format(active_row - 1, active_col))
            # active_row = curr_row_model_index.row()
            # active_col = curr_row_model_index.column()

            model_index_topLeft = self.contributorModel.index(
                active_row - 1, active_col, QtCore.QModelIndex())
            model_index_topRight = self.contributorModel.index(
                active_row - 1, active_col, QtCore.QModelIndex())
            selection = QtCore.QItemSelection(model_index_topLeft,
                                              model_index_topRight)
            # sel_model.clear()
            sel_model.select(selection,
                             QtCore.QItemSelectionModel.ClearAndSelect)

        else:
            TDBUtil.make_msgbox("", "Please select a publisher to move.",
                                QtWidgets.QMessageBox.Information)
Пример #23
0
    def _handleLink(self, link):
        """Handle a link in the text."""
        action, index = link.split(':', 1)
        index = int(index)
        info = self.editor.model().extTagInfos[index]

        if action == 'add':
            tagwidgets.AddTagTypeDialog.addTagType(info.tag)
        elif action == 'delete':
            levels.editor.changeTags({
                el: tags.SingleTagDifference(info.tag,
                                             removals=el.tags[info.tag])
                for el in info.elements
            })
        elif action == 'select':
            # Construct a QItemSelection storing the whole selection and add it to the model at once.
            # Otherwise a selectionChanged signal would be emitted after each selected wrapper.
            itemSelection = QtCore.QItemSelection()
            for wrapper in self.editor.model().getAllNodes():
                if wrapper.element in info.elements:
                    index = self.editor.model().getIndex(wrapper)
                    itemSelection.select(index, index)
            self.editor.selectionModel().select(
                itemSelection, QtCore.QItemSelectionModel.ClearAndSelect)
Пример #24
0
 def _selectDroppedRows(self, parent, start, end):
     self.selectionModel().select(
         QtCore.QItemSelection(self.model().index(start, 0, parent),
                               self.model().index(end, 0, parent)),
         QtCore.QItemSelectionModel.ClearAndSelect)
     self.setFocus(Qt.MouseFocusReason)