tests/plugins/Dash/organicgridtest.cpp · unity8

git.iko.soy/unity8

on f621663 help sign in

unity8/tests/plugins/Dash/organicgridtest.cpp

534 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"

33class DummyModel : public QAbstractListModel {

34public:

35 DummyModel() : m_count(0) {}

37 int rowCount(const QModelIndex & /*parent*/) const

38 {

39 return m_count;

40 }

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

43 {

44 return QVariant();

45 }

47 void setCount(int count)

48 {

49 beginResetModel();

50 m_count = count;

51 endResetModel();

52 }

54 void addItem()

55 {

56 beginInsertRows(QModelIndex(), m_count, m_count);

57 m_count++;

58 endInsertRows();

59 }

61 void removeLast()

62 {

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

64 m_count--;

65 endRemoveRows();

66 }

68private:

69 int m_count;

70};

72class OrganicGridTest : public QObject

73{

74 Q_OBJECT

76private:

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

78 {

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

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

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

82 const int inModuleIndex = modelIndex % 6;

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

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

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

86 } else {

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

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

89 }

90 }

92 void checkInitialPositions()

93 {

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

95 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

96 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

115 checkImplicitHeight(1150);

116 }

117

118 void checkImplicitHeight(qreal implicitHeight)

119 {

120 QTRY_COMPARE(grid->m_implicitHeightDirty, false);

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

122 }

123

124private Q_SLOTS:

125 void init()

126 {

127 view = new QQuickView();

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

129 view->engine()->addImportPath(BUILT_PLUGINS_DIR);

130

131 model = new DummyModel();

132 model->setCount(21);

133

134 view->setSource(QUrl::fromLocalFile(DASHVIEWSTEST_FOLDER "/organicgridtest.qml"));

135

136 view->show();

137 QTest::qWaitForWindowExposed(view);

138 view->resize(470, 400);

139

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

141 grid->setModel(model);

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

143

144 checkInitialPositions();

145 }

146

147 void cleanup()

148 {

149 delete view;

150 delete model;

151 }

152

153 void testInitialPosition()

154 {

155 }

156

157 void testWidthResize()

158 {

159 view->resize(770, 400);

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

161

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

163 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

164 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 2);

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

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

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

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

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

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

171

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

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

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

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

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

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

178

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

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

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

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

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

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

185

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

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

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

189

190 checkImplicitHeight(570);

191

192 view->resize(769, 400);

193

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

195 checkInitialPositions();

196 }

197

198 void testColumnSpacing()

199 {

200 grid->setColumnSpacing(11);

201

202 QTRY_COMPARE(grid->m_needsRelayout, false);

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

204 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

205 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

224 checkImplicitHeight(1150);

225

226 grid->setColumnSpacing(10);

227 QTRY_COMPARE(grid->m_needsRelayout, false);

228

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

230 checkInitialPositions();

231 }

232

233 void testRowSpacing()

234 {

235 grid->setRowSpacing(11);

236

237 QTRY_COMPARE(grid->m_needsRelayout, false);

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

239 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

240 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

259 checkImplicitHeight(1157);

260

261 grid->setRowSpacing(10);

262 QTRY_COMPARE(grid->m_needsRelayout, false);

263

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

265 checkInitialPositions();

266 }

267

268 void testDelegateSizeChange()

269 {

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

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

272 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

280

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

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

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

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

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

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

287

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

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

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

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

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

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

294

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

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

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

298 checkImplicitHeight(190);

299

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

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

302

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

304 checkInitialPositions();

305 }

306

307 void testChangeModel()

308 {

309 DummyModel *model2 = new DummyModel();

310 model2->setCount(6);

311 grid->setModel(model2);

312 delete model;

313 model = model2;

314

315 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

323 checkImplicitHeight(280);

324 }

325

326 void testModelReset()

327 {

328 model->setCount(6);

329

330 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

338 checkImplicitHeight(280);

339 }

340

341 void testModelRemoveLastNonVisible()

342 {

343 model->removeLast();

344

345 // This is the same than checkInitialPositions but

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

347 // in the model

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

349 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

350 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

369 checkImplicitHeight(960);

370

371 model->removeLast();

372

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

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

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

376 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

377 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

396 checkImplicitHeight(960);

397

398 model->removeLast();

399

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

401 // it does change height again

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

403 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

404 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

423 checkImplicitHeight(860);

424

425 }

426

427 void testModelAppendRemoveLast()

428 {

429 DummyModel *model2 = new DummyModel();

430 model2->setCount(6);

431 grid->setModel(model2);

432 delete model;

433 model = model2;

434

435 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

443 checkImplicitHeight(280);

444

445 model2->addItem();

446

447 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

456 checkImplicitHeight(380);

457

458 model2->addItem();

459 model2->addItem();

460

461 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

472 checkImplicitHeight(570);

473

474 model2->removeLast();

475

476 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

486 checkImplicitHeight(380);

487 }

488

489 void testDelegateCreationRanges()

490 {

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

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

493 model->setCount(400);

494 checkImplicitHeight(2290);

495

496 view->resize(470, 700);

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

498 checkImplicitHeight(2290);

499 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

501

502 grid->setDisplayMarginBeginning(-300);

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

504 checkImplicitHeight(2290);

505

506 QTRY_COMPARE(grid->m_firstVisibleIndex, 36);

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

508 checkImplicitHeight(2290);

509

510 view->resize(470, 470);

511

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

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

514

515 model->setCount(21);

516

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

518

519 grid->setDisplayMarginBeginning(0);

520 grid->setDisplayMarginEnd(0);

521

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

523 checkInitialPositions();

524 }

525

526private:

527 QQuickView *view;

528 OrganicGrid *grid;

529 DummyModel *model;

530};

531

532QTEST_MAIN(OrganicGridTest)

533

534#include "organicgridtest.moc"