QListWidget item editing

JonB

@dheerendra
Yep, I looked through all those. None of them pick up, e.g., terminating editing, at least, so no good....

dheerendra

terminatingEditing has to be custom. You have no choice other the your own delegate :)

JonB

@dheerendra
Yep, that's fine, as I wrote to @VRonin above, I am presently having a go at his code (converted to Python/PyQt!) to get me going....

DyraSan

Hey, I am newbie

and I want to know how to edit a QListWidget item without removing it to edit and adding back?

thanks,

Kissanime

VRonin

listWidget->item(i)->setData(role,data);

JonB

@VRonin
OK, I have come up with the basics which I believe emulates/corresponds to your C++ as best I can. I now have a further question about something which you don't do in your example which I would like.

First, I'll paste the guts of my Python/PyQt code. You'll see it's rather different in signals/slots/emits. This may help or hinder, I don't know, feel free to ignore if that's best.

class JEditableListStyledItemDelegate(QtWidgets.QStyledItemDelegate):
    # class variable for "editStarted" signal
    editStarted = QtCore.pyqtSignal(name='editStarted')
    # class variable for "editFinished" signal
    editFinished = QtCore.pyqtSignal(name='editFinished')

    def __init__(self, parent: QtCore.QObject=None):
        super().__init__(parent)

        self.closeEditor.connect(self.editFinished)

    def setEditorData(self, editor: QtWidgets.QWidget, index: QtCore.QModelIndex):
        self.editStarted.emit()
        return super().setEditorData(editor, index)


class JEditableListWidget(QtWidgets.QListWidget):
    # class variable for "editStarted" signal
    editStarted = QtCore.pyqtSignal(name='editStarted')
    # class variable for "editFinished" signal
    editFinished = QtCore.pyqtSignal(name='editFinished')

    def __init__(self, parent: QtWidgets.QWidget=None):
        super().__init__(parent)

        styledItemDelegate = JEditableListStyledItemDelegate(self)
        styledItemDelegate.editStarted.connect(self.editStarted)
        styledItemDelegate.editFinished.connect(self.editFinished)
        self.setItemDelegate(styledItemDelegate)

The above "works". The JEditableListStyledItemDelegate emits its own editStarted/Finished signals. The JEditableListWidget "redirects" those signals to its own editStarted/Finished signals, for the outside world to slot onto. So far so good?

Now, if you look at a QListWidget signal for an item like http://doc.qt.io/qt-5/qlistwidget.html#itemChanged, its signature is QListWidget::itemChanged(QListWidgetItem *item). Hence it sends to the outside world a parameter of the QListWidgetItem which has been changed. My editStarted/Finished signals should do the same.

Now I get stuck as to how I'm supposed to do that.

I start by changing my JEditableListWidget signals to:

class JEditableListWidget(QtWidgets.QListWidget):
    # class variable for "editStarted" signal, including item
    editStarted = QtCore.pyqtSignal(QtWidgets.QListWidgetItem, name='editStarted')
    # class variable for "editFinished" signal, including item
    editFinished = QtCore.pyqtSignal(QtWidgets.QListWidgetItem, name='editFinished')

The extra first parameter of QtWidgets.QListWidgetItem declares the signal as forwarding the item as a parameter.

Now how do I pass that? I believe that (a) I will need a lambda for the signal and (b) I need to know what item is being edited. I think where I had:

styledItemDelegate.editStarted.connect(self.editStarted)

I now need something like:

styledItemDelegate.editStarted.connect(lambda: self.editStarted(someItemWidget))

[Actually I suspect it might be more like:

styledItemDelegate.editStarted.connect(lambda: self.editStarted.emit(someItemWidget))

]
Could you tell me:

Is this how you would do it in C++ (e.g. with a lambda)? (If not, I may be doing it wrong.) Could you show me your C++ for how you would do this and I will attempt to figure it to PyQt? (Also, I believe your code omitted an emit because I know that's a NO-OP in C++; but could you include it wherever it should be, because in PyQt you can see we have to use emit as a function.)
How do I calculate what the someItemWidget will be, from inside my JEditableListWidget?

VRonin

It's actually super easy.
In the delegate:

add an argument of type QtCore.QModelIndex to the signals.
remove self.closeEditor.connect(self.editFinished)
change self.editStarted.emit() to self.editStarted.emit(index)
add

def destroyEditor(self, editor: QtWidgets.QWidget, index: QtCore.QModelIndex):
        self.editFinished.emit(index)
        return super().destroyEditor(editor, index)

Now in JEditableListWidget you can connect a slot that accepts a QtCore.QModelIndex. To find the corresponding QListWidgetItem you can just call item(index.row())

JonB

@VRonin
TVM. I'll implement next week. You're passing the QtCore.QModelIndex available in the JEditableListStyledItemDelegate class up the signal chain to indicate which QListWidgetItem was acted upon. I thought the JEditableListWidget class would know which item in the list was being edited, but seemingly not?

JonB

@VRonin
Well, I followed your principle of having the QStyledItemDelegate emit signals with the QModelIndex as a parameter.

I diverged from yours slightly. Given that I'm now overriding destroyEditor() so as to access the index, it seems to me that I might as well be consistent and override createEditor() for beginning editing. So the following two overrides:

class JEditableListStyledItemDelegate(QtWidgets.QStyledItemDelegate):
    # class variable for "editStarted" signal, with QModelIndex parameter
    editStarted = QtCore.pyqtSignal(QtCore.QModelIndex, name='editStarted')
    # class variable for "editFinished" signal, with QModelIndex parameter
    editFinished = QtCore.pyqtSignal(QtCore.QModelIndex, name='editFinished')

    def createEditor(self, parent: QtWidgets.QWidget, option: QtWidgets.QStyleOptionViewItem, index: QtCore.QModelIndex):
        editor = super().createEditor(parent, option, index)
        if editor is not None:
            self.editStarted.emit(index)
        return editor

    def destroyEditor(self, editor: QtWidgets.QWidget, index: QtCore.QModelIndex):
        self.editFinished.emit(index)
        return super().destroyEditor(editor, index)

The above seems to give me fairly reliable signals for what I want, e.g. disable other buttons for doing things to QListWidget (add row, delete row) while the user is editing a row.

Seem reasonable to you? Thanks for all your input.

VRonin

@JonB said in QListWidget item editing:

Given that I'm now overriding destroyEditor() so as to access the index, it seems to me that I might as well be consistent and override createEditor() for beginning editing.

Only doubt I have is if the delegate recycles the editor. Try going from editing 1 cell to editing another one directly and see if both create and destroy are called or it just calls setEditorData

JonB

@VRonin
OK, thanks! You should have said that concern was why you had overridden different/"inconsistent" methods, I had no idea why! Tried with direct click to edit another item, all is well, does call destroy and then create.

So I shall mark what I did as the solution to my original question. TVM.

P.S.
Your Xmas hat looks good. But a lot of others are also wearing them...! :)

mrjj

@JonB said in QListWidget item editing:

Your Xmas hat looks good. But a lot of others are also wearing them...! :)

Well that is is on purpose :)

VRonin

@JonB said in QListWidget item editing:

Your Xmas hat looks good

All credit goes to @mrjj