tests/plugins/Dash/organicgridtest.cpp · unity8

git.iko.soy/unity8

on bef8ee3 help sign in

unity8/tests/plugins/Dash/organicgridtest.cpp

532 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#include <private/qquickitem_p.h>

28#include "organicgrid.h"

30#include <paths.h>

32class DummyModel : public QAbstractListModel {

33public:

34 DummyModel() : m_count(0) {}

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

37 {

38 return m_count;

39 }

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

42 {

43 return QVariant();

44 }

46 void setCount(int count)

47 {

48 beginResetModel();

49 m_count = count;

50 endResetModel();

51 }

53 void addItem()

54 {

55 beginInsertRows(QModelIndex(), m_count, m_count);

56 m_count++;

57 endInsertRows();

58 }

60 void removeLast()

61 {

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

63 m_count--;

64 endRemoveRows();

65 }

67private:

68 int m_count;

69};

71class OrganicGridTest : public QObject

72{

73 Q_OBJECT

75private:

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

77 {

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

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

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

81 const int inModuleIndex = modelIndex % 6;

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

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

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

85 } else {

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

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

88 }

89 }

91 void checkInitialPositions()

92 {

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

94 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

95 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

114 checkImplicitHeight(1150);

115 }

116

117 void checkImplicitHeight(qreal implicitHeight)

118 {

119 QTRY_COMPARE(grid->m_implicitHeightDirty, false);

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

121 }

122

123private Q_SLOTS:

124 void init()

125 {

126 view = new QQuickView();

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

128

129 model = new DummyModel();

130 model->setCount(21);

131

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

133

134 view->show();

135 QTest::qWaitForWindowExposed(view);

136 view->resize(470, 400);

137

138 grid = static_cast<OrganicGrid*>(view->rootObject()->findChild<QObject*>("grid"));

139 grid->setModel(model);

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

141

142 checkInitialPositions();

143 }

144

145 void cleanup()

146 {

147 delete view;

148 delete model;

149 }

150

151 void testInitialPosition()

152 {

153 }

154

155 void testWidthResize()

156 {

157 view->resize(770, 400);

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

159

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

161 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

162 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 2);

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

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

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

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

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

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

169

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

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

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

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

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

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

176

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

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

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

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

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

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

183

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

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

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

187

188 checkImplicitHeight(570);

189

190 view->resize(769, 400);

191

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

193 checkInitialPositions();

194 }

195

196 void testColumnSpacing()

197 {

198 grid->setColumnSpacing(11);

199

200 QTRY_COMPARE(grid->m_needsRelayout, false);

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

202 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

203 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

222 checkImplicitHeight(1150);

223

224 grid->setColumnSpacing(10);

225 QTRY_COMPARE(grid->m_needsRelayout, false);

226

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

228 checkInitialPositions();

229 }

230

231 void testRowSpacing()

232 {

233 grid->setRowSpacing(11);

234

235 QTRY_COMPARE(grid->m_needsRelayout, false);

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

237 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

238 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

257 checkImplicitHeight(1157);

258

259 grid->setRowSpacing(10);

260 QTRY_COMPARE(grid->m_needsRelayout, false);

261

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

263 checkInitialPositions();

264 }

265

266 void testDelegateSizeChange()

267 {

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

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

270 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

278

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

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

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

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

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

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

285

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

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

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

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

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

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

292

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

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

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

296 checkImplicitHeight(190);

297

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

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

300

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

302 checkInitialPositions();

303 }

304

305 void testChangeModel()

306 {

307 DummyModel *model2 = new DummyModel();

308 model2->setCount(6);

309 grid->setModel(model2);

310 delete model;

311 model = model2;

312

313 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

321 checkImplicitHeight(280);

322 }

323

324 void testModelReset()

325 {

326 model->setCount(6);

327

328 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

336 checkImplicitHeight(280);

337 }

338

339 void testModelRemoveLastNonVisible()

340 {

341 model->removeLast();

342

343 // This is the same than checkInitialPositions but

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

345 // in the model

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

347 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

348 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

367 checkImplicitHeight(960);

368

369 model->removeLast();

370

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

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

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

374 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

375 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

394 checkImplicitHeight(960);

395

396 model->removeLast();

397

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

399 // it does change height again

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

401 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

402 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

421 checkImplicitHeight(860);

422

423 }

424

425 void testModelAppendRemoveLast()

426 {

427 DummyModel *model2 = new DummyModel();

428 model2->setCount(6);

429 grid->setModel(model2);

430 delete model;

431 model = model2;

432

433 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

441 checkImplicitHeight(280);

442

443 model2->addItem();

444

445 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

454 checkImplicitHeight(380);

455

456 model2->addItem();

457 model2->addItem();

458

459 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

470 checkImplicitHeight(570);

471

472 model2->removeLast();

473

474 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

484 checkImplicitHeight(380);

485 }

486

487 void testDelegateCreationRanges()

488 {

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

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

491 model->setCount(400);

492 checkImplicitHeight(2290);

493

494 view->resize(470, 700);

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

496 checkImplicitHeight(2290);

497 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

499

500 grid->setDisplayMarginBeginning(-300);

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

502 checkImplicitHeight(2290);

503

504 QTRY_COMPARE(grid->m_firstVisibleIndex, 36);

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

506 checkImplicitHeight(2290);

507

508 view->resize(470, 470);

509

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

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

512

513 model->setCount(21);

514

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

516

517 grid->setDisplayMarginBeginning(0);

518 grid->setDisplayMarginEnd(0);

519

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

521 checkInitialPositions();

522 }

523

524private:

525 QQuickView *view;

526 OrganicGrid *grid;

527 DummyModel *model;

528};

529

530QTEST_MAIN(OrganicGridTest)

531

532#include "organicgridtest.moc"