The easiest way to make a "tracking" item selection in TreeView? - c++

Question

Okay, so I have a QTreeView and a Model subclassed from QAbstractItemModel set to it. So far so good.
The data of the model gets updated every constant time interval, for example, two seconds. Let's say for simplicity the items are just short integers, and have no hierarchical structure. All items are unique.
t=0:
497
1739
18
125
19
The user selects the item 18:
t=1:
497
1739
[18]
125
19
t=2, the list of items updates and changes!
497
18
[1739]
125
For example, 1739 and 18 are now swapped, and the last 19 disappears.
Whoops! 1739 is now selected, which seems legit: the user has selected the third item, and it's still being selected even after an update.
I hope the question is now obvious: I need the selection to "track" what item exactly is selected. Using some internal id of the item itself. So if the new list contains an item with the same id as the previously selected one, it gets selected.
I could change the selection myself on update, or use insertRow and removeRow, but I don't know what exactly (1739 and 18 got swapped) has changed in the list, I just receive a new list of integers.
I've looked at QItemSelectionModel, and although the Qt documentation says
The QItemSelectionModel class keeps track of a view's selected items.
, it doesn't look like what I need. I thought it is another proxy model I need to subclass, but it's not.
Next I thought my Model is the right place to write the code that will track the selection, but I've failed again: a model is unable to retrieve the selection model of the view (view->selectionModel()), because it cannot access the view(s).
I could end up writing some signals and slots in my Model so that the code outside the Model could update the selection, plus a slot outside the model connected to the view's selectionModel updating the id of the currently selected item stored in the Model, etc, etc, but before writing such things I thought of asking if there already is some practice I don't know about.
There is so few documentation and articles explaining all these stuff, and I was unable to find an answer to the above myself.
Thank you!

Answer 1

It would be best to detect when items are added/moved/deleted from model and emit respective signals, but this would be to complex and probably you don't need such complex functionality.
Assuming that you are interested in single selection you can do that quite simply. When current selection changes simply store selected value.
When you will be notified that model has changed just find new position of items and update selection.
void onCurrentSelectionChange(const QModelIndex & index) { // slot
selectedValue = index->data(); // update field: QVariant selectedValue
}
void onModelReset() { // slot connected to signal where model reports that it was changed
QModelIndex newSelection = yourModel->findIndexOfValue(selectedValue); // you have to provide such method in your moel
emit newSelection(newSelection); // signal connected to setCurrentIndex slot of QTreeView or selection model
}
If you want handle more complex selection it will be more trouble.

Answer 2

I think you provide the answer your self. You can use an internal id that is unique for each item:
template<typename T>
class Item {
public:
Item(int id, T data);
// Access methods here.
private:
int id;
T data;
};
Then, every time you receive the timeout from your timer you can update your item selection list :
vector<int> selection;
for (int &index: treeview->selectionModel()->selectedIndexes()){
selection.push_back(model[index].id); // This assumes you implement [] operator for your model.
}
// Do modify list.
// and the using QModelSelection select again every item which id is in
// `selection`
That way you can "track" the selected items.
It is not a good idea depend on the item value, since this limit the solution to a model containing uninque values. Neither is good idea use the selectionChanged signal since it will be triggered by the user but also by you when change selections programmatically, and that would generate an infinite loop.