d5f8aef · unity8 · git.iko.soy

git.iko.soy/unity8

on xenial help sign in

Fix insertions/removals on the qlimitproxymodel

d5f8aefAlbert Astals13 years ago

plugins/Utils/qlimitproxymodelqml.cpp+50−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,25 @@ 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) {

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

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

139+ m_sourceInserting = true;

140+ } else if (currentCount < m_limit) {

141+ const int nItemsToInsert = m_limit - currentCount;

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

134− m_sourceInserting = true;

143+ m_sourceInserting = true;

144+ m_dataChangedBegin = start + nItemsToInsert;

145+ m_dataChangedEnd = m_limit - 1;

146+ if (m_dataChangedBegin > m_dataChangedEnd) {

147+ m_dataChangedBegin = -1;

148+ m_dataChangedEnd = -1;

149+ }

150+ } else {

151+ m_dataChangedBegin = start;

152+ m_dataChangedEnd = m_limit - 1;

153+ }

135 }

154 }

136}

155}

137

156

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

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

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

143 m_sourceRemoving = true;

162 m_sourceRemoving = true;

144 } else if (start < m_limit) {

163 } else if (start < m_limit) {

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

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

166+ if (currentCount <= m_limit) {

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

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

146− m_sourceRemoving = true;

168+ m_sourceRemoving = true;

169+ } else if (currentCount - nSourceRemovedItems < m_limit) {

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

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

172+ m_sourceRemoving = true;

173+ m_dataChangedBegin = start;

174+ m_dataChangedEnd = m_limit - nItemsToRemove - 1;

175+ if (m_dataChangedBegin > m_dataChangedEnd) {

176+ m_dataChangedBegin = -1;

177+ m_dataChangedEnd = -1;

178+ }

179+ } else {

180+ m_dataChangedBegin = start;

181+ m_dataChangedEnd = m_limit - 1;

182+ }

147 }

183 }

148}

184}

149

185

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

154 endInsertRows();

190 endInsertRows();

155 m_sourceInserting = false;

191 m_sourceInserting = false;

156 }

192 }

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

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

195+ m_dataChangedBegin = -1;

196+ m_dataChangedEnd = -1;

197+ }

157}

198}

158

199

159void

200void

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

163 endRemoveRows();

204 endRemoveRows();

164 m_sourceRemoving = false;

205 m_sourceRemoving = false;

165 }

206 }

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

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

209+ m_dataChangedBegin = -1;

210+ m_dataChangedEnd = -1;

211+ }

166}

212}

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)