[FIXED] Update Object when Checkbox clicked in QTableView

Issue

I've been learning python a fair it lately and I've come across a few questions here and I'm not entirely sure how to solve them. Each item in the Table is displaying data from a class object called PlayblastJob. This is being built using Python and PySide.

1. When a user selects a bunch of rows in the Table and clicks 'Randomize Selected Values', the displayed data does not update until the cursor hovers over the table or i click something in the view. How can i refresh the data in all the columns and rows each time the button is clicked?

2. When a user clicks the 'Checkbox' how can I have that signal set the property 'active' of that rows particular Job object instance?

Code that creates ui in screenshot above:

import os
import sys
import random
from PySide import QtCore, QtGui


class PlayblastJob(object):
    def __init__(self, **kwargs):
        super(PlayblastJob, self).__init__()

        # instance properties
        self.active = True
        self.name = ''
        self.camera = ''
        self.renderWidth = 1920
        self.renderHeight = 1080
        self.renderScale = 1.0
        self.status = ''

        # initialize attribute values
        for k, v in kwargs.items():
            if hasattr(self, k):
                setattr(self, k, v)


    def getScaledRenderSize(self):
        x = int(self.renderWidth * self.renderScale)
        y = int(self.renderHeight * self.renderScale)
        return (x,y)


class JobModel(QtCore.QAbstractTableModel):

    HEADERS = ['Name', 'Camera', 'Resolution', 'Status']

    def __init__(self):
        super(JobModel, self).__init__()
        self.items = []


    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
        if orientation == QtCore.Qt.Horizontal:
            if role == QtCore.Qt.DisplayRole:
                return self.HEADERS[section]
        return None


    def columnCount(self, parent=QtCore.QModelIndex()):
        return len(self.HEADERS)


    def rowCount(self, parent=QtCore.QModelIndex()):
        return len(self.items)


    def appendJob(self, *items):
        self.beginInsertRows(QtCore.QModelIndex(), self.rowCount(), self.rowCount() + len(items) - 1)
        for item in items:
            assert isinstance(item, PlayblastJob)
            self.items.append(item)
        self.endInsertRows()


    def removeJobs(self, items):
        rowsToRemove = []
        for row, item in enumerate(self.items):
            if item in items:
                rowsToRemove.append(row)
        for row in sorted(rowsToRemove, reverse=True):
            self.beginRemoveRows(QtCore.QModelIndex(), row, row)
            self.items.pop(row)
            self.endRemoveRows()


    def clear(self):
        self.beginRemoveRows(QtCore.QModelIndex(), 0, self.rowCount())
        self.items = []
        self.endRemoveRows()


    def data(self, index, role=QtCore.Qt.DisplayRole):
        if not index.isValid():
            return

        row = index.row()
        col = index.column()

        if 0 <= row < self.rowCount():
            item = self.items[row]
            if role == QtCore.Qt.DisplayRole:
                if col == 0:
                    return item.name
                elif col == 1:
                    return item.camera
                elif col == 2:
                    width, height = item.getScaledRenderSize()
                    return '{} x {}'.format(width, height)
                elif col == 3:
                    return item.status.title()
            elif role == QtCore.Qt.ForegroundRole:
                if col == 3:
                    if item.status == 'error':
                        return QtGui.QColor(255, 82, 82)
                    elif item.status == 'success':
                        return QtGui.QColor(76, 175, 80)
                    elif item.status == 'warning':
                        return QtGui.QColor(255, 193, 7)
            elif role == QtCore.Qt.TextAlignmentRole:
                if col == 2:
                    return QtCore.Qt.AlignCenter
                if col == 3:
                    return QtCore.Qt.AlignCenter
            elif role == QtCore.Qt.CheckStateRole:
                if col == 0:
                    if item.active:
                        return QtCore.Qt.Checked
                    else:
                        return QtCore.Qt.Unchecked
            elif role == QtCore.Qt.UserRole:
                return item
        return None


