Qt – update view size on delegate sizeHint change

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.

Other notes:

• calling updateGeometry() on the widget is pointless in this case, as adding a widget to a layout automatically results in a LayoutRequest event (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())";
• the SizeHintRole of 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 emit: 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)