Crashes when moving cellWidgets around in a TableWidget

I am writing a tool that allows me to track some tasks along a path of predifined stages, from something on a backlog, to ToDo, through WIP, Review and finally to done.

I created a custom widget, that will eventually be yellow, not unlike a postit note and perhaps with a bit of formatting it to give it a nice frame, etc... but stopped before getting far enough to make it look right because of this issue.

The idea is that each of these yellow Task widgets will have a stage they are at, and that I can select them in a Table Widget, and move them onto the next or previous stage, which will update taht objects stage, then refresh the TableWidget, read all the widget and where thay should be and set them in their new place.

So I have it kind of working to some degree (below), where I can move the tasks forward and they update location, but I noticed when I click the cells that the widget was previously in, print statement still says that the cell still has a widget there (which kind of makes sense, as code below isn't removing the previous one, but I'd expect to visually still see it). And I can move them forward and backwards, and the information on the tasks does update correctly, but the table won't refresh unless the task moves to a cell that never had a cellWidget in it. Test this by moving it backwards. It works, movnig forward visually does nothing, but moving again, does show up.

I tried clearing the TableWidget and rebuilding from scratch and that crashes. The main issue I am having is that with all these crashes, which is an issue in itself as it makes debugging very tough... When I try and clear the TableWidget (with .clear()) before repopulating, I get this.

Process finished with exit code -1073741819 (0xC0000005)

Same error code if I try removing the old cells by setting the Table Widget to 0 rows before adding the correct number of rows.

A known issue that is less important is when I select a cell without a widget and try and move it, gies me this, but don't worry too much about that fix, as it's known issue.

Process finished with exit code -1073740791 (0xC0000409)

Also tried cleaning up by iterating every cell and if it has a cell widget, remove cell widget before re-setting them to correct place and it still crashes. I'm out of ideas.

Task Widget

import sys
from PyQt5.QtWidgets import (QApplication, QTableWidget, QWidget, QFrame, QHBoxLayout, QLabel,
                            QPushButton,QVBoxLayout)

class Task(QWidget):
    def __init__(self, ID, name, est):
        super(Task, self).__init__()
        # Creates a small widget that will be added to a table widget
        self.ID = ID
        self.name = name
        self.est = est
        #  These cell widgets represent tasks. So each task has a particular 'stage' it is at
        self.stage = 'ToDo'
        self.stages = ['Backlog', 'ToDo', 'WIP', 'Review', 'Done']
        self.objects_labels = {}
        self.initUI()

    def initUI(self):
        # adds a bunch of labels to the widget
        layout = QVBoxLayout()
        frame = QFrame()
        frame.setFrameShape(QFrame.StyledPanel)
        frame.setStyleSheet('background-color: red')
        frame.setLineWidth(2)
        layout.addWidget(frame)
        info = [self.ID, self.name, self.est]
        for section in info:
            self.objects_labels[section] = QLabel(str(section))
            layout.addWidget(self.objects_labels[section])
        self.setLayout(layout)
        self.setStyleSheet('background-color: yellow')

    def task_move(self, forward = True):
        # The main widget will allow me to change the stage of a particular Task
        # The idea is that I update the Table widget to show everything in the right place
        # This function finds out what stage it is at and increments/decrements by one
        index = self.stages.index(self.stage)
        print(self.stages)
        print(index)
        if forward:
            print('--->')
            if self.stage == self.stages[-1]:
                print('Already at the end of process')
                return
            self.stage = self.stages[index + 1]
        else:
            print('<---')
            if self.stage == self.stages[0]:
                print('Already at the start of process')
                return
            self.stage = self.stages[index - 1]

MainWidget

