tests/plugins/Dash/organicgridtest.cpp · unity8

git.iko.soy/unity8

on 0cfbca3 help sign in

unity8/tests/plugins/Dash/organicgridtest.cpp

535 lines 22 kB history raw

1/*

3 *

4 * This program is free software; you can redistribute it and/or modify

5 * it under the terms of the GNU General Public License as published by

6 * the Free Software Foundation; version 3.

7 *

8 * This program is distributed in the hope that it will be useful,

9 * but WITHOUT ANY WARRANTY; without even the implied warranty of

10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

11 * GNU General Public License for more details.

12 *

13 * You should have received a copy of the GNU General Public License

14 * along with this program. If not, see <http://www.gnu.org/licenses/>.

15 */

17#include <QQuickView>

18#include <QtTestGui>

19#include <QDebug>

20#include <QGuiApplication>

21#include <QQuickView>

22#include <QtQml/qqml.h>

23#include <QStringListModel>

24#include <QQmlContext>

25#include <QQmlEngine>

26#pragma GCC diagnostic push

27#pragma GCC diagnostic ignored "-pedantic"

28#include <private/qquickitem_p.h>

29#pragma GCC diagnostic pop

31#include "organicgrid.h"

33#include <paths.h>

35class DummyModel : public QAbstractListModel {

36public:

37 DummyModel() : m_count(0) {}

39 int rowCount(const QModelIndex & /*parent*/) const override

40 {

41 return m_count;

42 }

44 QVariant data(const QModelIndex & /*index*/, int /*role*/) const override

45 {

46 return QVariant();

47 }

49 void setCount(int count)

50 {

51 beginResetModel();

52 m_count = count;

53 endResetModel();

54 }

56 void addItem()

57 {

58 beginInsertRows(QModelIndex(), m_count, m_count);

59 m_count++;

60 endInsertRows();

61 }

63 void removeLast()

64 {

65 beginRemoveRows(QModelIndex(), m_count - 1, m_count - 1);

66 m_count--;

67 endRemoveRows();

68 }

70private:

71 int m_count;

72};

74class OrganicGridTest : public QObject

