I am using PyQt5 to make an application. One of my widgets will be a QListView that displays a list of required items, e.g. required to cook a particular dish, say.
For most of these, the listed item is the only possibility. But for a few items, there is more than one option that will fulfill the requirements. For those with multiple possibilities, I want to display those possibilities in a functional QComboBox. So if the user has no whole milk, they can click that item, and see that 2% milk also works.
How can I include working combo boxes among the elements of my QListView?
Below is an example that shows what I have so far. It can work in Spyder or using python -i, you just have to comment or uncomment as noted. By "work", I mean it shows the required items in QListView, but the combo boxes show only the first option, and their displays can't be changed with the mouse. However, I can say e.g. qb1.setCurrentIndex(1) at the python prompt, and then when I move the mouse pointer onto the widget, the display updates to "2% milk". I have found it helpful to be able to interact with and inspect the widget in Spyder or a python interpreter, but I still have this question. I know there are C++ examples of things like this around, but I have been unable to understand them well enough to do what I want. If we can post a working Python example of this, it will help me and others too I'm sure.
from PyQt5.QtWidgets import QApplication, QComboBox, QListView, QStyledItemDelegate
from PyQt5.QtCore import QAbstractListModel, Qt
# A delegate for the combo boxes.
class QBDelegate(QStyledItemDelegate):
def paint(self, painter, option, index):
painter.drawText(option.rect, Qt.AlignLeft, self.parent().currentText())
# my own wrapper for the abstract list class
class PlainList(QAbstractListModel):
def __init__(self, elements):
super().__init__()
self.elements = elements
def data(self, index, role):
if role == Qt.DisplayRole:
text = self.elements[index.row()]
return text
def rowCount(self, index):
try:
return len(self.elements)
except TypeError:
return self.elements.rowCount(index)
app = QApplication([]) # in Spyder, this seems unnecessary, but harmless.
qb0 = 'powdered sugar' # no other choice
qb1 = QComboBox()
qb1.setModel(PlainList(['whole milk','2% milk','half-and-half']))
d1 = QBDelegate(qb1)
qb1.setItemDelegate(d1)
qb2 = QComboBox()
qb2.setModel(PlainList(['butter', 'lard']))
d2 = QBDelegate(qb2)
qb2.setItemDelegate(d2)
qb3 = 'cayenne pepper' # there is no substitute
QV = QListView()
qlist = PlainList([qb0, qb1, qb2, qb3])
QV.setModel(qlist)
QV.setItemDelegateForRow(1, d1)
QV.setItemDelegateForRow(2, d2)
QV.show()
app.exec_() # Comment this line out, to run in Spyder. Then you can inspect QV etc in the iPython console. Handy!
There are some misconceptions in your attempt.
First of all, setting the delegate parent as a combo box and then setting the delegate for the list view won't make the delegate show the combo box.
Besides, as the documentation clearly says:
Warning: You should not share the same instance of a delegate between views. Doing so can cause incorrect or unintuitive editing behavior since each view connected to a given delegate may receive the closeEditor() signal, and attempt to access, modify or close an editor that has already been closed.
In any case, adding the combo box to the item list is certainly not an option: the view won't have anything to do with it, and overriding the data() to show the current combo item is not a valid solution; while theoretically item data can contain any kind of object, for your purpose the model should contain data, not widgets.
In order to show a different widget for a view, you must override createEditor() and return the appropriate widget.
Then, since you probably need to keep the data available when accessing the model and for the view, the model should contain the available options and eventually return the current option or the "sub-list" depending on the situation.
Finally, rowCount() must always return the row count of the model, not that of the content of the index.
A possibility is to create a "nested model" that supports a "current index" for the selected option for inner models.
Then you could either use openPersistentEditor() or implement flags() and add the Qt.ItemIsEditable for items that contain a list model.
class QBDelegate(QStyledItemDelegate):
def createEditor(self, parent, option, index):
value = index.data(Qt.EditRole)
if isinstance(value, PlainList):
editor = QComboBox(parent)
editor.setModel(value)
editor.setCurrentIndex(value.currentIndex)
# submit the data whenever the index changes
editor.currentIndexChanged.connect(
lambda: self.commitData.emit(editor))
else:
editor = super().createEditor(parent, option, index)
return editor
def setModelData(self, editor, model, index):
if isinstance(editor, QComboBox):
# the default implementation tries to set the text if the
# editor is a combobox, but we need to set the index
model.setData(index, editor.currentIndex())
else:
super().setModelData(editor, model, index)
class PlainList(QAbstractListModel):
currentIndex = 0
def __init__(self, elements):
super().__init__()
self.elements = []
for element in elements:
if isinstance(element, (tuple, list)) and element:
element = PlainList(element)
self.elements.append(element)
def data(self, index, role=Qt.DisplayRole):
if role == Qt.EditRole:
return self.elements[index.row()]
elif role == Qt.DisplayRole:
value = self.elements[index.row()]
if isinstance(value, PlainList):
return value.elements[value.currentIndex]
else:
return value
def flags(self, index):
flags = super().flags(index)
if isinstance(index.data(Qt.EditRole), PlainList):
flags |= Qt.ItemIsEditable
return flags
def setData(self, index, value, role=Qt.EditRole):
if role == Qt.EditRole:
item = self.elements[index.row()]
if isinstance(item, PlainList):
item.currentIndex = value
else:
self.elements[index.row()] = value
return True
def rowCount(self, parent=None):
return len(self.elements)
app = QApplication([])
qb0 = 'powdered sugar' # no other choice
qb1 = ['whole milk','2% milk','half-and-half']
qb2 = ['butter', 'lard']
qb3 = 'cayenne pepper' # there is no substitute
QV = QListView()
qlist = PlainList([qb0, qb1, qb2, qb3])
QV.setModel(qlist)
QV.setItemDelegate(QBDelegate(QV))
## to always display the combo:
#for i in range(qlist.rowCount()):
# index = qlist.index(i)
# if index.flags() & Qt.ItemIsEditable:
# QV.openPersistentEditor(index)
QV.show()
app.exec_()
I have a single column TableView with a checkbox. I want to check the checkbox when an item is selected and the same opposite when a check box is checked, item should be in selection as well.
I have this working with one issue, since I have set the table in QSortFilterProxyModel, when an item is filtered and selected the the row number is changing as per the filter as well. So I can't get the actual item in my QStandardItemModel. Like, if I filtered and checked the 3rd item, the selected item will be the one in initial state.
My Code is as follows:
class WindowHomeScreen(QtWidgets.QMainWindow):
"""Main Screen of the application"""
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.menu_items = {}
self.is_all_selected = False # Table items
self.filter_proxy_model = QtCore.QSortFilterProxyModel()
articles = sql_db.query_fetch_articles_list()
self.fixed_rates = sql_db.query_fetch_fixed_rates()
self.model = QtGui.QStandardItemModel(len(articles), 1)
self.model.setHorizontalHeaderLabels(["Articles"])
self.articles_dict: dict[str, tuple[Article, PriceStructure, OSCharges]] = {}
for row, article in enumerate(articles):
if article[0].mrp != 0:
key = f"{article[0].article} - ₹{article[0].mrp}"
else:
key = f"{article[0].article} - ###"
item = QtGui.QStandardItem(key)
self.articles_dict[key] = article
item.setFlags(
Qt.ItemFlag.ItemIsUserCheckable
| Qt.ItemFlag.ItemIsEnabled
| Qt.ItemFlag.ItemIsSelectable
)
item.setCheckState(Qt.CheckState.Unchecked)
self.model.setItem(row, 0, item)
self.filter_proxy_model.setSourceModel(self.model)
self.filter_proxy_model.setFilterCaseSensitivity(
Qt.CaseSensitivity.CaseInsensitive
)
self.filter_proxy_model.setFilterKeyColumn(0)
# Connections with filter
self.ui.lineEdit.textChanged.connect(
self.filter_proxy_model.setFilterRegularExpression
)
self.ui.tableView.horizontalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.ResizeMode.Stretch
)
self.ui.tableView.setEditTriggers(
QtWidgets.QTableView.EditTrigger.NoEditTriggers
)
self.ui.tableView.setModel(self.filter_proxy_model)
self.ui.tableView.doubleClicked.connect(self.tableDoubleClicked)
self.ui.tableView.clicked.connect(self.tableSingleClicked)
self.ui.tableView.selectionModel().selectionChanged.connect(
self.tableSelectionChanged
)
self.ui.tableView.findChild(QtWidgets.QAbstractButton).clicked.connect(
self.tableSelectAll
)
# Connections to buttons
self.ui.button_show_stats.clicked.connect(self.buttonShowStats)
self.ui.button_export_xl.clicked.connect(self.buttonExport)
self.ui.button_export_summary.clicked.connect(self.buttonExportSummaryReport)
# TODO: Create new method to export only currently displaying item
self.ui.button_export_xl_sub.clicked.connect(self.buttonExport)
# Connections to menu items
self.ui.actionClose.triggered.connect(self.menu_close_app)
self.ui.actionUpgradeBom.triggered.connect(self.menu_create_bom)
self.ui.actionUpgradeOS_Charge.triggered.connect(self.menu_create_osc)
self.ui.actionUpgradePrice_Structure.triggered.connect(self.menu_create_ps)
self.ui.actionUpdateOS_Charges.triggered.connect(self.menu_manage_osc)
self.ui.actionUpdatePrice_Structure.triggered.connect(self.menu_manage_ps)
self.ui.actionUpdateOther_Expenses.triggered.connect(self.menu_manage_expenses)
self.ui.actionUpdateFixed_Charges.triggered.connect(
self.menu_manage_fixed_charges
)
def tableSelectAll(self):
"""Select or Unselect all check boxes in the table
Table View corner button function.
"""
if self.is_all_selected:
self.ui.tableView.clearSelection()
self.is_all_selected = not self.is_all_selected
def tableSelectionChanged(
self, selected: QtCore.QItemSelection, deselected: QtCore.QItemSelection
):
"""Catch Selection changed behaviour"""
for item in selected.indexes():
self.model.item(item.row(), 0).setCheckState(Qt.CheckState.Checked)
for item in deselected.indexes():
self.model.item(item.row(), 0).setCheckState(Qt.CheckState.Unchecked)
def tableSingleClicked(self, modelIndex: QtCore.QModelIndex):
"""Single clicked item in the tableview
Select or Unselect item.
"""
if (
self.model.item(modelIndex.row(), 0).checkState() == Qt.CheckState.Checked
and modelIndex not in self.ui.tableView.selectedIndexes()
) or (
self.model.item(modelIndex.row(), 0).checkState() == Qt.CheckState.Unchecked
and modelIndex in self.ui.tableView.selectedIndexes()
):
self.ui.tableView.selectionModel().select(
modelIndex, QtCore.QItemSelectionModel.SelectionFlag.Toggle
)
# rest of the code...
Thanks to: #musicamante ;
I was able to solve the issue by modifying my selection changed method and singleitem clicked method as follows;
def tableSelectionChanged(
self, selected: QtCore.QItemSelection, deselected: QtCore.QItemSelection
):
"""Catch Selection changed behaviour"""
for index in selected.indexes():
self.filter_proxy_model.setData(index, Qt.CheckState.Checked, Qt.ItemDataRole.CheckStateRole)
for index in deselected.indexes():
self.filter_proxy_model.setData(index, Qt.CheckState.Unchecked, Qt.ItemDataRole.CheckStateRole)
def tableSingleClicked(self, modelIndex: QtCore.QModelIndex):
"""Single item clicked/checked in the tableview
Select or Unselect item when checkbox is checked or unchecked.
"""
# CheckState key is 10 in itemData - Not read doc for info
# check_state will be Qt.CheckState "enum value" when checkbox item is checked.
# check_state will be Qt.CheckState "enum" when item selected.
# only checkbox item selection is needed, so integer value will consider in here and other ignored which isn't needed.
check_state = self.filter_proxy_model.itemData(modelIndex).get(10)
if (
check_state == 2
and modelIndex not in self.ui.tableView.selectedIndexes()
) or (
check_state == 0
and modelIndex in self.ui.tableView.selectedIndexes()
):
self.ui.tableView.selectionModel().select(
modelIndex, QtCore.QItemSelectionModel.SelectionFlag.Toggle
)
I have a QTreeWidget in my gui in which the contents will be cleared whenever it loads in a different set of data and I am trying to tracked what has been checked as User loads in different data set.
Initially, I thought of tracking it using derive_tree_items method that I created in which it contains the QTreeWidgetItem object, however as soon as I tried to load in a new set of data, the objects that I stored will be lost as they are deleted (expected)..
Currently at a lost what is a better way to 'track' these checkable items? (I may also need to populate them into QMenu + QAction, hence the trackable checking but that will be for next time)
In my code, you can replicate by:
Click on button 'Data-01'
Check any objects, eg. I checked 'c102' and 'a102'
Click on button 'Data-02'
Click on button 'Data-01' again
Expecting to see 'c102', 'a102' is checked..
IsNewItemRole = QtCore.Qt.UserRole + 1000
class CustomTreeWidgetItem(QtGui.QTreeWidgetItem):
"""Initialization class for QTreeWidgetItem creation.
Args:
widget (QtGui.QTreeWidget): To append items into.
text (str): Input name for QTreeWidgetItem.
is_tristate (bool): Should it be a tri-state checkbox. False by default.
"""
def __init__(self, parent=None, text=None, is_tristate=False, is_new_item=False):
super(CustomTreeWidgetItem, self).__init__(parent)
self.setText(0, text)
# flags = QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsUserCheckable
if is_tristate:
# flags |= QtCore.Qt.ItemIsTristate
# Solely for the Parent item
self.setFlags(
self.flags()
| QtCore.Qt.ItemIsTristate
| QtCore.Qt.ItemIsEditable
| QtCore.Qt.ItemIsUserCheckable
)
else:
self.setFlags(
self.flags()
| QtCore.Qt.ItemIsEditable
| QtCore.Qt.ItemIsUserCheckable
)
self.setCheckState(0, QtCore.Qt.Unchecked)
self.setData(0, IsNewItemRole, is_new_item)
def setData(self, column, role, value):
"""Override QTreeWidgetItem setData function.
QTreeWidget does not have a signal that defines when an item has been
checked/ unchecked. And so, this method will emits the signal as a
means to handle this.
Args:
column (int): Column value of item.
role (int): Value of Qt.ItemDataRole. It will be Qt.DisplayRole or
Qt.CheckStateRole
value (int or unicode):
"""
state = self.checkState(column)
QtGui.QTreeWidgetItem.setData(self, column, role, value)
if (role == QtCore.Qt.CheckStateRole and
state != self.checkState(column)):
tree_widget = self.treeWidget()
if isinstance(tree_widget, CustomTreeWidget):
tree_widget.itemToggled.emit(self, column)
class CustomTreeWidget(QtGui.QTreeWidget):
"""Initialization class for QTreeWidget creation.
Args:
widget ():
"""
# itemToggled = QtCore.pyqtSignal(QtGui.QTreeWidgetItem, bool)
itemToggled = QtCore.Signal(QtGui.QTreeWidgetItem, bool)
contentUpdates = QtCore.Signal()
def __init__(self, widget=None):
super(CustomTreeWidget, self).__init__(widget)
self.rename_counter = False
# self.itemToggled.connect(self.handleItemToggled)
self.currentItemChanged.connect(self.selection_item_changed)
self.itemChanged.connect(self.tree_item_changed)
self.itemDoubleClicked.connect(self.tree_item_double_clicked)
def selection_item_changed(self, current, previous):
"""Overrides widget's default signal.
Emiited when current item selection is changed. This will also toggles
the state of `self.add_child_btn`.
If a child item is selected, the "Add Child" button will be disabled.
Args:
current (CustomTreeWidgetItem): Currently selected item.
previous (CustomTreeWidgetItem or None): Previous selected item.
"""
state = True
if not current or current.parent():
state = False
def tree_item_changed(self, item, column):
"""Overrides widget's default signal.
Emitted when the contents of the selected item in the column changes.
Args:
item (CustomTreeWidgetItem): Selected item.
column (int): Column value of the selected item.
"""
if self.rename_counter and self.prev_name != item.text(column):
self.rename_counter = False
item.setData(0, IsNewItemRole, True)
self.contentUpdates.emit()
elif item.checkState(column) == QtCore.Qt.Checked:
print('Item Checked')
elif item.checkState(column) == QtCore.Qt.Unchecked:
print('Item Unchecked')
def tree_item_double_clicked(self, item, column):
"""Overrides widget's default signal.
Emitted when User performs double clicks inside the widget.
Args:
item (CustomTreeWidgetItem): Selected item.
column (int): Column value of the selected item.
"""
self.prev_name = item.text(column)
self.rename_counter = True
def derive_tree_items(self, mode="all"):
all_items = OrderedDict()
root_item = self.invisibleRootItem()
top_level_count = root_item.childCount()
for i in range(top_level_count):
top_level_item = root_item.child(i)
top_level_item_name = str(top_level_item.text(0))
child_num = top_level_item.childCount()
all_items[top_level_item_name] = []
for n in range(child_num):
child_item = top_level_item.child(n)
child_item_name = str(child_item.text(0)) or ""
all_items[top_level_item_name].append(child_item)
return all_items
class MainApp(QtGui.QWidget):
def __init__(self, parent=None):
super(MainApp, self).__init__(parent)
self._diff_highlight = False
self._tree = CustomTreeWidget()
self._tree.header().hide()
# QTreeWidget default signals override
self._tree.contentUpdates.connect(self.update_dictionary)
tree_layout = QtGui.QVBoxLayout()
self.btn1 = QtGui.QPushButton("Data-01")
self.btn2 = QtGui.QPushButton("Data-02")
tree_layout.addWidget(self._tree)
tree_layout.addWidget(self.btn1)
tree_layout.addWidget(self.btn2)
main_layout = QtGui.QHBoxLayout()
main_layout.addLayout(tree_layout)
self.setLayout(main_layout)
self.setup_connections()
def setup_connections(self):
self.btn1.clicked.connect(self.show_data_01)
self.btn2.clicked.connect(self.show_data_02)
def update_dictionary(self):
print '>>> update: ', self._tree.derive_tree_items()
def show_data_01(self):
print '>>> Button1 test'
self._tree.clear()
test_dict1 = {
"itemA" :{
"menuA": ["a101", "a102"],
},
"itemBC": {
"menuC": ["c101", "c102", "c103"],
"menuB": ["b101"]
},
}
for page_name, page_contents in test_dict1.items():
# page_item = PageHeaderItem(self._tree, page_name)
for pk, pv in page_contents.items():
parent = CustomTreeWidgetItem(self._tree, pk, is_tristate=True)
for c in pv:
child = CustomTreeWidgetItem(parent, c)
self._tree.expandAll()
def show_data_02(self):
print '>>> Button2 test'
self._tree.clear()
test_dict2 = {
"itemD" :{
"menuD": ["d100"],
},
}
for page_name, page_contents in test_dict2.items():
# page_item = PageHeaderItem(self._tree, page_name)
for pk, pv in page_contents.items():
parent = CustomTreeWidgetItem(self._tree, pk, is_tristate=True)
for c in pv:
child = CustomTreeWidgetItem(parent, c)
self._tree.expandAll()
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
w = MainApp()
w.show()
sys.exit(app.exec_())
A QTreeWidget (like QListWidget and QTableWidget) has its internal model; it's some sort of a high-level access to a data model, and its actual model is not directly (as in easily) accessible, nor it should. They are "simplified" model-view interfaces, intended for general use that don't require advanced editing, but - most importantly - they only support their own, single and unique model. There's no easy way to change it except from their Q[viewType]WidgetItem interfaces, unless you completely reset the model, meaning that you'll need to "store" the data somewhere else if you want to use multiple models in the same view, making the whole thing much more complex than it needs to be and much prone to errors and issues, which is exactly what happens in your case.
On the opposite side, those QWidgetItemViews offer some features missing in standard models and views, and one of them is the "auto-check" of items in QTreeWidgets.
While that feature is very useful, it could be a serius PITA when you need to show different data models on the same view; this means that, to avoid the rhetorical reinvention of the wheel, it's better to stick with the QTreeView/QStandardItemModel pair and just implement the tristate mechanism instead of using convoluted methods that might clash with the internal implementation of a QTreeWidget.
Separate QStandardItemModel subclass instancies, with parent/child Tristate support
The most important aspect here is that you will be using a single data model class instance for each data set (instead of multiple dict + view's model pairs), making it much easier to switch between them with a simple flick of setModel().
The drawback is the aforementioned lack of parent/children state support, which has to be implemented; once that logic is solved, you'll get multiple persistent, unique and consistent models, no matter how many of them you actually need.
Besides the actual model contents initialization, you are only required to subclass two methods of QStandardItemModel:
setData(index, value, role) is overridden to apply the check state to the children indexes: if the role is Qt.CheckState and the index has any children, the [un]checked state is applied to them; if the index has a parent, the index emits the dataChanged signal to the model, ensuring that its view[s] requires updates (otherwise the checkbox visible state won't be updated correctly until the view is repainted)[1];
data(index, role) overriding is required to "show" the checkstate for the parent(s); it doesn't matter what the model's index data is: if it has any children, its state totally depends on them (all/any/none checked), otherwise it's based on the default model index's checkState;
Once that's solved, you only have to care about setting the newly selected model to the view, and all states will be there as they were before switching to another model, if any.
To keep some consistence with your example, I used your dict-based model data creation logic, but I'd suggest you to use a recursive method to add sub-children.
Since I was already there, I also added a mechanism to store the expanded state of every index, for better view/model consistency; it's not required, but it really helps user experience :-) Keep in mind that that's just there for demonstration purposes: obviously, if you add/remove items without taking care of the internal expandState dict, this won't work properly (or won't work at all!).
import sys
from PyQt5 import QtCore, QtGui, QtWidgets
dataSets = [
{
"itemA" :{
"menuA": ["a101", "a102"],
},
"itemBC": {
"menuC": ["c101", "c102", "c103"],
"menuB": ["b101"]
},
},
{
"itemD" :{
"menuD": ["d100"],
},
}
]
class TreeModel(QtGui.QStandardItemModel):
checkStateChange = QtCore.pyqtSignal(QtCore.QModelIndex, bool)
def __init__(self, dataSet):
super(TreeModel, self).__init__()
# unserialize data, as per your original code; you might want to use a
# recursive function instead, to allow multiple levels of items
for page_name, page_contents in dataSet.items():
for pk, pv in page_contents.items():
parent = QtGui.QStandardItem(pk)
parent.setCheckable(True)
self.appendRow(parent)
if pv:
parent.setTristate(True)
for c in pv:
child = QtGui.QStandardItem(c)
child.setCheckable(True)
parent.appendRow(child)
self.dataChanged.connect(self.checkStateChange)
def setData(self, index, value, role=QtCore.Qt.EditRole):
if role == QtCore.Qt.CheckStateRole:
childState = QtCore.Qt.Checked if value else QtCore.Qt.Unchecked
# set all children states according to this parent item
for row in range(self.rowCount(index)):
for col in range(self.columnCount(index)):
childIndex = self.index(row, col, index)
self.setData(childIndex, childState, QtCore.Qt.CheckStateRole)
# if the item has a parent, emit the dataChanged signal to ensure
# that the parent state is painted correctly according to what data()
# will return; note that this will emit the dataChanged signal whatever
# the "new" parent state is, meaning that it might still be the same
parent = self.parent(index)
if parent.isValid():
self.dataChanged.emit(parent, parent)
return super(TreeModel, self).setData(index, value, role)
def data(self, index, role=QtCore.Qt.DisplayRole):
# QStandardItemModel doesn't support auto tristate based on its children
# as it does for QTreeWidget's internal model; we have to implement that
if role == QtCore.Qt.CheckStateRole and self.flags(index) & QtCore.Qt.ItemIsTristate:
childStates = []
# collect all child check states
for row in range(self.rowCount(index)):
for col in range(self.columnCount(index)):
childIndex = self.index(row, col, index)
childState = self.data(childIndex, QtCore.Qt.CheckStateRole)
# if the state of a children is partially checked we can
# stop here and return a partially checked state
if childState == QtCore.Qt.PartiallyChecked:
return QtCore.Qt.PartiallyChecked
childStates.append(childState)
if all(childStates):
# all children are checked, yay!
return QtCore.Qt.Checked
elif any(childStates):
# only some children are checked...
return QtCore.Qt.PartiallyChecked
# no item is checked, so bad :-(
return QtCore.Qt.Unchecked
return super(TreeModel, self).data(index, role)
def checkStateChange(self, topLeft, bottomRight):
# if you need some control back to your data outside the model, here is
# the right place to do it; note that *usually* the topLeft and
# bottomRight indexes are the same, expecially with QStandardItemModels
# but that would not be the same in some special cases
pass
class Window(QtWidgets.QWidget):
def __init__(self):
QtWidgets.QWidget.__init__(self)
layout = QtWidgets.QGridLayout()
self.setLayout(layout)
self.treeView = QtWidgets.QTreeView()
layout.addWidget(self.treeView)
self.models = []
self.expandStates = {}
for i, dataSet in enumerate(dataSets):
model = TreeModel(dataSet)
button = QtWidgets.QPushButton('Data-{:02}'.format(i + 1))
layout.addWidget(button)
button.clicked.connect(lambda _, model=model: self.setModel(model))
def getExpandState(self, expDict, model, index=QtCore.QModelIndex()):
# set the index expanded state, if it's not the root index:
# the root index is not a valid index!
if index.isValid():
expDict[index] = self.treeView.isExpanded(index)
# if the index (or root index) has children, set their states
for row in range(model.rowCount(index)):
for col in range(model.columnCount(index)):
childIndex = model.index(row, col, index)
# if the current index has children, set their expand state
# using this function, which is recursive
for childRow in range(model.rowCount(childIndex)):
self.getExpandState(expDict, model, childIndex)
def setModel(self, model):
if self.treeView.model():
if self.treeView.model() == model:
# the model is the same, no need to update anything
return
# save the expand states of the current model before changing it
prevModel = self.treeView.model()
self.expandStates[prevModel] = expDict = {}
self.getExpandState(expDict, prevModel)
self.treeView.setModel(model)
if model in self.expandStates:
# if the new model has expand states saved, restore them
for index, expanded in self.expandStates.get(model, {}).items():
self.treeView.setExpanded(index, expanded)
else:
self.treeView.expandAll()
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
w = Window()
w.show()
sys.exit(app.exec_())
[1]: In this example the dataChanged signal is emitted whenever any child item check state changes. This isn't a big issue, but if you really need to avoid unnecessary dataChanged notifications you might need to add a QtCore.QTimer.singleshot delayed dataChanged signal emission only if the parent state has changed. It's not that hard to achieve, but I didn't think it was really necessary for this example.