PyQT QPushbutton with toggle function in a table view - python-3.x

Question

I am try to create a Tableview using delegate. Specifically adding a pushbutton at each row
I have added a QPushbutton to a table view as shown below. The pushbutton is checkable, but when the status is checked it always shows false. If I don't use openPersistenteditor, then the push button works but I have to double click.
class ButtonDelegate(QtWidgets.QItemDelegate):
def __init__(self, parent):
QtWidgets.QItemDelegate.__init__(self, parent)
def createEditor(self, parent, option, index):
self.button = QtWidgets.QPushButton(parent)
self.button.setCheckable(True)
self.button.setStyleSheet("background: white;")
self.button.toggled.connect(self.commit_data)
self.button
return self.button
def updateEditorGeometry(self, editor, option, index):
editor.setGeometry(option.rect)
def paint(self, painter, option, index):
value = index.data(QtCore.Qt.EditRole)
opt = QtWidgets.QStyleOptionButton()
opt.state = QtWidgets.QStyle.State_Enabled
opt.state = QtWidgets.QStyle.State_On if value else QtWidgets.QStyle.State_Off
QtWidgets.QApplication.style().drawControl(QtWidgets.QStyle.CE_PushButton, opt, painter)
def commit_data(self):
if self.button.isChecked():
self.button.setStyleSheet("background: black;")
else:
self.button.setStyleSheet("background: blue;")
class Model(QtCore.QAbstractTableModel):
def __init__(self, table):
super().__init__()
self.table = table
def rowCount(self, parent):
return len(self.table)
def columnCount(self, parent):
return len(self.table[0])
def flags(self, index):
return QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable
def data(self, index, role):
if role == QtCore.Qt.DisplayRole:
return self.table[index.row()][index.column()]
def setData(self, index, value, role):
if type(role) == QtCore.QVariant:
self.table[index.row()][index.column()] = role.value()
return True
class Main(QtWidgets.QMainWindow):
def __init__(self, parent=None):
super().__init__(parent)
table = [[False] for i in range(50)]
self.model = Model(table)
self.tableView = QtWidgets.QTableView()
self.tableView.setModel(self.model)
self.tableView.setItemDelegateForColumn(0, ButtonDelegate(self))
for row in range(len(table)) :
self.tableView.openPersistentEditor(self.model.index(row, 0))

Answer 1

First of all, you're combining two different ways of displaying a button, and you should only use one of them.
The paint implementation only draws a button, there's no interaction available, you should implement that using editorEvent().
The createEditor() instead actually creates a button, just like it normally creates a line edit for standard text fields.
Using the editor (along with the openPersistentEditor) is probably the simpler choice, but it's a good choice only as long as the model is relatively small. If you plan in having hundreds or thousands of items, the paint implementation is certainly better for performance.
Now, assuming you'll go for the easy way (the editor), the problem is that you're constantly overwriting self.button everytime a new editor is requested. The result is that self.button will always refer to the last button created. Remember, whenever a function dynamically creates a new object (without deleting the previously created ones), setting that object as an instance attribute is pointless, as you're creating a reference that will be overwritten the next time the function gets called.
A possible solution is to use a lambda for the signal, and send the button instance as argument for the function:
class ButtonDelegate(QtWidgets.QItemDelegate):
# ...
def createEditor(self, parent, option, index):
button = QtWidgets.QPushButton(parent)
button.setCheckable(True)
button.setStyleSheet("background: white;")
button.toggled.connect(lambda: self.commit_data(button))
return button
def commit_data(self, button):
if button.isChecked():
button.setStyleSheet("background: black;")
else:
button.setStyleSheet("background: blue;")
A suggestion: use line spacings between functions and classes. Your code is so condensed that it's actually very difficult to read it; adding spaces between functions makes it more easy to read and understand where functions start and end, which dramatically improves readability of your code, which is a very important aspect you should not underestimate. Read more about this and other related subjects in the official Style Guide for Python Code.