I have a
QTreeView with a
QStyledItemDelegate inside of it. When a certain action occurs to the delegate, its size is supposed to change. However I haven’t figured out how to get the
QTreeView‘s rows to resize in response to the delegate’s editor size changing. I tried
QTreeView.repaint and a couple other things but it doesn’t seem to work. Could someone point me in the right direction?
Here’s a minimal reproduction (note: The code is hacky in a few places, it’s just meant to be a demonstration of the problem, not a demonstration of good MVC).
- Run the code below
- Press either “Add a label” button
- Note that the height of the row in the
QTreeViewdoes not change no matter how many times either button is clicked.
from PySide2 import QtCore, QtWidgets _VALUE = 100 class _Clicker(QtWidgets.QWidget): clicked = QtCore.Signal() def __init__(self, parent=None): super(_Clicker, self).__init__(parent=parent) self.setLayout(QtWidgets.QVBoxLayout()) self._button = QtWidgets.QPushButton("Add a label") self.layout().addWidget(self._button) self._button.clicked.connect(self._add_label) self._button.clicked.connect(self.clicked.emit) def _add_label(self): global _VALUE _VALUE += 10 self.layout().addWidget(QtWidgets.QLabel("Add a label")) self.updateGeometry() # Note: I didn't expect this to work but added it regardless class _Delegate(QtWidgets.QStyledItemDelegate): def createEditor(self, parent, option, index): widget = _Clicker(parent=parent) viewer = self.parent() widget.clicked.connect(viewer.updateGeometries) # Note: I expected this to work return widget def paint(self, painter, option, index): super(_Delegate, self).paint(painter, option, index) viewer = self.parent() if not viewer.isPersistentEditorOpen(index): viewer.openPersistentEditor(index) def setEditorData(self, editor, index): pass def updateEditorGeometry(self, editor, option, index): editor.setGeometry(option.rect) def sizeHint(self, option, index): hint = index.data(QtCore.Qt.SizeHintRole) if hint: return hint return super(_Delegate, self).sizeHint(option, index) class _Model(QtCore.QAbstractItemModel): def __init__(self, parent=None): super(_Model, self).__init__(parent=parent) self._labels = ["foo", "bar"] def columnCount(self, parent=QtCore.QModelIndex()): return 1 def data(self, index, role): if role == QtCore.Qt.SizeHintRole: return QtCore.QSize(200, _VALUE) if role != QtCore.Qt.DisplayRole: return None return self._labels[index.row()] def index(self, row, column, parent=QtCore.QModelIndex()): child = self._labels[row] return self.createIndex(row, column, child) def parent(self, index): return QtCore.QModelIndex() def rowCount(self, parent=QtCore.QModelIndex()): if parent.isValid(): return 0 return len(self._labels) application = QtWidgets.QApplication() view = QtWidgets.QTreeView() view.setModel(_Model()) view.setItemDelegate(_Delegate(parent=view)) view.show() application.exec_()
How do I get a single row in a
QTreeView, which has a persistent editor applied already to it, to tell Qt to resize in response to some change in the editor?
Note: One possible solution would be to close the persistent editor and re-open it to force Qt to redraw the editor widget. This would be generally very slow and not work in my specific situation. Keeping the same persistent editor is important.
As the documentation about
updateGeometries() explains, it:
Updates the geometry of the child widgets of the view.
This is used to update the widgets (editors, scroll bars, headers, etc) based on the current view state. It doesn’t consider the editor size hints, so that call or the attempt to update the size hint is useless (and, it should go without saying, using global for this is wrong).
In order to properly notify the view that a specific index has updated its size hint, you must use the delegate’s
sizeHintChanged signal, which should also be emitted when the editor is created in order to ensure that the view makes enough room for it; note that this is normally not required for standard editors (as, being they temporary, they should not try to change the layout of the view), but for persistent editors that are potentially big, it may be necessary.
updateGeometry()on the widget is pointless in this case, as adding a widget to a layout automatically results in a
LayoutRequestevent (which is what
updateGeometry()does, among other things);
- as explained in
createEditor(), “the view’s background will shine through unless the editor paints its own background (e.g., with setAutoFillBackground())”;
SizeHintRoleof the model should always return a size important for the model (if any), not based on the editor; it’s the delegate responsibility to do that, and the model should never be influenced by any of its views;
- opening a persistent editor in a paint event is wrong; only drawing related aspects should ever happen in a paint function, most importantly because they are called very often (even hundreds of times per second for item views) so they should be as fast as possible, but also because doing anything that might affect a change in geometry will cause (at least) a recursive call;
- signals can be “chained” without using
self._button.clicked.connect(self.clicked)would have sufficed;
Considering all the above, there are two possibilities. The problem is that there is no direct correlation between the editor widget and the index it’s referred to, so we need to find a way to emit
sizeHintChanged with its correct index when the editor is updated.
This can only be done by creating a reference of the index for the editor, but it’s important that we use a QPersistentModelIndex for that, as the indexes might change while a persistent editor is opened (for example, when sorting or filtering), and the index provided in the arguments of delegate functions is not able to track these changes.
Emit a custom signal
In this case, we only use a custom signal that is emitted whenever we know that the layout is changed, and we create a local function in
createEditor that will eventually emit the
sizeHintChanged signal by “reconstructing” the valid index:
class _Clicker(QtWidgets.QWidget): sizeHintChanged = QtCore.Signal() def __init__(self, parent=None): super().__init__(parent) self.setAutoFillBackground(True) layout = QtWidgets.QVBoxLayout(self) self._button = QtWidgets.QPushButton("Add a label") layout.addWidget(self._button) self._button.clicked.connect(self._add_label) def _add_label(self): self.layout().addWidget(QtWidgets.QLabel("Add a label")) self.sizeHintChanged.emit() class _Delegate(QtWidgets.QStyledItemDelegate): def createEditor(self, parent, option, index): widget = _Clicker(parent) persistent = QtCore.QPersistentModelIndex(index) def emitSizeHintChanged(): index = persistent.model().index( persistent.row(), persistent.column(), persistent.parent()) self.sizeHintChanged.emit(index) widget.sizeHintChanged.connect(emitSizeHintChanged) self.sizeHintChanged.emit(index) return widget # no other functions implemented here
Use the delegate’s event filter
We can create a reference for the persistent index in the editor, and then emit the
sizeHintChanged signal in the event filter of the delegate whenever a
LayoutRequest event is received from the editor:
class _Clicker(QtWidgets.QWidget): def __init__(self, parent=None): super().__init__(parent) self.setAutoFillBackground(True) layout = QtWidgets.QVBoxLayout(self) self._button = QtWidgets.QPushButton("Add a label") layout.addWidget(self._button) self._button.clicked.connect(self._add_label) def _add_label(self): self.layout().addWidget(QtWidgets.QLabel("Add a label")) class _Delegate(QtWidgets.QStyledItemDelegate): def createEditor(self, parent, option, index): widget = _Clicker(parent) widget.index = QtCore.QPersistentModelIndex(index) return widget def eventFilter(self, editor, event): if event.type() == event.LayoutRequest: persistent = editor.index index = persistent.model().index( persistent.row(), persistent.column(), persistent.parent()) self.sizeHintChanged.emit(index) return super().eventFilter(editor, event)
Finally, you should obviously remove the
SizeHintRole return in
data(), and in order to open all persistent editors you could do something like this:
def openEditors(view, parent=None): model = view.model() if parent is None: parent = QtCore.QModelIndex() for row in range(model.rowCount(parent)): for column in range(model.columnCount(parent)): index = model.index(row, column, parent) view.openPersistentEditor(index) if model.rowCount(index): openEditors(view, index) # ... openEditors(view)