Recommended approach for cell validation on dynamic table.
The scenario: I have a QDialog where based on different dropdown selections 1 or more tables are dynamically added. Because tables are dynamically added, the standard cell clicked signal is not enough. It only provides the row and column, and I need to know which table was clicked in addition to the row and column. More specifically, I have 2 columns with integer values. When a cell is changed in one of the columns, they must be within a valid range, and the value of the cell in the 2nd column must be >= value of the cell in the first column.
I'm fairly new to Python, but my thinking is that I need to create a class that extends the QTableWidgetItem with the additional information I need and sends a custom signal, which I can then wire up to a slot within the dialog. I've tried several variations of the following code, but can't get things quite right:
class SmartCell(QtCore.QObject):
valueChanged = QtCore.pyqtSignal(str) # Signal to be emitted when value changes.
def __init__(self, tbl, rowname, colname, value):
QtGui.QTableWidgetItem.__init__(self)
self.tbl_name = tbl
self.row_name = rowname
self.col_name = colname
# self.setText(value)
self.__value = value
#property
def value(self):
return self.__value
#value.setter
def value(self, value):
if self.__value != value:
self.__value = value
# self.setText(value)
signal = self.tbl_name + ":" + self.row_name + ":" + self.col_name + ":" + self.text()
self.valueChanged.emit(signal)
and then in the dialog, after importing the SmartCell reference as sCell:
item = sCell(obj_name, f.part_name, "start_frame", str(f.start_frame))
item.valueChanged.connect(self.frame_cell_changed)
tbl.setItem(rowcounter, 1, item)
item = sCell(obj_name, f.part_name, "end_frame", str(f.end_frame))
item.valueChanged.connect(self.frame_cell_changed)
tbl.setItem(rowcounter, 2, item)
You're getting too complicated, the task of validating what a delegate should do instead of using create a post-validation logic with the QTableWidgetItems.
import random
from PyQt4 import QtCore, QtGui
class LimistDelegate(QtGui.QStyledItemDelegate):
def createEditor(self, parent, option, index):
editor = super(LimistDelegate, self).createEditor(parent, option, index)
if index.column() in (1, 2):
editor = QtGui.QSpinBox(parent)
return editor
def setEditorData(self, editor, index):
if index.column() in (1, 2):
m = 0 if index.column() == 1 else index.sibling(index.row(), 1).data()
M = index.sibling(index.row(), 2).data() if index.column() == 1 else 360
if hasattr(m, 'toPyObject'):
m = m.toPyObject()
if hasattr(M, 'toPyObject'):
M = M.toPyObject()
editor.setMinimum(m)
editor.setMaximum(M)
super(LimistDelegate, self).setEditorData(editor, index)
def create_table():
nrows, ncols = random.randrange(3, 6), 3
table = QtGui.QTableWidget(nrows, ncols)
for r in range(nrows):
text = "description {}".format(r)
a = random.randrange(0, 180)
b = random.randrange(a, 360)
for c, val in enumerate([text, a, b]):
it = QtGui.QTableWidgetItem()
it.setData(QtCore.Qt.DisplayRole, val) # set data on item
table.setItem(r, c, it)
return table
class Widget(QtGui.QWidget):
def __init__(self, parent=None):
super(Widget, self).__init__(parent)
vlay = QtGui.QVBoxLayout(self)
for _ in range(4):
table = create_table()
delegate = LimistDelegate(table) # create delegate
table.setItemDelegate(delegate) # set delegate
vlay.addWidget(table)
if __name__ == '__main__':
import sys
app = QtGui.QApplication(sys.argv)
w = Widget()
w.show()
sys.exit(app.exec_())
Related
I am playing with the model/view programming with pyqt to try to understand it.
My problem is that when I try si select in item from the already selected group of items the onSelection changed event does not trigger, and the selection behaviour becomes weird. (Not only cannot select items from previously selected butn also contiguous selections take place...).
If I comment the def data(self, _index, role=Qt.DisplayRole): method I get the behaviour I want, so I guess I am missing something with the way the data is populated in the table. But I cannot populate data in the table if this is commented (Hello :)).
I tried to handle it with the onMouseClick event and with the selection behaviour with no sucess.
The selection behaviour I want can be found also in this example:
https://wiki.python.org/moin/PyQt/Reading%20selections%20from%20a%20selection%20model
Find below my code, which might be a bit messy as I am making just some trials (sorry for that).
Any comment will be much appreciatted, many thanks.
from PyQt5.QtWidgets import QApplication, QTableView, QAbstractItemView
import sys
from PyQt5.QtCore import QAbstractTableModel, Qt, QModelIndex, QItemSelection, QItemSelectionModel, QAbstractItemModel
class myTableModel(QAbstractTableModel):
def __init__(self, rows, columns, parent=None, *args):
QAbstractTableModel.__init__(self, parent, *args)
self.rowCount = rows
self.columnCount = columns
self.table_data = [[None] * columns for _ in range(rows)]
self.unselectedItems = []
def rowCount(self, parent):
return self.rowCount
def columnCount(self, parent):
return self.columnCount
def flags(self, index):
return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable
def data(self, _index, role=Qt.DisplayRole):
if role == Qt.DisplayRole and _index.isValid():
row = _index.row()
column = _index.column()
item = _index.internalPointer()
if item is not None:
print(item)
value = self.table_data[row][column]
# print('value returned: ' + str(value) + ' row: ' + str(row) + ' col: ' + str(column))
return value
else:
return None
def setData(self, _index, value, role=Qt.EditRole):
if role == Qt.EditRole and _index.isValid():
# print(_index.row())
# self.arraydata[index.row()] = [value]
# print('Return from rowCount: {0}'.format(self.rowCount(index)))
row = _index.row()
column = _index.column()
self.table_data[row][column] = value
self.dataChanged.emit(_index, _index)
return True
return QAbstractTableModel.setData(self, index, value, role)
def updateSelection(self, selected, deselected):
selectedItems = selected.indexes()
for _index in selectedItems:
_text = f"({_index.row()}, {_index.column()})"
self.setData(_index, _text)
del selectedItems[:]
self.unselectedItems = deselected.indexes()
for _index in self.unselectedItems:
_text = "previous selection"
self.setData(_index, _text)
print('unselected item: ' + str(_index))
class myTableView(QTableView):
def __init__(self, rowCount, columnCount, model):
super().__init__()
self.rowCount = rowCount
self.columnCount = columnCount
self.model = model
self.setModel(model)
self.selectionModel().selectionChanged.connect(tblModel.updateSelection)
self.setSelectionMode(QAbstractItemView.ContiguousSelection)
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton:
selectedItems = self.selectedIndexes()
allIndexes = []
for i in range(self.rowCount):
for j in range(self.columnCount):
allIndexes.append(self.model.index(i, j))
# print('all indexes appended')
indexesToClear = [_index for _index in allIndexes if
_index not in selectedItems and _index not in self.model.unselectedItems]
for _index in indexesToClear:
valueFromIndex = str(self.model.data(_index, Qt.DisplayRole))
if valueFromIndex == "previous selection":
self.model.setData(_index, "")
# def mousePressEvent(self, event):
# if event.button() == Qt.LeftButton:
# self.selectionModel().reset()
app = QApplication(sys.argv)
tblModel = myTableModel(8, 4, app) # create table model
tblView = myTableView(8, 4, tblModel)
topLeft = tblModel.index(0, 0, QModelIndex())
bottomRight = tblModel.index(5, 2, QModelIndex())
selectionMode = tblView.selectionModel()
selection = QItemSelection(topLeft, bottomRight)
selectionMode.select(selection, QItemSelectionModel.Select)
# set selected indexes text to selection
indexes = selectionMode.selectedIndexes()
for index in indexes:
text = str(index.row()) + str(index.column())
tblModel.setData(index, text, role=Qt.EditRole)
tblView.show()
app.exec()
The behavior is erratic also because you didn't call the base class implementation of mouseReleaseEvent, which does some operations required to correctly update the selection, including deselecting the previously selected items except the current/new one (but the behavior can change according to the view's selectionMode).
Also, consider that the selectionChanged signal of the selection model only emits the changes: if an item was already selected when the selection changes, it will not be listed in the selected list of the signal argument.
In order to access the full list of selected items, you'll need to call the selectedIndexes() of the view, or its selection model.
class myTableView(QTableView):
def __init__(self, model):
super().__init__()
# no need for these
# self.rowCount = rowCount
# self.columnCount = columnCount
# NEVER overwrite existing class property names!
# self.model = model
self.setModel(model)
self.selectionModel().selectionChanged.connect(self.updateSelection)
self.setSelectionMode(QAbstractItemView.ContiguousSelection)
def updateSelection(self, selected, deselected):
selectedIndexes = self.selectedIndexes()
for row in range(model.rowCount()):
for column in range(model.columnCount()):
_index = model.index(row, column)
if _index in selectedIndexes:
_text = f"({_index.row()}, {_index.column()})"
elif _index in deselected:
_text = "previous selection"
else:
_text = ""
model.setData(_index, _text)
I also removed the rowCount and columnCount arguments for the table init, as it's redundant (and prone to errors if you change the model size): their values only depend on the model's own size, and you should access them only through it.
Finally, you should never overwrite existing class attributes; other than the self.model I commented out above, this also goes for self.rowCount and self.columnCount you used in the model (which also doesn't make much sense, as the public methods would return the methods themselves, causing recursion).
I have a custom Qt table model that allows a user to add both columns and rows after it's been created. I'm trying to display this table using a QSortFilterProxyModel / QTableView setup, but I'm getting strange behavior when I try and enable sorting on the table view. My view launches and displays the added data correctly:
However, when I click on one of the column headers (to sort), phantom columns are added to the view.
Has anyone seen this before or know whats going on? I'm admittedly a novice still with Qt, so maybe I'm just approaching this the wrong way. Thanks.
# -*- mode:python; mode:auto-fill; fill-column:79; coding:utf-8 -*-
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
# =====================================================================
# =====================================================================
class SimpleProxyModel(QSortFilterProxyModel):
def filterAcceptsColumn(self, col, index):
return True
# =====================================================================
# =====================================================================
class SimpleModel(QAbstractTableModel):
def __init__(self):
super(SimpleModel, self).__init__()
self._data = {}
def rowCount(self, index=QModelIndex()):
if len(self._data.values()) > 0:
return len(self._data.values()[0])
else:
return 0
def columnCount(self, index=QModelIndex()):
return len(self._data.keys())
def data( self, index, role = Qt.DisplayRole ):
row, col = index.row(), index.column()
if ( not index.isValid() or
not ( 0 <= row < self.rowCount() ) or
not ( 0 <= col < self.columnCount() ) ):
return QVariant()
if role == Qt.DisplayRole:
return QVariant( self._data[col][row] )
return QVariant()
def addData( self, col, val):
new_col = False
# Turn on flag for new column
if col not in self._data.keys():
new_col = True
if new_col:
self.beginInsertColumns(QModelIndex(), self.columnCount(),self.columnCount())
# Catch this column up with the others by adding blank rows
self._data[col] = [""] * self.rowCount()
self.beginInsertRows(QModelIndex(), self.rowCount(), self.rowCount())
# Add data to each column, either the value specified or a blank
for i in range(self.columnCount()):
if i == col:
self._data[i].append(val)
else:
self._data[i].append( "" )
self.endInsertRows()
if new_col:
self.endInsertColumns()
# =====================================================================
# =====================================================================
class SimpleView(QWidget):
def __init__(self, parent=None):
super(SimpleView, self).__init__(parent)
self._mainmodel = None
self._proxymodel = None
self._tableview = QTableView()
self._tableview.setSortingEnabled(True)
layout = QVBoxLayout()
layout.addWidget( self._tableview )
self.setLayout(layout)
def setModel(self, model):
self._mainmodel = model
proxy = SimpleProxyModel()
proxy.setSourceModel(model)
self._tableview.setModel(proxy)
# =====================================================================
# =====================================================================
app = QApplication([])
v = SimpleView()
m = SimpleModel()
v.setModel( m )
m.addData(0,1)
m.addData(0,2)
m.addData(1,3)
v.show()
app.exec_()
The Qt documentation is fairly clear on this. You must call endInsertRows after beginInsertRows, and endInsertColumns after beginInsertColumns.
The most pertinent point from the last link above is this:
Note: This function emits the columnsAboutToBeInserted() signal which
connected views (or proxies) must handle before the data is inserted.
Otherwise, the views may end up in an invalid state.
So you must call endInsertColum() before beginning any other insertions/deletions.
It looks like the problem was in my SimpleModel.addData method, and is related to how I nested the column and row inserts. If you change this method to first insert new columns, and then insert new rows, the phantom columns don't show up.
def addData( self, col, val):
if col not in self._data.keys():
self.beginInsertColumns(QModelIndex(), self.columnCount(),self.columnCount())
# Catch this column up with the others by adding blank rows
self._data[col] = [""] * self.rowCount()
self.endInsertColumns()
self.beginInsertRows(QModelIndex(), self.rowCount(), self.rowCount())
# Add data to each column, either the value specified or a blank
for i in range(self.columnCount()):
if i == col:
self._data[i].append(val)
else:
self._data[i].append( "" )
self.endInsertRows()
I have a qtablewidget and one of its cell widgets in each row is a qcombobox. I would like to sort the table according to the contents of the qcomboboxes in each row. How to do that? Any help is greatly appreciated.
self.table = QTableWidget(0,5)
self.table.setSortingEnabled(True)
self.table.horizontalHeader().sortIndicatorChanged.connect(self.table_sorting_clicked)
'''some code here'''
def table_sorting_clicked(self,logicalIndex,order):
'''some code here'''
install a QSignalMapper
connect it to the sorting method
connect currentTextChanged()-signal of the comboboxes with the signalmapper
and set the itemData of the cells with the comboboxes to currentText() (necessary, because there is nothing to sort, if all cells contain only comboboxes)
update itemData if currentText() changes.
here a working example in pyqt5:
class MyTableWidget(QtWidgets.QTableWidget):
def __init__(self, parent = None):
QtWidgets.QTableWidget.__init__(self, parent)
self.setRowCount(5)
self.setColumnCount(2)
self.signalMapper = QtCore.QSignalMapper(self)
self.signalMapper.mapped.connect(self.table_sorting_clicked)
self.horizontalHeader().sortIndicatorChanged.connect(self.changeSortOrder)
texts = []
for i in ['A','B','C','D','E','F','G','H','I','J']:
texts.append(i)
for i in range(0,self.rowCount()):
combo = QtWidgets.QComboBox()
combo.addItems(texts)
combo.setCurrentIndex(i)
combo.currentTextChanged.connect(self.signalMapper.map)
self.signalMapper.setMapping(combo, i)
self.setItem(i,0,QtWidgets.QTableWidgetItem(str(i+1)))
self.setItem(i,1,QtWidgets.QTableWidgetItem())
self.setCellWidget(i,1,combo)
self.item(i,1).setData(0, combo.currentText())
self.setSortingEnabled(True)
self.sortOrder = 0
def table_sorting_clicked(self, index):
self.item(index,1).setData(0, self.cellWidget(index,1).currentText())
self.sortByColumn(1,self.sortOrder)
# edit 04.09.2015 19:40
#this doesn't work correctly if called several times
# add the following code:
for i in range(self.rowCount()):
self.signalMapper.removeMappings(self.cellWidget(i,1))
self.cellWidget(i,1).currentTextChanged.connect(self.signalMapper.map)
self.signalMapper.setMapping(self.cellWidget(i,1), i)
def changeSortOrder(self,logicalIndex,order):
self.sortOrder = order
self.sortByColumn(logicalIndex,self.sortOrder)
But perhaps using a delegate would be the better choice for Your purposes. There You can set a QListWidget as editor/selector for the user and You don't need to set item data additionally, the signals will be simpler:
class MyDelegate(QtWidgets.QStyledItemDelegate):
def __init__(self, t, parent=None,):
QtWidgets.QStyledItemDelegate.__init__(self)
self.setParent(parent)
self.editorTexte = t
def createEditor(self,parent, option, index):
if index.column() == 1:
return QtWidgets.QListWidget(parent)
return QtWidgets.QStyledItemDelegate.createEditor(self,parent, option, index)
def setEditorData(self, editor, index):
value = str(index.data())
if index.column() == 1:
for i, v in enumerate(self.editorTexte):
item = QtWidgets.QListWidgetItem(v)
editor.addItem(item)
if v == value:
editor.setCurrentItem(editor.item(i))
x = self.parent().columnViewportPosition(index.column())
y = self.parent().rowViewportPosition(index.row())
w = self.parent().columnWidth(index.column())
h = self.parent().rowHeight(index.row())*5
editor.setGeometry(x,y,w,h)
else:
QtWidgets.QStyledItemDelegate.setEditorData(self, editor, index)
def setModelData(self,editor,model,index):
if index.column() == 1:
v = editor.currentItem().text()
else:
v = editor.text()
model.setData(index, v)
class MyTableWidget(QtWidgets.QTableWidget):
def __init__(self, parent = None):
QtWidgets.QTableWidget.__init__(self, parent)
self.setRowCount(5)
self.setColumnCount(2)
texts = []
for i in ['A','B','C','D','E','F','G','H','I','J']:
texts.append(i)
self.setItemDelegate(MyDelegate(texts, self))
for i in range(0,self.rowCount()):
self.setItem(i,0,QtWidgets.QTableWidgetItem(str(i+1)))
self.setItem(i,1,QtWidgets.QTableWidgetItem(texts[i]))
self.setSortingEnabled(True)
self.sortOrder = 0
self.sortByColumn(1,self.sortOrder)
self.horizontalHeader().sortIndicatorChanged.connect(self.changeSortOrder)
def changeSortOrder(self,logicalIndex,order):
self.sortOrder = order
self.sortByColumn(logicalIndex,self.sortOrder)
I am trying to have a QTableView of checkboxes, so I can use them for row selections... I have managed to do that, now I want the header Itself to be checkbox so I can check/Uncheck All or any row . I have been looking for days, but couldn't get to do it.
I tried to use setHeaderData to the model, but couldn't do it.
Any help would be appreciated.
I wasn't particularly happy with the C++ version that #tmoreau ported to Python as it didn't:
handle more than one column
handle custom header heights (for example multi-line header text)
use a tri-state checkbox
work with sorting
So I fixed all of those issues, and created an example with a QStandardItemModel which I generally would advocate over trying to create your own model based on QAbstractTableModel.
There are probably still some imperfections, so I welcome suggestions for how to improve it!
import sys
from PyQt4 import QtCore, QtGui
# A Header supporting checkboxes to the left of the text of a subset of columns
# The subset of columns is specified by a list of column_indices at
# instantiation time
class CheckBoxHeader(QtGui.QHeaderView):
clicked=QtCore.pyqtSignal(int, bool)
_x_offset = 3
_y_offset = 0 # This value is calculated later, based on the height of the paint rect
_width = 20
_height = 20
def __init__(self, column_indices, orientation = QtCore.Qt.Horizontal, parent = None):
super(CheckBoxHeader, self).__init__(orientation, parent)
self.setResizeMode(QtGui.QHeaderView.Stretch)
self.setClickable(True)
if isinstance(column_indices, list) or isinstance(column_indices, tuple):
self.column_indices = column_indices
elif isinstance(column_indices, (int, long)):
self.column_indices = [column_indices]
else:
raise RuntimeError('column_indices must be a list, tuple or integer')
self.isChecked = {}
for column in self.column_indices:
self.isChecked[column] = 0
def paintSection(self, painter, rect, logicalIndex):
painter.save()
super(CheckBoxHeader, self).paintSection(painter, rect, logicalIndex)
painter.restore()
#
self._y_offset = int((rect.height()-self._width)/2.)
if logicalIndex in self.column_indices:
option = QtGui.QStyleOptionButton()
option.rect = QtCore.QRect(rect.x() + self._x_offset, rect.y() + self._y_offset, self._width, self._height)
option.state = QtGui.QStyle.State_Enabled | QtGui.QStyle.State_Active
if self.isChecked[logicalIndex] == 2:
option.state |= QtGui.QStyle.State_NoChange
elif self.isChecked[logicalIndex]:
option.state |= QtGui.QStyle.State_On
else:
option.state |= QtGui.QStyle.State_Off
self.style().drawControl(QtGui.QStyle.CE_CheckBox,option,painter)
def updateCheckState(self, index, state):
self.isChecked[index] = state
self.viewport().update()
def mousePressEvent(self, event):
index = self.logicalIndexAt(event.pos())
if 0 <= index < self.count():
x = self.sectionPosition(index)
if x + self._x_offset < event.pos().x() < x + self._x_offset + self._width and self._y_offset < event.pos().y() < self._y_offset + self._height:
if self.isChecked[index] == 1:
self.isChecked[index] = 0
else:
self.isChecked[index] = 1
self.clicked.emit(index, self.isChecked[index])
self.viewport().update()
else:
super(CheckBoxHeader, self).mousePressEvent(event)
else:
super(CheckBoxHeader, self).mousePressEvent(event)
if __name__=='__main__':
def updateModel(index, state):
for i in range(model.rowCount()):
item = model.item(i, index)
item.setCheckState(QtCore.Qt.Checked if state else QtCore.Qt.Unchecked)
def modelChanged():
for i in range(model.columnCount()):
checked = 0
unchecked = 0
for j in range(model.rowCount()):
if model.item(j,i).checkState() == QtCore.Qt.Checked:
checked += 1
elif model.item(j,i).checkState() == QtCore.Qt.Unchecked:
unchecked += 1
if checked and unchecked:
header.updateCheckState(i, 2)
elif checked:
header.updateCheckState(i, 1)
else:
header.updateCheckState(i, 0)
app = QtGui.QApplication(sys.argv)
tableView = QtGui.QTableView()
model = QtGui.QStandardItemModel()
model.itemChanged.connect(modelChanged)
model.setHorizontalHeaderLabels(['Title 1\nA Second Line','Title 2'])
header = CheckBoxHeader([0,1], parent = tableView)
header.clicked.connect(updateModel)
# populate the models with some items
for i in range(3):
item1 = QtGui.QStandardItem('Item %d'%i)
item1.setCheckable(True)
item2 = QtGui.QStandardItem('Another Checkbox %d'%i)
item2.setCheckable(True)
model.appendRow([item1, item2])
tableView.setModel(model)
tableView.setHorizontalHeader(header)
tableView.setSortingEnabled(True)
tableView.show()
sys.exit(app.exec_())
I had the same issue, and find a solution here, in C++. There is no easy solution, you have to create your own header.
Here's my full code with PyQt4. It seems to work with Python2 and Python3.
I also implemented the select all / select none functionality.
import sys
import signal
#import QT
from PyQt4 import QtCore,QtGui
#---------------------------------------------------------------------------------------------------------
# Custom checkbox header
#---------------------------------------------------------------------------------------------------------
#Draw a CheckBox to the left of the first column
#Emit clicked when checked/unchecked
class CheckBoxHeader(QtGui.QHeaderView):
clicked=QtCore.pyqtSignal(bool)
def __init__(self,orientation=QtCore.Qt.Horizontal,parent=None):
super(CheckBoxHeader,self).__init__(orientation,parent)
self.setResizeMode(QtGui.QHeaderView.Stretch)
self.isChecked=False
def paintSection(self,painter,rect,logicalIndex):
painter.save()
super(CheckBoxHeader,self).paintSection(painter,rect,logicalIndex)
painter.restore()
if logicalIndex==0:
option=QtGui.QStyleOptionButton()
option.rect= QtCore.QRect(3,1,20,20) #may have to be adapt
option.state=QtGui.QStyle.State_Enabled | QtGui.QStyle.State_Active
if self.isChecked:
option.state|=QtGui.QStyle.State_On
else:
option.state|=QtGui.QStyle.State_Off
self.style().drawControl(QtGui.QStyle.CE_CheckBox,option,painter)
def mousePressEvent(self,event):
if self.isChecked:
self.isChecked=False
else:
self.isChecked=True
self.clicked.emit(self.isChecked)
self.viewport().update()
#---------------------------------------------------------------------------------------------------------
# Table Model, with checkBoxed on the left
#---------------------------------------------------------------------------------------------------------
#On row in the table
class RowObject(object):
def __init__(self):
self.col0="column 0"
self.col1="column 1"
class Model(QtCore.QAbstractTableModel):
def __init__(self,parent=None):
super(Model,self).__init__(parent)
#Model= list of object
self.myList=[RowObject(),RowObject()]
#Keep track of which object are checked
self.checkList=[]
def rowCount(self,QModelIndex):
return len(self.myList)
def columnCount(self,QModelIndex):
return 2
def addOneRow(self,rowObject):
frow=len(self.myList)
self.beginInsertRows(QtCore.QModelIndex(),row,row)
self.myList.append(rowObject)
self.endInsertRows()
def data(self,index,role):
row=index.row()
col=index.column()
if role==QtCore.Qt.DisplayRole:
if col==0:
return self.myList[row].col0
if col==1:
return self.myList[row].col1
elif role==QtCore.Qt.CheckStateRole:
if col==0:
if self.myList[row] in self.checkList:
return QtCore.Qt.Checked
else:
return QtCore.Qt.Unchecked
def setData(self,index,value,role):
row=index.row()
col=index.column()
if role==QtCore.Qt.CheckStateRole and col==0:
rowObject=self.myList[row]
if rowObject in self.checkList:
self.checkList.remove(rowObject)
else:
self.checkList.append(rowObject)
index=self.index(row,col+1)
self.dataChanged.emit(index,index)
return True
def flags(self,index):
if index.column()==0:
return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsUserCheckable
return QtCore.Qt.ItemIsEnabled
def headerData(self,section,orientation,role):
if role==QtCore.Qt.DisplayRole:
if orientation==QtCore.Qt.Horizontal:
if section==0:
return "Title 1"
elif section==1:
return "Title 2"
def headerClick(self,isCheck):
self.beginResetModel()
if isCheck:
self.checkList=self.myList[:]
else:
self.checkList=[]
self.endResetModel()
if __name__=='__main__':
app=QtGui.QApplication(sys.argv)
#to be able to close with ctrl+c
signal.signal(signal.SIGINT, signal.SIG_DFL)
tableView=QtGui.QTableView()
model=Model(parent=tableView)
header=CheckBoxHeader(parent=tableView)
header.clicked.connect(model.headerClick)
tableView.setModel(model)
tableView.setHorizontalHeader(header)
tableView.show()
sys.exit(app.exec_())
NB: You could store the rows in self.checkList. In my case, I often have to delete rows in random position so it was not sufficient.
I am trying to create a QAbstractListView for use with a QComboBox which maintains a sorted list of the items it contains. I've included some sample code below that illustrates my problem. When I update the items in the list, the currentIndex of the combo box does not update to reflect the changes to the model. I've tried using the rowsAboutToBeInserted and rowsInserted signals, but I can't see any effect (maybe I'm doing it wrong?).
My actual use case is a little more complex, but the example should be enough. The items being sorted aren't just strings, and take a little more effort to sort and have a ItemDataRole different to their DisplayRole.
The itemsAdded and itemsRemoved are my own functions, which will be connected to signals from another list which I'm trying to proxy.
To trigger the problem, press the 'Insert "c"' button. The string is inserted into the list correctly, but the selection moves from 'e' to 'd' (i.e. the selection index does not change).
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
class Model(QtCore.QAbstractListModel):
def __init__(self, *args, **kwargs):
QtCore.QAbstractListModel.__init__(self, *args, **kwargs)
self.items = []
def rowCount(self, parent=QtCore.QModelIndex()):
return len(self.items)
def data(self, index, role=QtCore.Qt.DisplayRole):
if index.isValid() is True:
if role == QtCore.Qt.DisplayRole:
return QtCore.QVariant(self.items[index.row()])
elif role == QtCore.Qt.ItemDataRole:
return QtCore.QVariant(self.items[index.row()])
return QtCore.QVariant()
def itemsAdded(self, items):
# insert items into their sorted position
items = sorted(items)
row = 0
while row < len(self.items) and len(items) > 0:
if items[0] < self.items[row]:
self.items[row:row] = [items.pop(0)]
row += 1
row += 1
# add remaining items to end of list
if len(items) > 0:
self.items.extend(items)
def itemsRemoved(self, items):
# remove items from list
for item in items:
for row in range(0, len(self.items)):
if self.items[row] == item:
self.items.pop(row)
break
def main():
app = QtGui.QApplication([])
w = QtGui.QWidget()
w.resize(300,300)
layout = QtGui.QVBoxLayout()
model = Model()
model.itemsAdded(['a','b','d','e'])
combobox = QtGui.QComboBox()
combobox.setModel(model)
combobox.setCurrentIndex(3)
layout.addWidget(combobox)
def insertC(self):
model.itemsAdded('c')
button = QtGui.QPushButton('Insert "c"')
button.clicked.connect(insertC)
layout.addWidget(button)
w.setLayout(layout)
w.show()
app.exec_()
if __name__ == '__main__':
main()
A complete working example below, based on Tim's answer.
The call to setCurrentIndex isn't required. The view keeps track of this automatically when insertRows/removeRows are called correctly.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from PyQt4 import QtCore, QtGui
class Model(QtCore.QAbstractListModel):
def __init__(self, *args, **kwargs):
QtCore.QAbstractListModel.__init__(self, *args, **kwargs)
self.items = []
def rowCount(self, parent=QtCore.QModelIndex()):
return len(self.items)
def data(self, index, role=QtCore.Qt.DisplayRole):
if index.isValid() is True:
if role == QtCore.Qt.DisplayRole:
return QtCore.QVariant(self.items[index.row()])
elif role == QtCore.Qt.ItemDataRole:
return QtCore.QVariant(self.items[index.row()])
return QtCore.QVariant()
def itemsAdded(self, items):
# insert items into their sorted position
items = sorted(items)
row = 0
while row < len(self.items) and len(items) > 0:
if items[0] < self.items[row]:
self.beginInsertRows(QtCore.QModelIndex(), row, row)
self.items.insert(row, items.pop(0))
self.endInsertRows()
row += 1
row += 1
# add remaining items to end of the list
if len(items) > 0:
self.beginInsertRows(QtCore.QModelIndex(), len(self.items), len(self.items) + len(items) - 1)
self.items.extend(items)
self.endInsertRows()
def itemsRemoved(self, items):
# remove items from the list
for item in items:
for row in range(0, len(self.items)):
if self.items[row] == item:
self.beginRemoveRows(QtCore.QModelIndex(), row, row)
self.items.pop(row)
self.endRemoveRows()
break
def main():
app = QtGui.QApplication([])
w = QtGui.QWidget()
w.resize(300,200)
layout = QtGui.QVBoxLayout()
model = Model()
model.itemsAdded(['a','b','d','e'])
combobox = QtGui.QComboBox()
combobox.setModel(model)
combobox.setCurrentIndex(3)
layout.addWidget(combobox)
def insertC(self):
model.itemsAdded('c')
def removeC(self):
model.itemsRemoved('c')
buttonInsert = QtGui.QPushButton('Insert "c"')
buttonInsert.clicked.connect(insertC)
layout.addWidget(buttonInsert)
buttonRemove = QtGui.QPushButton('Remove "c"')
buttonRemove.clicked.connect(removeC)
layout.addWidget(buttonRemove)
w.setLayout(layout)
w.show()
app.exec_()
if __name__ == '__main__':
main()
I guess you need to modify the selection index yourself, i.e. something like
if row < currentIndex():
setCurrentIndex( currentIndex() + 1 );
You should however read the following passage:
Models that provide interfaces to resizable list-like data structures can provide implementations of insertRows() and removeRows(). When implementing these functions, it is important to call the appropriate functions so that all connected views are aware of any changes:
• An insertRows() implementation must call beginInsertRows() before inserting new rows into the data structure, and it must call endInsertRows() immediately afterwards.
• A removeRows() implementation must call beginRemoveRows() before the rows are removed from the data structure, and it must call endRemoveRows() immediately afterwards.