75{

76 Q_OBJECT

78private:

79 void verifyItem(const QQuickItem *item, int modelIndex, qreal x, qreal y, bool visible)

80 {

81 QTRY_COMPARE(item->x(), x);

82 QTRY_COMPARE(item->y(), y);

83 QTRY_COMPARE(QQuickItemPrivate::get(item)->culled, !visible);

84 const int inModuleIndex = modelIndex % 6;

85 if (inModuleIndex == 0 || inModuleIndex == 1 || inModuleIndex == 3 || inModuleIndex == 5) {

86 QTRY_COMPARE(item->height(), grid->smallDelegateSize().height());

87 QTRY_COMPARE(item->width(), grid->smallDelegateSize().width());

88 } else {

89 QTRY_COMPARE(item->height(), grid->bigDelegateSize().height());

90 QTRY_COMPARE(item->width(), grid->bigDelegateSize().width());

91 }

92 }

94 void checkInitialPositions()

95 {

96 QTRY_COMPARE(grid->m_visibleItems.count(), 18);

97 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

98 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

99 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

100 verifyItem(grid->m_visibleItems[ 1], 1, 100, 0, true);

101 verifyItem(grid->m_visibleItems[ 2], 2, 0, 100, true);

102 verifyItem(grid->m_visibleItems[ 3], 3, 190, 190, true);

103 verifyItem(grid->m_visibleItems[ 4], 4, 200, 0, true);

104 verifyItem(grid->m_visibleItems[ 5], 5, 290, 190, true);

105 verifyItem(grid->m_visibleItems[ 6], 6, 0, 290, true);

106 verifyItem(grid->m_visibleItems[ 7], 7, 100, 290, true);

107 verifyItem(grid->m_visibleItems[ 8], 8, 0, 390, true);

108 verifyItem(grid->m_visibleItems[ 9], 9, 190, 480, false);

109 verifyItem(grid->m_visibleItems[10], 10, 200, 290, true);

110 verifyItem(grid->m_visibleItems[11], 11, 290, 480, false);

111 verifyItem(grid->m_visibleItems[12], 12, 0, 580, false);

112 verifyItem(grid->m_visibleItems[13], 13, 100, 580, false);

113 verifyItem(grid->m_visibleItems[14], 14, 0, 680, false);

114 verifyItem(grid->m_visibleItems[15], 15, 190, 770, false);

115 verifyItem(grid->m_visibleItems[16], 16, 200, 580, false);

116 verifyItem(grid->m_visibleItems[17], 17, 290, 770, false);

117 checkImplicitHeight(1150);

118 }

119

120 void checkImplicitHeight(qreal implicitHeight)

121 {

122 QTRY_COMPARE(grid->m_implicitHeightDirty, false);

123 QCOMPARE(grid->implicitHeight(), implicitHeight);

124 }

125

126private Q_SLOTS:

127 void init()

128 {

129 view = new QQuickView();

130 view->setResizeMode(QQuickView::SizeRootObjectToView);

131

132 model = new DummyModel();

133 model->setCount(21);

134

135 view->setSource(QUrl::fromLocalFile(testDataDir() + "/" TEST_DIR "/organicgridtest.qml"));

136

137 view->show();

138 QTest::qWaitForWindowExposed(view);

139 view->resize(470, 400);

140

141 grid = dynamic_cast<OrganicGrid*>(view->rootObject()->findChild<QObject*>("grid"));

142 grid->setModel(model);

143 QTRY_COMPARE(grid->width(), 470.);

144

145 checkInitialPositions();

146 }

147

148 void cleanup()

149 {

150 delete view;

151 delete model;

152 }

153

154 void testInitialPosition()

155 {

156 }

157

158 void testWidthResize()

159 {

160 view->resize(770, 400);

161 QTRY_COMPARE(grid->width(), 770.);

162

163 QTRY_COMPARE(grid->m_visibleItems.count(), 21);

164 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

165 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 2);

166 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

167 verifyItem(grid->m_visibleItems[ 1], 1, 100, 0, true);

168 verifyItem(grid->m_visibleItems[ 2], 2, 0, 100, true);

169 verifyItem(grid->m_visibleItems[ 3], 3, 190, 190, true);

170 verifyItem(grid->m_visibleItems[ 4], 4, 200, 0, true);

171 verifyItem(grid->m_visibleItems[ 5], 5, 290, 190, true);

172

173 verifyItem(grid->m_visibleItems[ 6], 6, 390, 0, true);

174 verifyItem(grid->m_visibleItems[ 7], 7, 490, 0, true);

175 verifyItem(grid->m_visibleItems[ 8], 8, 390, 100, true);

176 verifyItem(grid->m_visibleItems[ 9], 9, 580, 190, true);

177 verifyItem(grid->m_visibleItems[10], 10, 590, 0, true);

178 verifyItem(grid->m_visibleItems[11], 11, 680, 190, true);

179

180 verifyItem(grid->m_visibleItems[12], 12, 0, 290, true);

181 verifyItem(grid->m_visibleItems[13], 13, 100, 290, true);

182 verifyItem(grid->m_visibleItems[14], 14, 0, 390, true);

183 verifyItem(grid->m_visibleItems[15], 15, 190, 480, false);

184 verifyItem(grid->m_visibleItems[16], 16, 200, 290, true);

185 verifyItem(grid->m_visibleItems[17], 17, 290, 480, false);

186

187 verifyItem(grid->m_visibleItems[18], 18, 390, 290, true);

188 verifyItem(grid->m_visibleItems[19], 19, 490, 290, true);

189 verifyItem(grid->m_visibleItems[20], 20, 390, 390, true);

190

191 checkImplicitHeight(570);

192

193 view->resize(769, 400);

194

195 // This is exactly the same block as the first again

196 checkInitialPositions();

197 }

198

199 void testColumnSpacing()

