5d43ac0 · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

Fix insertions/removals on the qlimitproxymodel

5d43ac0Albert Astals13 years ago

plugins/Utils/qlimitproxymodelqml.cpp+90−4

compare with xenial

unifiedsplit

@@ -25,6 +25,8 @@ QLimitProxyModelQML::QLimitProxyModelQML(QObject *parent)

25 , m_limit(-1)

26 , m_sourceInserting(false)

27 , m_sourceRemoving(false)

28+ , m_dataChangedBegin(-1)

29+ , m_dataChangedEnd(-1)

28{

30{

29 connect(this, SIGNAL(modelReset()), SIGNAL(countChanged()));

31 connect(this, SIGNAL(modelReset()), SIGNAL(countChanged()));

30 connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)), SIGNAL(countChanged()));

32 connect(this, SIGNAL(rowsInserted(QModelIndex,int,int)), SIGNAL(countChanged()));

@@ -130,8 +132,45 @@ QLimitProxyModelQML::sourceRowsAboutToBeInserted(const QModelIndex &parent, int

130 beginInsertRows(mapFromSource(parent), start, end);

132 beginInsertRows(mapFromSource(parent), start, end);

131 m_sourceInserting = true;

133 m_sourceInserting = true;

132 } else if (start < m_limit) {

134 } else if (start < m_limit) {

135+ const int nSourceAddedItems = end - start + 1;

136+ const int currentCount = QIdentityProxyModel::rowCount();

137+ if (currentCount + nSourceAddedItems <= m_limit) {

138+ // After Inserting items we will be under the limit

139+ // so just proceed with the insertion normally

133− beginInsertRows(mapFromSource(parent), start, qMin(m_limit - 1, end));

140+ beginInsertRows(mapFromSource(parent), start, end);

141+ m_sourceInserting = true;

142+ } else if (currentCount >= m_limit) {

143+ // We are already over the limit so to our users we are not adding items, just

144+ // changing it's data, i.e we had something like

145+ // A B C D E

146+ // with a limit of 5

147+ // after inserting (let's say three 'F' at position 1) we will have

148+ // A F F F B

149+ // so we just need to signal a dataChanged from 1 to 4

150+ m_dataChangedBegin = start;

151+ m_dataChangedEnd = m_limit - 1;

152+ } else { // currentCount < m_limit && currentCount + nSourceAddedItems > m_limit

153+ // We have less items than the limit but after adding them we will be over

154+ // To our users this means we need to insert some items and change the

155+ // data of some others, i.e we had something like

156+ // A B C

157+ // with a limit of 5

158+ // after inserting (let's say three 'F' at position 1) we will have

159+ // A F F F B

160+ // so we need to signal an insetion from position 1 to 2, instead of from

161+ // position 1 to 3 and a after that a data changed from 3 to 4

162+ const int nItemsToInsert = m_limit - currentCount;

163+ beginInsertRows(mapFromSource(parent), start, start + nItemsToInsert - 1);

134− m_sourceInserting = true;

164+ m_sourceInserting = true;

165+ m_dataChangedBegin = start + nItemsToInsert;

166+ m_dataChangedEnd = m_limit - 1;

167+ if (m_dataChangedBegin > m_dataChangedEnd) {

168+ // Just in case we were empty and insert 6 items with a limit of 5

169+ // We don't want to signal a dataChanged from 5 to 4

170+ m_dataChangedBegin = -1;

171+ m_dataChangedEnd = -1;

172+ }

173+ }

135 }

174 }

136}

175}

137

176

@@ -142,8 +181,45 @@ QLimitProxyModelQML::sourceRowsAboutToBeRemoved(const QModelIndex &parent, int s

142 beginRemoveRows(mapFromSource(parent), start, end);

181 beginRemoveRows(mapFromSource(parent), start, end);

143 m_sourceRemoving = true;

182 m_sourceRemoving = true;

144 } else if (start < m_limit) {

183 } else if (start < m_limit) {

184+ const int nSourceRemovedItems = end - start + 1;

185+ const int currentCount = QIdentityProxyModel::rowCount();

186+ if (currentCount <= m_limit) {

187+ // We are already under the limit so

188+ // so just proceed with the removal normally

145− beginRemoveRows(mapFromSource(parent), start, qMin(m_limit - 1, end));

189+ beginRemoveRows(mapFromSource(parent), start, end);

190+ m_sourceRemoving = true;

191+ } else if (currentCount - nSourceRemovedItems >= m_limit) {

192+ // Even after removing items we will be at or over the limit

193+ // So to our users we are not removing anything, just changing the data

194+ // i.e. we had a internal model with

195+ // A B C D E F G H

196+ // and a limit of 5, our users just see

197+ // A B C D E

198+ // so if we remove 3 items starting at 1 we have to expose

199+ // A E F G H

200+ // that is, a dataChanged from 1 to 4

201+ m_dataChangedBegin = start;

202+ m_dataChangedEnd = m_limit - 1;

203+ } else { // currentCount > m_limit && currentCount - nSourceRemovedItems < m_limit

204+ // We have more items than the limit but after removing we will be below it

205+ // So to our users we both removing and changing the data

206+ // i.e. we had a internal model with

207+ // A B C D E F G

208+ // and a limit of 5, our users just see

209+ // A B C D E

210+ // so if we remove items from 1 to 3 we have to expose

211+ // A E F G

212+ // that is, a remove from 4 to 4 and a dataChanged from 1 to 3

213+ const int nItemsToRemove = m_limit - (currentCount - nSourceRemovedItems);

214+ beginRemoveRows(mapFromSource(parent), m_limit - nItemsToRemove, m_limit - 1);

146− m_sourceRemoving = true;

215+ m_sourceRemoving = true;

216+ m_dataChangedBegin = start;

217+ m_dataChangedEnd = m_limit - nItemsToRemove - 1;

218+ if (m_dataChangedBegin > m_dataChangedEnd) {

219+ m_dataChangedBegin = -1;

220+ m_dataChangedEnd = -1;

221+ }

222+ }

147 }

