def setUp(self):
self.sourceModel1 = QStandardItemModel(5, 2)
self.proxyModel1 = SortProxyModel()
self.proxyModel1.setSourceModel(self.sourceModel1)
self.store = SharedSelectionStore(self.proxyModel1)
self.model1 = SharedSelectionModel(self.store, self.proxyModel1, None)
self.sourceModel2 = QStandardItemModel(5, 3)
self.proxyModel2 = SortProxyModel()
self.proxyModel2.setSourceModel(self.sourceModel2)
self.model2 = SharedSelectionModel(self.store, self.proxyModel2, None)
def __init__(self, var, lc, widget_parent=None, widget=None):
QWidget.__init__(self)
self.list_view = QListView()
text = []
model = QStandardItemModel(self.list_view)
for (i, val) in enumerate(var.values):
item = QStandardItem(val)
item.setCheckable(True)
if i + 1 in lc:
item.setCheckState(Qt.Checked)
text.append(val)
model.appendRow(item)
model.itemChanged.connect(widget_parent.conditions_changed)
self.list_view.setModel(model)
layout = QGridLayout(self)
layout.addWidget(self.list_view)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.adjustSize()
self.setWindowFlags(Qt.Popup)
self.widget = widget
self.widget.desc_text = ', '.join(text)
self.widget.set_text()
def __init__(self, parent=None, **kwargs):
# type: (Optional[QWidget], Any) -> None
super().__init__(parent, **kwargs)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Expanding)
self.__model = QStandardItemModel() # type: QAbstractItemModel
self.__flattened = False
self.__actionRole = Qt.UserRole
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
view = QTreeView(objectName="tool-tree-view")
view.setUniformRowHeights(True)
view.setFrameStyle(QTreeView.NoFrame)
view.setModel(self.__model)
view.setRootIsDecorated(False)
view.setHeaderHidden(True)
view.setItemsExpandable(True)
view.setEditTriggers(QTreeView.NoEditTriggers)
view.activated.connect(self.__onActivated)
view.clicked.connect(self.__onActivated)
view.entered.connect(self.__onEntered)
view.installEventFilter(self)
self.__view = view # type: QTreeView
layout.addWidget(view)
self.setLayout(layout)
def create_model(self):
allkeys = set(self.allinfo_local) | set(self.allinfo_remote)
allkeys = sorted(allkeys)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(self._header_labels)
current_index = -1
for i, file_path in enumerate(allkeys):
datainfo = self._parse_info(file_path)
item1 = QStandardItem()
item1.setData(" " if datainfo.islocal else "", Qt.DisplayRole)
item1.setData(self.IndicatorBrushes[0], Qt.ForegroundRole)
item1.setData(datainfo, Qt.UserRole)
item2 = QStandardItem(datainfo.title)
item3 = QStandardItem()
item3.setData(datainfo.size, Qt.DisplayRole)
item4 = QStandardItem()
item4.setData(datainfo.instances, Qt.DisplayRole)
item5 = QStandardItem()
item5.setData(datainfo.variables, Qt.DisplayRole)
item6 = QStandardItem()
item6.setData(datainfo.target, Qt.DisplayRole)
if datainfo.target:
item6.setIcon(variable_icon(datainfo.target))
item7 = QStandardItem()
item7.setData(", ".join(datainfo.tags) if datainfo.tags else "",
Qt.DisplayRole)
row = [item1, item2, item3, item4, item5, item6, item7]
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
return model, current_index
def test_tooltree(self):
tree = ToolTree()
role = tree.actionRole()
model = QStandardItemModel()
tree.setModel(model)
item = QStandardItem("One")
item.setData(QAction("One", tree), role)
model.appendRow([item])
cat = QStandardItem("A Category")
item = QStandardItem("Two")
item.setData(QAction("Two", tree), role)
cat.appendRow([item])
item = QStandardItem("Three")
item.setData(QAction("Three", tree), role)
cat.appendRow([item])
model.appendRow([cat])
def p(action):
print("triggered", action.text())
tree.triggered.connect(p)
tree.show()
self.qWait()
def __init__(self):
super().__init__()
self.data = None
self._invalidated = False
# List of available preprocessors (DescriptionRole : Description)
self.preprocessors = QStandardItemModel()
def mimeData(indexlist):
assert len(indexlist) == 1
index = indexlist[0]
qname = index.data(DescriptionRole).qualname
m = QMimeData()
m.setData("application/x-qwidget-ref", qname.encode("utf-8"))
return m
# TODO: Fix this (subclass even if just to pass a function
# for mimeData delegate)
self.preprocessors.mimeData = mimeData
box = gui.vBox(self.controlArea, "Preprocessors")
self.preprocessorsView = view = QListView(
selectionMode=QListView.SingleSelection,
dragEnabled=True,
dragDropMode=QListView.DragOnly)
view.setModel(self.preprocessors)
view.activated.connect(self.__activated)
box.layout().addWidget(view)
####
self._qname2ppdef = {ppdef.qualname: ppdef for ppdef in PREPROCESSORS}
# List of 'selected' preprocessors and their parameters.
self.preprocessormodel = None
self.flow_view = SequenceFlow()
self.controler = Controller(self.flow_view, parent=self)
self.overlay = OverlayWidget(self)
self.overlay.setAttribute(Qt.WA_TransparentForMouseEvents)
self.overlay.setWidget(self.flow_view)
self.overlay.setLayout(QVBoxLayout())
self.overlay.layout().addWidget(
QLabel("Drag items from the list on the left", wordWrap=True))
self.scroll_area = QScrollArea(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn)
self.scroll_area.viewport().setAcceptDrops(True)
self.scroll_area.setWidget(self.flow_view)
self.scroll_area.setWidgetResizable(True)
self.mainArea.layout().addWidget(self.scroll_area)
self.flow_view.installEventFilter(self)
box = gui.vBox(self.controlArea, "Output")
gui.auto_commit(box, self, "autocommit", "Send", box=False)
self._initialize()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__pages = [] # type: List[PagedWidget.Page]
self.__currentIndex = -1
self.setContentsMargins(0, 0, 0, 0)
self.setLayout(QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(0)
self.__tabview = PagedWidget.TabView(
viewMode=QListView.IconMode,
flow=QListView.TopToBottom,
editTriggers=QListView.NoEditTriggers,
uniformItemSizes=True,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff)
self.__tabview.setAttribute(Qt.WA_LayoutUsesWidgetRect)
self.__tabview.setContentsMargins(0, 0, 0, 0)
self.__tabview.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.__tabview.setItemDelegate(PagedWidget.TabViewDelegate())
self.__tabview.setModel(QStandardItemModel(self))
self.__tabview.selectionModel().selectionChanged.connect(
self.__on_activated, Qt.UniqueConnection)
iconsize = self.style().pixelMetric(QStyle.PM_LargeIconSize) * 3 // 2
self.__tabview.setIconSize(QSize(iconsize, iconsize))
self.__tabview.setAttribute(Qt.WA_MacShowFocusRect, False)
self.__stack = QStackedWidget(objectName="contents")
self.__stack.setContentsMargins(0, 0, 0, 0)
self.__stack.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.layout().addWidget(self.__tabview)
self.layout().addWidget(self.__stack)
def __init__(self, master):
"""Initialize the attributes and set up the interface"""
QDialog.__init__(self, windowTitle=self.captionTitle)
WidgetMessagesMixin.__init__(self)
self.setLayout(QVBoxLayout())
self.insert_message_bar()
self.layout().insertWidget(0, self.message_bar)
self.master = master
self.keep_running = False
self.scheduled_call = None
self.saved_state = None
self.saved_progress = 0
self.scores = []
self.rank_model = QStandardItemModel(self)
self.rank_table = view = QTableView(
selectionBehavior=QTableView.SelectRows,
selectionMode=QTableView.SingleSelection,
showGrid=False)
view.setItemDelegate(HorizontalGridDelegate())
view.setModel(self.rank_model)
view.selectionModel().selectionChanged.connect(
self.on_selection_changed)
view.horizontalHeader().setStretchLastSection(True)
view.horizontalHeader().hide()
self.layout().addWidget(view)
self.button = gui.button(self,
self,
"Start",
callback=self.toggle,
default=True)
def init_item_model(self):
if self.data_model:
self.data_model.clear()
self.setup_filter_model()
else:
self.data_model = QStandardItemModel()
self.data_model.setSortRole(Qt.UserRole)
self.data_model.setHorizontalHeaderLabels(self.DATA_HEADER_LABELS)
def __init__(self, master):
"""Initialize the attributes and set up the interface"""
QDialog.__init__(self, master, windowTitle=self.captionTitle)
WidgetMessagesMixin.__init__(self)
self.setLayout(QVBoxLayout())
self.insert_message_bar()
self.layout().insertWidget(0, self.message_bar)
self.master = master
self.keep_running = False
self.scheduled_call = None
self.saved_state = None
self.saved_progress = 0
self.scores = []
self.add_to_model = queue.Queue()
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self._update)
self.update_timer.setInterval(200)
self._thread = None
self._worker = None
self.filter = QLineEdit()
self.filter.setPlaceholderText("Filter ...")
self.filter.textChanged.connect(self.filter_changed)
self.layout().addWidget(self.filter)
# Remove focus from line edit
self.setFocus(Qt.ActiveWindowFocusReason)
self.rank_model = QStandardItemModel(self)
self.model_proxy = QSortFilterProxyModel(self,
filterCaseSensitivity=False)
self.model_proxy.setSourceModel(self.rank_model)
self.rank_table = view = QTableView(
selectionBehavior=QTableView.SelectRows,
selectionMode=QTableView.SingleSelection,
showGrid=False,
editTriggers=gui.TableView.NoEditTriggers)
if self._has_bars:
view.setItemDelegate(TableBarItem())
else:
view.setItemDelegate(HorizontalGridDelegate())
view.setModel(self.model_proxy)
view.selectionModel().selectionChanged.connect(
self.on_selection_changed)
view.horizontalHeader().setStretchLastSection(True)
view.horizontalHeader().hide()
self.layout().addWidget(view)
self.button = gui.button(self,
self,
"Start",
callback=self.toggle,
default=True)
def __init__(self, parent=None, **kwargs):
super(AddonManagerWidget, self).__init__(parent, **kwargs)
#: list of Available | Installed
self.__items = []
self.setLayout(QVBoxLayout())
self.__header = QLabel(
wordWrap=True,
textFormat=Qt.RichText
)
self.__search = QLineEdit(
placeholderText=self.tr("Filter")
)
self.layout().addWidget(self.__search)
self.__view = view = QTreeView(
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True
)
self.__view.setItemDelegateForColumn(0, TristateCheckItemDelegate())
self.layout().addWidget(view)
self.__model = model = QStandardItemModel()
model.setHorizontalHeaderLabels(["", "Name", "Version", "Action"])
model.dataChanged.connect(self.__data_changed)
proxy = QSortFilterProxyModel(
filterKeyColumn=1,
filterCaseSensitivity=Qt.CaseInsensitive
)
proxy.setSourceModel(model)
self.__search.textChanged.connect(proxy.setFilterFixedString)
view.setModel(proxy)
view.selectionModel().selectionChanged.connect(
self.__update_details
)
header = self.__view.header()
header.setSectionResizeMode(0, QHeaderView.Fixed)
header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.__details = QTextBrowser(
frameShape=QTextBrowser.NoFrame,
readOnly=True,
lineWrapMode=QTextBrowser.WidgetWidth,
openExternalLinks=True,
)
self.__details.setWordWrapMode(QTextOption.WordWrap)
palette = QPalette(self.palette())
palette.setColor(QPalette.Base, Qt.transparent)
self.__details.setPalette(palette)
self.layout().addWidget(self.__details)
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
self.learners_box = gui.listBox(
self.controlArea, self, "selected_learner", "learners", box=True,
callback=self._learner_changed
)
self.outputbox = gui.vBox(self.controlArea, "Output")
box = gui.hBox(self.outputbox)
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.outputbox, self, "autocommit",
"Send Selected", "Send Automatically", box=False)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox, self, "selected_quantity",
items=self.quantities, label="Show: ",
orientation=Qt.Horizontal, callback=self._update)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
view.clicked.connect(self.cell_clicked)
box.layout().addWidget(view)
selbox = gui.hBox(box)
gui.button(selbox, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(selbox, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(selbox, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
def color_palette_model(palettes, iconsize=QSize(64, 16)):
model = QStandardItemModel()
for name, palette in palettes:
_, colors = max(palette.items())
colors = [QColor(*c) for c in colors]
item = QStandardItem(name)
item.setIcon(QIcon(palette_pixmap(colors, iconsize)))
item.setData(palette, Qt.UserRole)
model.appendRow([item])
return model
def __init__(self, parent=None, **kwargs):
QTreeView.__init__(self, parent, **kwargs)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Expanding)
self.__model = QStandardItemModel()
self.__flattened = False
self.__actionRole = Qt.UserRole
self.__view = None
self.__setupUi()
def __init__(self, parent=None):
super().__init__(parent=parent)
self.__stack: List = []
self.__stack_index: int = -1
def push_on_data_changed(_, __, roles):
if Qt.EditRole in roles:
self._push_data()
self.__model = QStandardItemModel()
self.__model.dataChanged.connect(self.dataChanged)
self.__model.dataChanged.connect(push_on_data_changed)
self.__root: QStandardItem = self.__model.invisibleRootItem()
self.__tree = TreeView(self.dataChanged)
self.__tree.drop_finished.connect(self.dataChanged)
self.__tree.drop_finished.connect(self._push_data)
self.__tree.setModel(self.__model)
self.__tree.selectionModel().selectionChanged.connect(
self.selectionChanged)
actions_widget = ModelActionsWidget()
actions_widget.layout().setSpacing(1)
action = QAction("+", self, toolTip="Add a new word")
action.triggered.connect(self.__on_add)
actions_widget.addAction(action)
action = QAction("\N{MINUS SIGN}", self, toolTip="Remove word")
action.triggered.connect(self.__on_remove)
actions_widget.addAction(action)
action = QAction("\N{MINUS SIGN}R", self,
toolTip="Remove word recursively (incl. children)")
action.triggered.connect(self.__on_remove_recursive)
actions_widget.addAction(action)
gui.rubber(actions_widget)
self.__undo_action = action = QAction("Undo", self, toolTip="Undo")
action.triggered.connect(self.__on_undo)
actions_widget.addAction(action)
self.__redo_action = action = QAction("Redo", self, toolTip="Redo")
action.triggered.connect(self.__on_redo)
actions_widget.addAction(action)
self._enable_undo_redo()
layout = QVBoxLayout()
layout.setSpacing(1)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.__tree)
layout.addWidget(actions_widget)
self.setLayout(layout)
def create_model(rows, columns):
model = QStandardItemModel()
model.setRowCount(rows)
model.setColumnCount(columns)
for i in range(rows):
for j in range(columns):
model.setItemData(model.index(i, j), {
Qt.DisplayRole: f"{i}x{j}",
Qt.UserRole: i * j,
})
return model
def __init__(self, parent=None, **kwargs):
FramelessWindow.__init__(self, parent, **kwargs)
self.setWindowFlags(Qt.Popup)
self.__filterFunc = None
self.__setupUi()
self.__loop = None
self.__model = QStandardItemModel()
self.__triggeredAction = None
def create_list_model(
items: Iterable[Mapping[Qt.ItemDataRole, Any]],
parent: Optional[QObject] = None,
) -> QStandardItemModel:
"""Create list model from an item date iterable."""
model = QStandardItemModel(parent)
for item in items:
sitem = QStandardItem()
for role, value in item.items():
sitem.setData(value, role)
model.appendRow([sitem])
return model
def on_done(self, result: Results):
model = QStandardItemModel()
for item in result.items:
model.appendRow(item)
model.setSortRole(Qt.UserRole)
model.setHorizontalHeaderLabels(Header.labels())
self.filter_proxy_model.setSourceModel(model)
self.tree_view.selectionModel().selectionChanged.connect(self.commit)
self.filter_view()
self.update_info_box()
def create_model(self):
allkeys = set(self.allinfo_local)
if self.allinfo_remote is not None:
allkeys = allkeys | set(self.allinfo_remote)
allkeys = sorted(allkeys)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(self._header_labels)
current_index = -1
for i, file_path in enumerate(allkeys):
data_info = self._parse_info(file_path)
row = []
for info_tag, header_setting in self.HEADER_SCHEMA:
item = QStandardItem()
try:
data = data_info.__getattribute__(info_tag)
except AttributeError:
# unknown tag in JSON
data = ''
# first column indicating cached data sets
if info_tag == 'islocal':
item.setData(' ' if data else '', Qt.DisplayRole)
item.setData(data_info, Qt.UserRole)
else:
# parse taxid to common name
if info_tag == 'taxid' and data in common_taxids():
data = shortname(data)[0].title()
if info_tag == 'tags':
data = ', '.join(data) if data else ''
item.setData(data, Qt.DisplayRole)
# set icon to Target column
if info_tag == 'target' and data:
item.setIcon(
Orange.widgets.data.owdatasets.variable_icon(data))
row.append(item)
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
return model, current_index
def test(self):
model = QStandardItemModel()
item_parent = QStandardItem("parent")
item_child = QStandardItem("child")
model.insertRow(0, item_parent)
item_parent.insertRow(0, item_child)
self.assertEqual(model.index(0, 0).data(), "parent")
self.assertEqual(model.index(0, 0, model.index(0, 0)).data(), "child")
del item_child
del item_parent
gc.collect()
self.assertEqual(model.index(0, 0).data(), "parent")
self.assertEqual(model.index(0, 0, model.index(0, 0)).data(), "child")
def clear(self):
""" Clear the widget/model (same as ``setModel(None)``).
"""
if self.__model is not None:
self.values_view.selectionModel().clearSelection()
self.values_view.selectionModel().selectionChanged.disconnect(
self.__onSelectionChanged)
self.values_view.setModel(None)
self.labels_combo.setModel(QStandardItemModel(self.labels_combo))
self.__currentIndex = -1
self.__selections = {}
self.__model = None
def init_form(self):
#self.header().hide()
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.setUniformRowHeights(True)
#self.setDragDropMode(QAbstractItemView.InternalMove)
#self.setDragEnabled(True)
#self.setAcceptDrops(True)
self.value = QStandardItemModel(
) if self._value is None else self._value
#self.selectionChanged = self.__selectionChanged
self.mouseDoubleClickEvent = self.__itemDoubleClicked
self.selectionModel().selectionChanged.connect(self.__selectionChanged)
def test_blockselectionmodel(self):
model = QStandardItemModel()
model.setRowCount(4)
model.setColumnCount(4)
sel = BlockSelectionModel(model)
sel.select(model.index(0, 0), BlockSelectionModel.Select)
self.assertSetEqual(selected(sel), {(0, 0)})
sel.select(model.index(0, 1), BlockSelectionModel.Select)
self.assertSetEqual(selected(sel), {(0, 0), (0, 1)})
sel.select(model.index(1, 1), BlockSelectionModel.Select)
self.assertSetEqual(selected(sel), {(0, 0), (0, 1), (1, 0), (1, 1)})
sel.select(model.index(0, 0), BlockSelectionModel.Deselect)
self.assertSetEqual(selected(sel), {(1, 1)})
sel.select(model.index(3, 3), BlockSelectionModel.ClearAndSelect)
self.assertSetEqual(selected(sel), {(3, 3)})
def initialize(self, data):
"""Initialize widget state from the data."""
col_targets, row_targets = grouputils.group_candidates(data)
modelitems = [guiutils.standarditem_from(obj)
for obj in col_targets + row_targets]
model = QStandardItemModel()
for item in modelitems:
model.appendRow(item)
self.label_selection_widget.setModel(model)
self.targets = col_targets + row_targets
# Default selections for all group keys
# (the first value is selected)
self.stored_selections = [[0] for _ in self.targets]
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.__onto_handler = OntologyHandler()
flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable
self.__model = PyListModel([], self, flags=flags)
self.__input_model = QStandardItemModel()
self.__library_view: QListView = None
self.__input_view: ListViewSearch = None
self.__ontology_view: EditableTreeView = None
self.ontology_info = ""
self._setup_gui()
self._restore_state()
self.settingsAboutToBePacked.connect(self._save_state)
def __init__(self, other_or_parent=None, parent=None):
if isinstance(other_or_parent, QObject) and parent is None:
parent, other_or_parent = other_or_parent, None
QObject.__init__(self, parent)
WidgetRegistry.__init__(self, other_or_parent)
# Should the QStandardItemModel be subclassed?
self.__item_model = QStandardItemModel(self)
for i, desc in enumerate(self.categories()):
cat_item = self._cat_desc_to_std_item(desc)
self.__item_model.insertRow(i, cat_item)
for j, wdesc in enumerate(self.widgets(desc.name)):
widget_item = self._widget_desc_to_std_item(wdesc, desc)
cat_item.insertRow(j, widget_item)
def init_form(self):
self.setSelectionBehavior(QAbstractItemView.SelectRows)
self.header().hide()
self.setUniformRowHeights(True)
self.setDragDropMode(QAbstractItemView.InternalMove)
self.setDragEnabled(True)
self.setAcceptDrops(True)
self.setModel(QStandardItemModel())
self.model().itemChanged.connect(self.__item_changed_event)
self.selectionChanged = self.selectionChanged
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# populate data
"""
def __init__(self, master):
QObject.__init__(self)
OWComponent.__init__(self, master)
self.view = gui.TableView(wordWrap=True,
editTriggers=gui.TableView.NoEditTriggers)
header = self.view.horizontalHeader()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
header.setDefaultAlignment(Qt.AlignCenter)
header.setStretchLastSection(False)
header.setContextMenuPolicy(Qt.CustomContextMenu)
header.customContextMenuRequested.connect(self.show_column_chooser)
self.model = QStandardItemModel(master)
self.model.setHorizontalHeaderLabels(["Method"])
self.view.setModel(self.model)
self.view.setItemDelegate(self.ItemDelegate())
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})