200 {

201 grid->setColumnSpacing(11);

202

203 QTRY_COMPARE(grid->m_needsRelayout, false);

204 QTRY_COMPARE(grid->m_visibleItems.count(), 18);

205 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

206 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

207 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

208 verifyItem(grid->m_visibleItems[ 1], 1, 101, 0, true);

209 verifyItem(grid->m_visibleItems[ 2], 2, 0, 100, true);

210 verifyItem(grid->m_visibleItems[ 3], 3, 191, 190, true);

211 verifyItem(grid->m_visibleItems[ 4], 4, 202, 0, true);

212 verifyItem(grid->m_visibleItems[ 5], 5, 292, 190, true);

213 verifyItem(grid->m_visibleItems[ 6], 6, 0, 290, true);

214 verifyItem(grid->m_visibleItems[ 7], 7, 101, 290, true);

215 verifyItem(grid->m_visibleItems[ 8], 8, 0, 390, true);

216 verifyItem(grid->m_visibleItems[ 9], 9, 191, 480, false);

217 verifyItem(grid->m_visibleItems[10], 10, 202, 290, true);

218 verifyItem(grid->m_visibleItems[11], 11, 292, 480, false);

219 verifyItem(grid->m_visibleItems[12], 12, 0, 580, false);

220 verifyItem(grid->m_visibleItems[13], 13, 101, 580, false);

221 verifyItem(grid->m_visibleItems[14], 14, 0, 680, false);

222 verifyItem(grid->m_visibleItems[15], 15, 191, 770, false);

223 verifyItem(grid->m_visibleItems[16], 16, 202, 580, false);

224 verifyItem(grid->m_visibleItems[17], 17, 292, 770, false);

225 checkImplicitHeight(1150);

226

227 grid->setColumnSpacing(10);

228 QTRY_COMPARE(grid->m_needsRelayout, false);

229

230 // This is exactly the same block as the first again

231 checkInitialPositions();

232 }

233

234 void testRowSpacing()

235 {

236 grid->setRowSpacing(11);

237

238 QTRY_COMPARE(grid->m_needsRelayout, false);

239 QTRY_COMPARE(grid->m_visibleItems.count(), 18);

240 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

241 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

242 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

243 verifyItem(grid->m_visibleItems[ 1], 1, 100, 0, true);

244 verifyItem(grid->m_visibleItems[ 2], 2, 0, 101, true);

245 verifyItem(grid->m_visibleItems[ 3], 3, 190, 191, true);

246 verifyItem(grid->m_visibleItems[ 4], 4, 200, 0, true);

247 verifyItem(grid->m_visibleItems[ 5], 5, 290, 191, true);

248 verifyItem(grid->m_visibleItems[ 6], 6, 0, 292, true);

249 verifyItem(grid->m_visibleItems[ 7], 7, 100, 292, true);

250 verifyItem(grid->m_visibleItems[ 8], 8, 0, 393, true);

251 verifyItem(grid->m_visibleItems[ 9], 9, 190, 483, false);

252 verifyItem(grid->m_visibleItems[10], 10, 200, 292, true);

253 verifyItem(grid->m_visibleItems[11], 11, 290, 483, false);

254 verifyItem(grid->m_visibleItems[12], 12, 0, 584, false);

255 verifyItem(grid->m_visibleItems[13], 13, 100, 584, false);

256 verifyItem(grid->m_visibleItems[14], 14, 0, 685, false);

257 verifyItem(grid->m_visibleItems[15], 15, 190, 775, false);

258 verifyItem(grid->m_visibleItems[16], 16, 200, 584, false);

259 verifyItem(grid->m_visibleItems[17], 17, 290, 775, false);

260 checkImplicitHeight(1157);

261

262 grid->setRowSpacing(10);

263 QTRY_COMPARE(grid->m_needsRelayout, false);

264

265 // This is exactly the same block as the first again

266 checkInitialPositions();

267 }

268

269 void testDelegateSizeChange()