class MainWidget(QWidget):
    def __init__(self):
        super().__init__()
        self.tasks = self.make_tasks()
        self.init_ui()
        self.update_tw()

    def make_tasks(self):
        # Create a few tasks
        a = Task(0, 'Name_A', 44)
        b = Task(0, 'Name_B', 22)
        c = Task(0, 'Name_C', 66)
        d = Task(0, 'Name_D', 90)

        return [a, b, c, d]

    def init_ui(self):
        layout_main = QVBoxLayout()

        self.tw = QTableWidget()
        self.tw.cellClicked.connect(self.cell_clicked)
        self.tw.horizontalHeader().setDefaultSectionSize(120)
        self.tw.verticalHeader().setDefaultSectionSize(120)

        layout_main.addWidget(self.tw)
        layout_bottom_button_bar = QHBoxLayout()

        self.btn_task_backward = QPushButton('<--- Task')
        self.btn_task_backward.clicked.connect(lambda: self.move_task(forward=False))

        self.btn_task_forward = QPushButton('Task --->')
        self.btn_task_forward.clicked.connect(lambda: self.move_task())

        for widget in [self.btn_task_backward, self.btn_task_forward]:
            layout_bottom_button_bar.addWidget(widget)

        layout_main.addLayout(layout_bottom_button_bar)

        self.setLayout(layout_main)
        self.setGeometry(300, 300, 800, 600)
        self.setWindowTitle('MainWidget')
        self.show()

    @property
    def tw_header(self):
        return {'Backlog': 0, 'ToDo': 1, 'WIP': 2, 'Review': 3, 'Done': 4}

    @property
    def selected_indices(self):
        return [(x.row(), x.column()) for x in self.tw.selectedIndexes()]

    @property
    def selected_widgets(self):
        selected_widgets = [self.tw.cellWidget(x[0], x[1]) for x in self.selected_indices]
        print(selected_widgets)
        return selected_widgets


    def move_task(self, forward=True):
        # Crashes if you select a non-widget cell, but thats a known issue
        # Moves the task forward or backward and then prompts to update the TableWidget
        for object in self.selected_widgets:
            object.task_move(forward=forward)
        self.tw.clearSelection()
        self.update_tw()

    def cell_clicked(self, row, column):
        if self.tw.cellWidget(row, column):
            print(self.selected_indices)
            print(self.selected_widgets)
        else:
            print('No Cell Widget here')

    def update_tw(self):
        #I wanted to clear the Table widget and rebuild, but this crashes
        # self.tw.clear()
        self.tw.setHorizontalHeaderLabels(self.tw_header.keys())
        rows = len(self.tasks)
        columns = len(self.tw_header)
        self.tw.setRowCount(rows)
        self.tw.setColumnCount(columns)
        # Looks through each task, and then gets it's stage, and then adds the widget to the correct column
        for index, object in enumerate(self.tasks):
            column = self.tw_header[object.stage]
            print('Setting stage {} for {}\n...to r={}, c={}\n***'.format(object.stage, object, index, column))
            self.tw.setCellWidget(index, column, object)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = MainWidget()
    sys.exit(app.exec_())

From my previous experience, I always found using setCellWidget clunky, underperforming and buggy. Most of the times my Widgets were lost or misplaced, while refreshing the table similarly to the way you are doing it. In addition, I guess you would want to use this "Task Mover" on a larger scale, and from what I could see, setting separate Widgets inside QWidgetItems becomes quite slow when done on loads of items.

My suggestion would be to use style delegates, so that you can customize the look of your items to your liking, without having to deal with the setCellWidget stuff which is giving you problem.

Once you have your own delegate, and paint the items the way you want, you can just keep updating that item data and moving the items around the table by using "take" and "set".

I am not sure if this would be the best way of executing this specific task, but moving towards this direction would probably give you greater flexibility and customisation power in the long run.

import sys
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *


class TaskProperty():
    properties = ["ID", "name", "est", "stage"]
    count = 4
    ID, Name, Est, Stage =  [Qt.UserRole + x for x in range(count)]


STAGES = ['Backlog', 'ToDo', 'WIP', 'Review', 'Done']

class MainWidget(QWidget):
    def __init__(self):
        super(MainWidget, self).__init__()
        self.tasks = self.make_tasks()
        self.init_ui()
        self.update_tw()

    def make_tasks(self):
        # Create a few tasks
        a = Task(0, 'Name_A', 44)
        b = Task(0, 'Name_B', 22)
        c = Task(0, 'Name_C', 66)
        d = Task(0, 'Name_D', 90)

        return [a, b, c, d]

    def init_ui(self):
        layout_main = QVBoxLayout()

        self.tw = QTableWidget()
        # create and set the delegate to the TableWidget
        self.delegate = TaskDelegate(self.tw )
        self.tw.setItemDelegate(self.delegate)

        self.tw.cellClicked.connect(self.cell_clicked)
        self.tw.horizontalHeader().setDefaultSectionSize(120)
        self.tw.verticalHeader().setDefaultSectionSize(120)

        layout_main.addWidget(self.tw)
        layout_bottom_button_bar = QHBoxLayout()

        self.btn_task_backward = QPushButton('<--- Task')
        self.btn_task_backward.clicked.connect(lambda: self.move_task(forward=False))

        self.btn_task_forward = QPushButton('Task --->')
        self.btn_task_forward.clicked.connect(lambda: self.move_task())

        for widget in [self.btn_task_backward, self.btn_task_forward]:
            layout_bottom_button_bar.addWidget(widget)

        layout_main.addLayout(layout_bottom_button_bar)

        self.setLayout(layout_main)
        self.setGeometry(300, 300, 800, 600)
        self.setWindowTitle('MainWidget')
        self.show()

    @property
    def tw_header(self):
        return {'Backlog': 0, 'ToDo': 1, 'WIP': 2, 'Review': 3, 'Done': 4}

    @property
    def selected_indices(self):
        return [(x.row(), x.column()) for x in self.tw.selectedIndexes()]


    def move_task(self, forward=True):
        '''
        To move the task to the next step, we iterate all the items selected.
        If the task can be moved, we take the corresponding item from its current cell and move it to the destination.
        :param forward:
        :return:
        '''
        selected =self.tw.selectedItems()
        for item in selected:
            item.setSelected(False)
            result = item.task_move(forward=forward)
            if result:
                next = 1 if forward else -1
                row = item.row()
                column = item.column()
                moveItem = self.tw.takeItem(row, column)
                self.tw.setItem(row, column + next, moveItem)
                moveItem.setSelected(True)

    def cell_clicked(self, row, column):
        item = self.tw.item(row, column)
        if not isinstance(item, TaskItem):
            print "No Task Item Here"

    def update_tw(self):
        # I wanted to clear the Table widget and rebuild, but this crashes
        # self.tw.clear()
        self.tw.clear()
        self.tw.setHorizontalHeaderLabels(self.tw_header.keys())
        rows = len(self.tasks)
        columns = len(self.tw_header)
        self.tw.setRowCount(rows)
        self.tw.setColumnCount(columns)
        # Looks through each task, and then gets it's stage, and then adds the widget to the correct column
        for row, object in enumerate(self.tasks):
            # create items of our custom type only for the column that need to be filled.
            # the other cells will be filled with null items.
            column = STAGES.index(object.stage)
            print('Setting stage {} for {}\n...to r={}, c={}\n***'.format(object.stage, object, row, column))
            item = TaskItem(object)
            self.tw.setItem(row, column, item)