223 }

148}

224}

149

225

@@ -154,6 +230,11 @@ QLimitProxyModelQML::sourceRowsInserted(const QModelIndex & /*parent*/, int /*st

154 endInsertRows();

230 endInsertRows();

155 m_sourceInserting = false;

231 m_sourceInserting = false;

156 }

232 }

233+ if (m_dataChangedBegin != -1 && m_dataChangedEnd != -1) {

234+ dataChanged(index(m_dataChangedBegin, 0), index(m_dataChangedEnd, 0));

235+ m_dataChangedBegin = -1;

236+ m_dataChangedEnd = -1;

237+ }

157}

238}

158

239

159void

240void

@@ -163,4 +244,9 @@ QLimitProxyModelQML::sourceRowsRemoved(const QModelIndex & /*parent*/, int /*sta

163 endRemoveRows();

244 endRemoveRows();

164 m_sourceRemoving = false;

245 m_sourceRemoving = false;

165 }

246 }

247+ if (m_dataChangedBegin != -1 && m_dataChangedEnd != -1) {

248+ dataChanged(index(m_dataChangedBegin, 0), index(m_dataChangedEnd, 0));

249+ m_dataChangedBegin = -1;

250+ m_dataChangedEnd = -1;

251+ }

166}

252}

plugins/Utils/qlimitproxymodelqml.h+2

@@ -55,6 +55,8 @@ private:

55 int m_limit;

56 bool m_sourceInserting;

57 bool m_sourceRemoving;

58+ int m_dataChangedBegin;

59+ int m_dataChangedEnd;

58};

60};

60#endif // QLIMITPROXYMODELQML_H

62#endif // QLIMITPROXYMODELQML_H

tests/plugins/Utils/qlimitproxymodeltest.cpp+133−8

@@ -58,10 +58,17 @@ public:

58 m_roles = roles;

59 }

61+ void clear()

62+ {

63+ beginRemoveRows(QModelIndex(), 0, m_list.count() - 1);

64+ m_list.clear();

65+ endRemoveRows();

66+ }

67+

61 bool insertRows(int row, int count, const QModelIndex &parent=QModelIndex()) {

68 bool insertRows(int row, int count, const QModelIndex &parent=QModelIndex()) {

62 beginInsertRows(parent, row, row+count-1);

69 beginInsertRows(parent, row, row+count-1);

63 for (int i=0; i<count; i++) {

70 for (int i=0; i<count; i++) {

64− m_list.insert(i+row, "test"+i);

71+ m_list.insert(i+row, QString::number(i));

65 }

72 }

66 endInsertRows();

73 endInsertRows();

67 return true;

74 return true;

@@ -88,6 +95,60 @@ private:

88 QHash<int, QByteArray> m_roles;

95 QHash<int, QByteArray> m_roles;

89};

96};

98+class MirrorModel : public QObject

99+{

100+ Q_OBJECT

101+

102+public:

103+ MirrorModel(QAbstractItemModel *model) : m_mirror(model)

104+ {

105+ connect(model, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(rowsInserted(QModelIndex,int,int)));

106+ connect(model, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(rowsRemoved(QModelIndex,int,int)));

107+ connect(model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(dataChanged(QModelIndex,QModelIndex)));

108+ }

109+

110+ void check()

111+ {

112+ QCOMPARE(m_list.count(), m_mirror->rowCount());

113+ for (int i = 0; i < m_list.count(); ++i) {

114+ QCOMPARE(m_list[i], m_mirror->data(m_mirror->index(i, 0)).toString());

115+ }

116+ }

117+

118+private Q_SLOTS:

119+ void rowsInserted(const QModelIndex &parent, int start, int end)

120+ {

121+ QVERIFY(!parent.isValid());

122+ for (int i = start; i <= end; ++i) {

123+ m_list.insert(i, m_mirror->data(m_mirror->index(i, 0)).toString());

124+ }

125+ }

126+

127+ void rowsRemoved(const QModelIndex &parent, int start, int end)

128+ {

129+ QVERIFY(!parent.isValid());

130+ for (int i = end; i >= start; --i) {

131+ m_list.removeAt(i);

132+ }

133+ }

134+

135+ void dataChanged(const QModelIndex &topLeft, const QModelIndex &bottomRight)

136+ {

137+ QVERIFY(topLeft.isValid());

138+ QVERIFY(bottomRight.isValid());

139+ QVERIFY(!topLeft.parent().isValid());

140+ QVERIFY(!bottomRight.parent().isValid());

141+ for (int i = topLeft.row(); i <= bottomRight.row(); ++i) {

142+ m_list[i] = m_mirror->data(m_mirror->index(i, 0)).toString();

143+ }

144+ }

145+

146+

147+private:

148+ QStringList m_list;

149+ QAbstractItemModel *m_mirror;

150+};

151+

91class QLimitProxyModelTest : public QObject

152class QLimitProxyModelTest : public QObject

92{

153{

93 Q_OBJECT

154 Q_OBJECT

@@ -401,15 +462,10 @@ private Q_SLOTS:

401 QCOMPARE(spyOnCountChanged.count(), 0);

462 QCOMPARE(spyOnCountChanged.count(), 0);

402

463

403 model.removeRows(2, 2);

464 model.removeRows(2, 2);

404− QCOMPARE(spyOnRowsRemoved.count(), 1);

465+ QCOMPARE(spyOnRowsRemoved.count(), 0);

405 QCOMPARE(spyOnRowsInserted.count(), 0);

466 QCOMPARE(spyOnRowsInserted.count(), 0);

406− QCOMPARE(spyOnCountChanged.count(), 1);

467+ QCOMPARE(spyOnCountChanged.count(), 0);

407− arguments = spyOnRowsRemoved.takeFirst();

408− QCOMPARE(arguments.at(1).toInt(), 2);

409− QCOMPARE(arguments.at(2).toInt(), 3);

410 QCOMPARE(proxy.rowCount(), 7);

468 QCOMPARE(proxy.rowCount(), 7);

411− spyOnRowsInserted.clear();

412− spyOnCountChanged.clear();

413

469

414 model.removeRows(0, 7);

470 model.removeRows(0, 7);

415 QCOMPARE(spyOnRowsRemoved.count(), 1);

471 QCOMPARE(spyOnRowsRemoved.count(), 1);

@@ -479,6 +535,75 @@ private Q_SLOTS:

479 QCOMPARE(proxy.rowCount(), 5);

535 QCOMPARE(proxy.rowCount(), 5);

480 QCOMPARE(spyOnCountChanged.count(), 1);

536 QCOMPARE(spyOnCountChanged.count(), 1);

481 }

537 }

538+

539+ void testMirrorModel() {

540+ QLimitProxyModelQML proxy;

541+ MockListModel model;

542+ MirrorModel mirror(&proxy);

543+

544+ proxy.setModel(&model);

545+ proxy.setLimit(5);

546+

547+ // Checks what happens when the model already has

548+ // more items than the limit and we add stuff to

549+ // the front

550+ model.insertRows(0, 7);

551+ mirror.check();

552+ model.insertRows(1, 3);

553+ mirror.check();

554+ model.clear();

555+ mirror.check();

556+

557+ // Checks what happens when the model does

558+ // not has more items than limit but adding

559+ // stuff to its front makes it go past the limit

560+ model.insertRows(0, 3);

561+ mirror.check();

562+ model.insertRows(1, 3);

563+ mirror.check();

564+ model.clear();

565+ mirror.check();

566+

567+ // Checks what happens when the model does

568+ // not has more items than limit and adding

569+ // stuff to its front makes it not go past the limit

570+ model.insertRows(0, 1);

571+ mirror.check();

572+ model.insertRows(1, 3);

573+ mirror.check();

574+ model.clear();

575+ mirror.check();

576+

577+ // Checks what happens when the model already has

578+ // more items than the limit and we remove stuff from

579+ // the front but it still has more than the limit

580+ model.insertRows(0, 10);

581+ mirror.check();

582+ model.removeRows(1, 3);

583+ mirror.check();

584+ model.clear();

585+ mirror.check();

586+

587+ // Checks what happens when the model already has

588+ // more items than the limit and we remove stuff from

589+ // the front but it has less than the limit

590+ model.insertRows(0, 6);

591+ mirror.check();

592+ model.removeRows(1, 3);

593+ mirror.check();

594+ model.clear();

595+ mirror.check();

596+

597+ // Checks what happens when the model has

598+ // less items than the limit and we remove stuff from

599+ // the front

600+ model.insertRows(0, 4);

601+ mirror.check();

602+ model.removeRows(1, 3);

603+ mirror.check();

604+ model.clear();

605+ mirror.check();

606+ }

482};

607};

483

608

484QTEST_GUILESS_MAIN(QLimitProxyModelTest)

609QTEST_GUILESS_MAIN(QLimitProxyModelTest)