270 {

271 grid->setSmallDelegateSize(QSizeF(30, 30));

272 grid->setBigDelegateSize(QSizeF(50, 50));

273 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

274 QTRY_COMPARE(grid->m_visibleItems.count(), 21);

275 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

276 verifyItem(grid->m_visibleItems[ 1], 1, 40, 0, true);

277 verifyItem(grid->m_visibleItems[ 2], 2, 0, 40, true);

278 verifyItem(grid->m_visibleItems[ 3], 3, 60, 60, true);

279 verifyItem(grid->m_visibleItems[ 4], 4, 80, 0, true);

280 verifyItem(grid->m_visibleItems[ 5], 5, 100, 60, true);

281

282 verifyItem(grid->m_visibleItems[ 6], 6, 140, 0, true);

283 verifyItem(grid->m_visibleItems[ 7], 7, 180, 0, true);

284 verifyItem(grid->m_visibleItems[ 8], 8, 140, 40, true);

285 verifyItem(grid->m_visibleItems[ 9], 9, 200, 60, true);

286 verifyItem(grid->m_visibleItems[10], 10, 220, 0, true);

287 verifyItem(grid->m_visibleItems[11], 11, 240, 60, true);

288

289 verifyItem(grid->m_visibleItems[12], 12, 280, 0, true);

290 verifyItem(grid->m_visibleItems[13], 13, 320, 0, true);

291 verifyItem(grid->m_visibleItems[14], 14, 280, 40, true);

292 verifyItem(grid->m_visibleItems[15], 15, 340, 60, true);

293 verifyItem(grid->m_visibleItems[16], 16, 360, 0, true);

294 verifyItem(grid->m_visibleItems[17], 17, 380, 60, true);

295

296 verifyItem(grid->m_visibleItems[18], 18, 0, 100, true);

297 verifyItem(grid->m_visibleItems[19], 19, 40, 100, true);

298 verifyItem(grid->m_visibleItems[20], 20, 0, 140, true);

299 checkImplicitHeight(190);

300

301 grid->setSmallDelegateSize(QSizeF(90, 90));

302 grid->setBigDelegateSize(QSizeF(180, 180));

303

304 // This is exactly the same block as the first again

305 checkInitialPositions();

306 }

307

308 void testChangeModel()

309 {

310 DummyModel *model2 = new DummyModel();

311 model2->setCount(6);

312 grid->setModel(model2);

313 delete model;

314 model = model2;

315

316 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

317 QTRY_COMPARE(grid->m_visibleItems.count(), 6);

318 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

319 verifyItem(grid->m_visibleItems[ 1], 1, 100, 0, true);

320 verifyItem(grid->m_visibleItems[ 2], 2, 0, 100, true);

321 verifyItem(grid->m_visibleItems[ 3], 3, 190, 190, true);

322 verifyItem(grid->m_visibleItems[ 4], 4, 200, 0, true);

323 verifyItem(grid->m_visibleItems[ 5], 5, 290, 190, true);

324 checkImplicitHeight(280);

325 }

326

327 void testModelReset()

328 {

329 model->setCount(6);

330

331 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

332 QTRY_COMPARE(grid->m_visibleItems.count(), 6);

333 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

334 verifyItem(grid->m_visibleItems[ 1], 1, 100, 0, true);

335 verifyItem(grid->m_visibleItems[ 2], 2, 0, 100, true);

336 verifyItem(grid->m_visibleItems[ 3], 3, 190, 190, true);

337 verifyItem(grid->m_visibleItems[ 4], 4, 200, 0, true);

338 verifyItem(grid->m_visibleItems[ 5], 5, 290, 190, true);

339 checkImplicitHeight(280);

340 }

341

342 void testModelRemoveLastNonVisible()

