tests/plugins/Dash/organicgridtest.cpp · unity8

git.iko.soy/unity8

on 1fb8ffc help sign in

unity8/tests/plugins/Dash/organicgridtest.cpp

533 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 override

38 {

39 return m_count;

40 }

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

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

130 model = new DummyModel();

131 model->setCount(21);

132

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

134

135 view->show();

136 QTest::qWaitForWindowExposed(view);

137 view->resize(470, 400);

138

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

140 grid->setModel(model);

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

142

143 checkInitialPositions();

144 }

145

146 void cleanup()

147 {

148 delete view;

149 delete model;

150 }

151

152 void testInitialPosition()

153 {

154 }

155

156 void testWidthResize()

157 {

158 view->resize(770, 400);

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

160

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

162 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

163 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 2);

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

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

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

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

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

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

170

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

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

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

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

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

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

177

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

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

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

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

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

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

184

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

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

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

188

189 checkImplicitHeight(570);

190

191 view->resize(769, 400);

192

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

194 checkInitialPositions();

195 }

196

197 void testColumnSpacing()

198 {

199 grid->setColumnSpacing(11);

200

201 QTRY_COMPARE(grid->m_needsRelayout, false);

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

203 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

204 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

223 checkImplicitHeight(1150);

224

225 grid->setColumnSpacing(10);

226 QTRY_COMPARE(grid->m_needsRelayout, false);

227

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

229 checkInitialPositions();

230 }

231

232 void testRowSpacing()

233 {

234 grid->setRowSpacing(11);

235

236 QTRY_COMPARE(grid->m_needsRelayout, false);

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

238 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

239 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

258 checkImplicitHeight(1157);

259

260 grid->setRowSpacing(10);

261 QTRY_COMPARE(grid->m_needsRelayout, false);

262

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

264 checkInitialPositions();

265 }

266

267 void testDelegateSizeChange()

268 {

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

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

271 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

279

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

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

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

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

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

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

286

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

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

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

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

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

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

293

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

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

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

297 checkImplicitHeight(190);

298

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

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

301

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

303 checkInitialPositions();

304 }

305

306 void testChangeModel()

307 {

308 DummyModel *model2 = new DummyModel();

309 model2->setCount(6);

310 grid->setModel(model2);

311 delete model;

312 model = model2;

313

314 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

322 checkImplicitHeight(280);

323 }

324

325 void testModelReset()

326 {

327 model->setCount(6);

328

329 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

337 checkImplicitHeight(280);

338 }

339

340 void testModelRemoveLastNonVisible()

341 {

342 model->removeLast();

343

344 // This is the same than checkInitialPositions but

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

346 // in the model

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

348 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

349 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

368 checkImplicitHeight(960);

369

370 model->removeLast();

371

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

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

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

375 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

376 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

395 checkImplicitHeight(960);

396

397 model->removeLast();

398

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

400 // it does change height again

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

402 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

403 QTRY_COMPARE(grid->m_numberOfModulesPerRow, 1);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

422 checkImplicitHeight(860);

423

424 }

425

426 void testModelAppendRemoveLast()

427 {

428 DummyModel *model2 = new DummyModel();

429 model2->setCount(6);

430 grid->setModel(model2);

431 delete model;

432 model = model2;

433

434 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

442 checkImplicitHeight(280);

443

444 model2->addItem();

445

446 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

455 checkImplicitHeight(380);

456

457 model2->addItem();

458 model2->addItem();

459

460 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

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

471 checkImplicitHeight(570);

472

473 model2->removeLast();

474

475 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

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

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

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

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

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

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

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

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

485 checkImplicitHeight(380);

486 }

487

488 void testDelegateCreationRanges()

489 {

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

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

492 model->setCount(400);

493 checkImplicitHeight(2290);

494

495 view->resize(470, 700);

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

497 checkImplicitHeight(2290);

498 QTRY_COMPARE(grid->m_firstVisibleIndex, 0);

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

500

501 grid->setDisplayMarginBeginning(-300);

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

503 checkImplicitHeight(2290);

504

505 QTRY_COMPARE(grid->m_firstVisibleIndex, 36);

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

507 checkImplicitHeight(2290);

508

509 view->resize(470, 470);

510

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

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

513

514 model->setCount(21);

515

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

517

518 grid->setDisplayMarginBeginning(0);

519 grid->setDisplayMarginEnd(0);

520

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

522 checkInitialPositions();

523 }

524

525private:

526 QQuickView *view;

527 OrganicGrid *grid;

528 DummyModel *model;

529};

530

531QTEST_MAIN(OrganicGridTest)

532

533#include "organicgridtest.moc"