class JobQueue(QtGui.QWidget):
    '''
    Description:
        Widget that manages the Jobs Queue
    '''
    def __init__(self):
        super(JobQueue, self).__init__()
        self.resize(400,600)

        # controls
        self.uiAddNewJob = QtGui.QPushButton('Add New Job')
        self.uiAddNewJob.setToolTip('Add new job')

        self.uiRemoveSelectedJobs = QtGui.QPushButton('Remove Selected')
        self.uiRemoveSelectedJobs.setToolTip('Remove selected jobs')

        self.jobModel = JobModel()
        self.uiJobTableView = QtGui.QTableView()
        self.uiJobTableView.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
        self.uiJobTableView.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
        self.uiJobTableView.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
        self.uiJobTableView.setModel(self.jobModel)

        self.jobSelection = self.uiJobTableView.selectionModel()

        self.uiRandomize = QtGui.QPushButton('Randomize Selected Values')
        self.uiPrintJobs = QtGui.QPushButton('Print Jobs')

        # sub layouts
        self.jobQueueToolsLayout = QtGui.QHBoxLayout()
        self.jobQueueToolsLayout.addWidget(self.uiAddNewJob)
        self.jobQueueToolsLayout.addWidget(self.uiRemoveSelectedJobs)
        self.jobQueueToolsLayout.addStretch()
        self.jobQueueToolsLayout.addWidget(self.uiRandomize)

        # layout
        self.mainLayout = QtGui.QVBoxLayout()
        self.mainLayout.addLayout(self.jobQueueToolsLayout)
        self.mainLayout.addWidget(self.uiJobTableView)
        self.mainLayout.addWidget(self.uiPrintJobs)
        self.setLayout(self.mainLayout)

        # connections
        self.uiAddNewJob.clicked.connect(self.addNewJob)
        self.uiRemoveSelectedJobs.clicked.connect(self.removeSelectedJobs)
        self.uiRandomize.clicked.connect(self.randomizeSelected)
        self.uiPrintJobs.clicked.connect(self.printJobs)


    # methods
    def addNewJob(self):
        name = random.choice(['Kevin','Melissa','Suzie','Eddie','Doug'])
        job = PlayblastJob(name=name, camera='Camera001', startFrame=50)
        self.jobModel.appendJob(job)

    def removeSelectedJobs(self):
        jobs = self.getSelectedJobs()
        self.jobModel.removeJobs(jobs)

    def getSelectedJobs(self):
        jobs = [x.data(QtCore.Qt.UserRole) for x in self.jobSelection.selectedRows()]
        return jobs

    def randomizeSelected(self):
        jobs = self.getSelectedJobs()
        for job in jobs:
            job.camera = random.choice(['Canon','Nikon','Sony','Red'])
            job.status = random.choice(['error','warning','success'])

    def printJobs(self):
        jobs = self.jobModel.items
        for job in jobs:
            print vars(job)

def main():
    app = QtGui.QApplication(sys.argv)
    window = JobQueue()
    window.show()
    app.exec_()


if __name__ == '__main__':
    main()

Solution

The data in a Qt item model should always be set using setData().

The obvious reason is that the default implementations of item views always call that method whenever the data is modified by the user (eg. manually editing the field), or more programmatically (checking/unchecking a checkable item, like in your case). The other reason is for more consistency with the whole model structure of Qt framework, which should not be ignored.

In any way, the most important thing is that whenever the data is changed, the dataChanged() signal must be emitted. This ensures that all views using the model are notified about the change and eventually update themselves accordingly.

So, while you could manually emit the dataChanged signal from your randomizeSelected function, I would advise you against so.
The dataChanged should only be emitted for the indexes that have actually changed. While you could theoretically emit a generic signal that has the top-left and bottom-right indexes, it's considered bad practice: the view doesn't know what data (and role) has changed and if it gets a signal saying that the whole model has changed it will have to do lots of computations; even if those computations might seem to happen instantly, if you only change even a single index text they become absolutely unnecessary. I know that yours is a very simple model, but for learning purposes it's important to keep this in mind.
On the other hand, if you want to correctly emit the signal for the changed index alone, this means that you need to manually create the model.index() correctly, making the whole structure unnecessary complex, especially if at some point you need more ways to change the data.
In any case, there's no direct and easy way to do so when dealing with checkable items, since it's up to the view to notify the model about the check state change.

Using setData() allows you to have a centralized way to actually set the data to the model and ensure that everything is correctly updated accordingly. Any other method is not only discouraged, but may lead to unexpected behavior (like yours).

Finally, abstract models only have the ItemIsEnabled and ItemIsSelectable flags, so in order to allow checking and uncheking items, you need to override the flags() method too to add the ItemIsUserCheckable flag, and then implement the relative check in the setData().

class JobModel(QtCore.QAbstractTableModel):
    # ...
    def setData(self, index, data, role=QtCore.Qt.EditRole):
        if role in (QtCore.Qt.EditRole, QtCore.Qt.DisplayRole):
            if index.column() == 0:
                self.items[index.row()].name = data
            elif index.column() == 1:
                self.items[index.row()].camera = data
            # I'm skipping the third column check, as you will probably need some 
            # custom function there, assuming it should be editable
            elif index.column() == 3:
                self.items[index.row()].status = data
            else:
                return False
            self.dataChanged.emit(index, index)
            return True
        elif role == QtCore.Qt.CheckStateRole and index.column() == 0:
            self.items[index.row()].active = bool(data)
            self.dataChanged.emit(index, index)
            return True
        return False

    def flags(self, index):
        flags = super().flags(index)
        if index.column() == 0:
            flags |= QtCore.Qt.ItemIsUserCheckable
        return flags


class JobQueue(QtGui.QWidget):
    # ...
    def randomizeSelected(self):
        for index in self.jobSelection.selectedRows():
            self.jobModel.setData(index.sibling(index.row(), 1), 
                random.choice(['Canon','Nikon','Sony','Red']))
            self.jobModel.setData(index.sibling(index.row(), 3), 
                random.choice(['error','warning','success']))

Note: selectedRows() defaults to the first column, so I'm using index.sibling() to get the correct index of the second and fourth column at the same row.

Note²: PySide has been considered obsolete from years. You should update to PySide2 at least.

Answered By - musicamante