343 {

344 model->removeLast();

345

346 // This is the same than checkInitialPositions but

347 // with a different implicitHeight since there's an item less

348 // in the model

349 QTRY_COMPARE(grid->m_visibleItems.count(), 18);

350 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

351 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

352 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

353 verifyItem(grid->m_visibleItems[ 1], 1, 100, 0, true);

354 verifyItem(grid->m_visibleItems[ 2], 2, 0, 100, true);

355 verifyItem(grid->m_visibleItems[ 3], 3, 190, 190, true);

356 verifyItem(grid->m_visibleItems[ 4], 4, 200, 0, true);

357 verifyItem(grid->m_visibleItems[ 5], 5, 290, 190, true);

358 verifyItem(grid->m_visibleItems[ 6], 6, 0, 290, true);

359 verifyItem(grid->m_visibleItems[ 7], 7, 100, 290, true);

360 verifyItem(grid->m_visibleItems[ 8], 8, 0, 390, true);

361 verifyItem(grid->m_visibleItems[ 9], 9, 190, 480, false);

362 verifyItem(grid->m_visibleItems[10], 10, 200, 290, true);

363 verifyItem(grid->m_visibleItems[11], 11, 290, 480, false);

364 verifyItem(grid->m_visibleItems[12], 12, 0, 580, false);

365 verifyItem(grid->m_visibleItems[13], 13, 100, 580, false);

366 verifyItem(grid->m_visibleItems[14], 14, 0, 680, false);

367 verifyItem(grid->m_visibleItems[15], 15, 190, 770, false);

368 verifyItem(grid->m_visibleItems[16], 16, 200, 580, false);

369 verifyItem(grid->m_visibleItems[17], 17, 290, 770, false);

370 checkImplicitHeight(960);

371

372 model->removeLast();

373

374 // Removing this one didn't cause any change since it only

375 // was the second item of a non visible 6-module

376 QTRY_COMPARE(grid->m_visibleItems.count(), 18);

377 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

378 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

379 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

380 verifyItem(grid->m_visibleItems[ 1], 1, 100, 0, true);

381 verifyItem(grid->m_visibleItems[ 2], 2, 0, 100, true);

382 verifyItem(grid->m_visibleItems[ 3], 3, 190, 190, true);

383 verifyItem(grid->m_visibleItems[ 4], 4, 200, 0, true);

384 verifyItem(grid->m_visibleItems[ 5], 5, 290, 190, true);

385 verifyItem(grid->m_visibleItems[ 6], 6, 0, 290, true);

386 verifyItem(grid->m_visibleItems[ 7], 7, 100, 290, true);

387 verifyItem(grid->m_visibleItems[ 8], 8, 0, 390, true);

388 verifyItem(grid->m_visibleItems[ 9], 9, 190, 480, false);

389 verifyItem(grid->m_visibleItems[10], 10, 200, 290, true);

390 verifyItem(grid->m_visibleItems[11], 11, 290, 480, false);

391 verifyItem(grid->m_visibleItems[12], 12, 0, 580, false);

392 verifyItem(grid->m_visibleItems[13], 13, 100, 580, false);

393 verifyItem(grid->m_visibleItems[14], 14, 0, 680, false);

394 verifyItem(grid->m_visibleItems[15], 15, 190, 770, false);

395 verifyItem(grid->m_visibleItems[16], 16, 200, 580, false);

396 verifyItem(grid->m_visibleItems[17], 17, 290, 770, false);

397 checkImplicitHeight(960);

398

399 model->removeLast();

400

401 // Removing this one removes the first of a 6-module so

402 // it does change height again

403 QTRY_COMPARE(grid->m_visibleItems.count(), 18);

404 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

405 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

406 verifyItem(grid->m_visibleItems[ 0], 0, 0, 0, true);

407 verifyItem(grid->m_visibleItems[ 1], 1, 100, 0, true);

408 verifyItem(grid->m_visibleItems[ 2], 2, 0, 100, true);

409 verifyItem(grid->m_visibleItems[ 3], 3, 190, 190, true);

410 verifyItem(grid->m_visibleItems[ 4], 4, 200, 0, true);

411 verifyItem(grid->m_visibleItems[ 5], 5, 290, 190, true);

412 verifyItem(grid->m_visibleItems[ 6], 6, 0, 290, true);

413 verifyItem(grid->m_visibleItems[ 7], 7, 100, 290, true);

414 verifyItem(grid->m_visibleItems[ 8], 8, 0, 390, true);

415 verifyItem(grid->m_visibleItems[ 9], 9, 190, 480, false);

416 verifyItem(grid->m_visibleItems[10], 10, 200, 290, true);

417 verifyItem(grid->m_visibleItems[11], 11, 290, 480, false);

418 verifyItem(grid->m_visibleItems[12], 12, 0, 580, false);

419 verifyItem(grid->m_visibleItems[13], 13, 100, 580, false);

420 verifyItem(grid->m_visibleItems[14], 14, 0, 680, false);

421 verifyItem(grid->m_visibleItems[15], 15, 190, 770, false);

422 verifyItem(grid->m_visibleItems[16], 16, 200, 580, false);

423 verifyItem(grid->m_visibleItems[17], 17, 290, 770, false);

424 checkImplicitHeight(860);

425

426 }

427

428 void testModelAppendRemoveLast()