class TaskDelegate(QStyledItemDelegate):
    '''
    This delegate take care of Drawing our cells the way we want it to be.
    '''
    def paint(self, painter, option, index):
        '''
        Override the Paint function to draw our own cell.
        If the QTableWidgetItem does not have our Data stored in it, we do a default paint
        :param painter:
        :param option:
        :param index:
        :return:
        '''
        painter.save()
        rect = option.rect

        status = index.data(TaskProperty.Stage)
        if status is None:
            return super(TaskDelegate, self).paint(painter, option, index)
        else:
            id = STAGES.index(status)
            pen = painter.pen()
            pen.setBrush(Qt.black)
            painter.setPen(pen)
            if id == index.column():
                rect.translate(3, 3)
                newRect = QRect(rect.x(), rect.y(), rect.width() - 6, 20)
                infos = [index.data(TaskProperty.ID), index.data(TaskProperty.Name), index.data(TaskProperty.Est)]
                painter.setBrush(Qt.red)
                painter.drawRect(newRect)
                painter.setBrush(Qt.yellow)
                for info in infos:
                    newRect.translate(0, 25)
                    painter.drawRect(newRect)
                    painter.drawText(newRect, Qt.AlignHCenter | Qt.AlignVCenter,
                                 str(info))



class TaskItem(QTableWidgetItem):
    '''
    Subclass QTableWidgetItem.
    Probably not needed, since we can set the property when we create the item instead of in the init,
    and keep track of which item is attached to which task object using the Column Index of the table.
    However, this can be useful if you want to attach more specific procedures to your items
    '''
    def __init__(self, task):
        super(TaskItem, self).__init__()
        self._task = task
        self.setData(TaskProperty.ID, task.ID)
        self.setData(TaskProperty.Name, task.name)
        self.setData(TaskProperty.Est, task.est)
        self.setData(TaskProperty.Stage, task.stage)

        self.objects_labels = {}

    def task_move(self, forward=True):
        result = self._task.task_move(forward=forward)
        self.setData(TaskProperty.Stage, self._task.stage)
        return result

class Task(object):
    '''
    The Task class is now just an object, not a widget.
    '''

    def __init__(self, ID, name, est):
        # Creates a small widget that will be added to a table widget
        self.ID = ID
        self.name = name
        self.est = est
        #  These cell widgets represent tasks. So each task has a particular 'stage' it is at
        self.stage = 'ToDo'
        self.stages = ['Backlog', 'ToDo', 'WIP', 'Review', 'Done']
        self.objects_labels = {}

    def task_move(self, forward=True):
        # The main widget will allow me to change the stage of a particular Task
        # The idea is that I update the Table widget to show everything in the right place
        # This function finds out what stage it is at and increments/decrements by one
        index = self.stages.index(self.stage)
        if forward:
            print('--->')
            if self.stage == self.stages[-1]:
                #print('Already at the end of process')
                return False
            self.stage = self.stages[index + 1]
        else:
            print('<---')
            if self.stage == self.stages[0]:
                #print('Already at the start of process')
                return False
            self.stage = self.stages[index - 1]
        return True

if __name__ == '__main__':
    app = QApplication(sys.argv)
    ex = MainWidget()
    sys.exit(app.exec_())