429 {

430 DummyModel *model2 = new DummyModel();

431 model2->setCount(6);

432 grid->setModel(model2);

433 delete model;

434 model = model2;

435

436 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

437 QTRY_COMPARE(grid->m_visibleItems.count(), 6);

438 verifyItem(grid->m_visibleItems[0], 0, 0, 0, true);

439 verifyItem(grid->m_visibleItems[1], 1, 100, 0, true);

440 verifyItem(grid->m_visibleItems[2], 2, 0, 100, true);

441 verifyItem(grid->m_visibleItems[3], 3, 190, 190, true);

442 verifyItem(grid->m_visibleItems[4], 4, 200, 0, true);

443 verifyItem(grid->m_visibleItems[5], 5, 290, 190, true);

444 checkImplicitHeight(280);

445

446 model2->addItem();

447

448 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

449 QTRY_COMPARE(grid->m_visibleItems.count(), 7);

450 verifyItem(grid->m_visibleItems[0], 0, 0, 0, true);

451 verifyItem(grid->m_visibleItems[1], 1, 100, 0, true);

452 verifyItem(grid->m_visibleItems[2], 2, 0, 100, true);

453 verifyItem(grid->m_visibleItems[3], 3, 190, 190, true);

454 verifyItem(grid->m_visibleItems[4], 4, 200, 0, true);

455 verifyItem(grid->m_visibleItems[5], 5, 290, 190, true);

456 verifyItem(grid->m_visibleItems[6], 6, 0, 290, true);

457 checkImplicitHeight(380);

458

459 model2->addItem();

460 model2->addItem();

461

462 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

463 QTRY_COMPARE(grid->m_visibleItems.count(), 9);

464 verifyItem(grid->m_visibleItems[0], 0, 0, 0, true);

465 verifyItem(grid->m_visibleItems[1], 1, 100, 0, true);

466 verifyItem(grid->m_visibleItems[2], 2, 0, 100, true);

467 verifyItem(grid->m_visibleItems[3], 3, 190, 190, true);

468 verifyItem(grid->m_visibleItems[4], 4, 200, 0, true);

469 verifyItem(grid->m_visibleItems[5], 5, 290, 190, true);

470 verifyItem(grid->m_visibleItems[6], 6, 0, 290, true);

471 verifyItem(grid->m_visibleItems[7], 7, 100, 290, true);

472 verifyItem(grid->m_visibleItems[8], 8, 0, 390, true);

473 checkImplicitHeight(570);

474

475 model2->removeLast();

476

477 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

478 QTRY_COMPARE(grid->m_visibleItems.count(), 8);

479 verifyItem(grid->m_visibleItems[0], 0, 0, 0, true);

480 verifyItem(grid->m_visibleItems[1], 1, 100, 0, true);

481 verifyItem(grid->m_visibleItems[2], 2, 0, 100, true);

482 verifyItem(grid->m_visibleItems[3], 3, 190, 190, true);

483 verifyItem(grid->m_visibleItems[4], 4, 200, 0, true);

484 verifyItem(grid->m_visibleItems[5], 5, 290, 190, true);

485 verifyItem(grid->m_visibleItems[6], 6, 0, 290, true);

486 verifyItem(grid->m_visibleItems[7], 7, 100, 290, true);

487 checkImplicitHeight(380);

488 }

489

490 void testDelegateCreationRanges()

491 {

492 grid->setSmallDelegateSize(QSizeF(30, 30));

493 grid->setBigDelegateSize(QSizeF(50, 50));

494 model->setCount(400);

495 checkImplicitHeight(2290);

496

497 view->resize(470, 700);

498 QTRY_COMPARE(grid->height(), 700.);

499 checkImplicitHeight(2290);

500 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

501 QTRY_COMPARE(grid->m_visibleItems.count(), 198);

502

503 grid->setDisplayMarginBeginning(-300);

504 grid->setDisplayMarginEnd(-(grid->height() - 400));

505 checkImplicitHeight(2290);

506

507 QTRY_COMPARE(grid->m_firstVisibleIndex, 36);

508 QTRY_COMPARE(grid->m_visibleItems.count(), 54);

509 checkImplicitHeight(2290);

510

511 view->resize(470, 470);

512

513 grid->setSmallDelegateSize(QSizeF(90, 90));

514 grid->setBigDelegateSize(QSizeF(180, 180));

515

516 model->setCount(21);

517

518 QTRY_COMPARE(grid->m_visibleItems.count(), 0);

519

520 grid->setDisplayMarginBeginning(0);

521 grid->setDisplayMarginEnd(0);

522

523 // This is exactly the same block as the first again

524 checkInitialPositions();

525 }

526

527private:

528 QQuickView *view;

529 OrganicGrid *grid;

530 DummyModel *model;

531};

532

533QTEST_MAIN(OrganicGridTest)

534

535#include "organicgridtest.moc"