plugins/Dash/abstractdashview.cpp · unity8

git.iko.soy/unity8

on f45a574 help sign in

unity8/plugins/Dash/abstractdashview.cpp

348 lines 9.0 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 "abstractdashview.h"

19static const qreal bufferRatio = 0.5;

21AbstractDashView::AbstractDashView()

22 : m_delegateModel(nullptr)

23 , m_asyncRequestedIndex(-1)

24 , m_columnSpacing(0)

25 , m_rowSpacing(0)

26 , m_buffer(320) // Same value used in qquickitemview.cpp in Qt 5.4

27 , m_displayMarginBeginning(0)

28 , m_displayMarginEnd(0)

29 , m_needsRelayout(false)

30 , m_delegateValidated(false)

31 , m_implicitHeightDirty(false)

32{

33 connect(this, SIGNAL(widthChanged()), this, SLOT(relayout()));

34 connect(this, SIGNAL(heightChanged()), this, SLOT(onHeightChanged()));

35}

37QAbstractItemModel *AbstractDashView::model() const

38{

39 return m_delegateModel ? m_delegateModel->model().value<QAbstractItemModel *>() : nullptr;

40}

42void AbstractDashView::setModel(QAbstractItemModel *model)

43{

44 if (model != this->model()) {

45 if (!m_delegateModel) {

46 createDelegateModel();

47 } else {

48 disconnect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,bool)), this, SLOT(onModelUpdated(QQmlChangeSet,bool)));

49 }

50 m_delegateModel->setModel(QVariant::fromValue<QAbstractItemModel *>(model));

51 connect(m_delegateModel, SIGNAL(modelUpdated(QQmlChangeSet,bool)), this, SLOT(onModelUpdated(QQmlChangeSet,bool)));

53 cleanupExistingItems();

55 Q_EMIT modelChanged();

56 polish();

57 }

58}

60QQmlComponent *AbstractDashView::delegate() const

61{

62 return m_delegateModel ? m_delegateModel->delegate() : nullptr;

63}

65void AbstractDashView::setDelegate(QQmlComponent *delegate)

66{

67 if (delegate != this->delegate()) {

68 if (!m_delegateModel) {

69 createDelegateModel();

70 }

72 cleanupExistingItems();

74 m_delegateModel->setDelegate(delegate);

76 Q_EMIT delegateChanged();

77 m_delegateValidated = false;

78 polish();

79 }

80}

82qreal AbstractDashView::columnSpacing() const

83{

84 return m_columnSpacing;

85}

87void AbstractDashView::setColumnSpacing(qreal columnSpacing)

88{

89 if (columnSpacing != m_columnSpacing) {

90 m_columnSpacing = columnSpacing;

91 Q_EMIT columnSpacingChanged();

93 if (isComponentComplete()) {

94 relayout();

95 }

96 }

97}

99qreal AbstractDashView::rowSpacing() const

100{

101 return m_rowSpacing;

102}

103

104void AbstractDashView::setRowSpacing(qreal rowSpacing)

105{

106 if (rowSpacing != m_rowSpacing) {

107 m_rowSpacing = rowSpacing;

108 Q_EMIT rowSpacingChanged();

109

110 if (isComponentComplete()) {

111 relayout();

112 }

113 }

114}

115

116qreal AbstractDashView::cacheBuffer() const

117{

118 return m_buffer;

119}

120

121void AbstractDashView::setCacheBuffer(qreal buffer)

122{

123 if (buffer < 0) {

124 qmlInfo(this) << "Cannot set a negative cache buffer";

125 return;

126 }

127

128 if (m_buffer != buffer) {

129 m_buffer = buffer;

130 if (isComponentComplete()) {

131 relayout();

132 }

133 emit cacheBufferChanged();

134 }

135}

136

137qreal AbstractDashView::displayMarginBeginning() const

138{

139 return m_displayMarginBeginning;

140}

141

142void AbstractDashView::setDisplayMarginBeginning(qreal begin)

143{

144 if (m_displayMarginBeginning == begin)

145 return;

146 m_displayMarginBeginning = begin;

147 if (isComponentComplete()) {

148 polish();

149 }

150 emit displayMarginBeginningChanged();

151}

152

153qreal AbstractDashView::displayMarginEnd() const

154{

155 return m_displayMarginEnd;

156}

157

158void AbstractDashView::setDisplayMarginEnd(qreal end)

159{

160 if (m_displayMarginEnd == end)

161 return;

162 m_displayMarginEnd = end;

163 if (isComponentComplete()) {

164 polish();

165 }

166 emit displayMarginEndChanged();

167}

168

169void AbstractDashView::createDelegateModel()

170{

171 m_delegateModel = new QQmlDelegateModel(qmlContext(this), this);

172 connect(m_delegateModel, SIGNAL(createdItem(int,QObject*)), this, SLOT(itemCreated(int,QObject*)));

173 if (isComponentComplete())

174 m_delegateModel->componentComplete();

175}

176

177void AbstractDashView::refill()

178{

179 if (!isComponentComplete() || height() < 0) {

180 return;

181 }

182

183 const qreal from = -m_displayMarginBeginning;

184 const qreal to = height() + m_displayMarginEnd;

185 const qreal bufferFrom = from - m_buffer;

186 const qreal bufferTo = to + m_buffer;

187

188 bool added = addVisibleItems(from, to, false);

189 bool removed = removeNonVisibleItems(bufferFrom, bufferTo);

190 added |= addVisibleItems(bufferFrom, bufferTo, true);

191

192 if (added || removed) {

193 m_implicitHeightDirty = true;

194 polish();

195 }

196}

197

198bool AbstractDashView::addVisibleItems(qreal fillFromY, qreal fillToY, bool asynchronous)

199{

200 if (fillToY <= fillFromY)

201 return false;

202

203 if (!delegate())

204 return false;

205

206 if (m_delegateModel->count() == 0)

207 return false;

208

209 int modelIndex;

210 qreal yPos;

211 findBottomModelIndexToAdd(&modelIndex, &yPos);

212 bool changed = false;

213 while (modelIndex < m_delegateModel->count() && yPos <= fillToY) {

214 if (!createItem(modelIndex, asynchronous))

215 break;

216

217 changed = true;

218 findBottomModelIndexToAdd(&modelIndex, &yPos);

219 }

220

221 findTopModelIndexToAdd(&modelIndex, &yPos);

222 while (modelIndex >= 0 && yPos > fillFromY) {

223 if (!createItem(modelIndex, asynchronous))

224 break;

225

226 changed = true;

227 findTopModelIndexToAdd(&modelIndex, &yPos);

228 }

229

230 return changed;

231}

232

233QQuickItem *AbstractDashView::createItem(int modelIndex, bool asynchronous)

234{

235 if (asynchronous && m_asyncRequestedIndex != -1)

236 return nullptr;

237

238 m_asyncRequestedIndex = -1;

239 QObject* object = m_delegateModel->object(modelIndex, asynchronous);

240 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);

241 if (!item) {

242 if (object) {

243 m_delegateModel->release(object);

244 if (!m_delegateValidated) {

245 m_delegateValidated = true;

246 QObject* delegateObj = delegate();

247 qmlInfo(delegateObj ? delegateObj : this) << "Delegate must be of Item type";

248 }

249 } else {

250 m_asyncRequestedIndex = modelIndex;

251 }

252 return nullptr;

253 } else {

254 addItemToView(modelIndex, item);

255 return item;

256 }

257}

258

259void AbstractDashView::releaseItem(QQuickItem *item)

260{

261 QQmlDelegateModel::ReleaseFlags flags = m_delegateModel->release(item);

262 if (flags & QQmlDelegateModel::Destroyed) {

263 item->setParentItem(nullptr);

264 }

265}

266

267void AbstractDashView::setImplicitHeightDirty()

268{

269 m_implicitHeightDirty = true;

270}

271

272void AbstractDashView::itemCreated(int modelIndex, QObject *object)

273{

274 QQuickItem *item = qmlobject_cast<QQuickItem*>(object);

275 if (!item) {

276 qWarning() << "AbstractDashView::itemCreated got a non item for index" << modelIndex;

277 return;

278 }

279 item->setParentItem(this);

280

281 // We only need to call createItem if we are here because of an asynchronous generation

282 // otherwise we are in this slot because createItem is creating the item sync

283 // and thus we don't need to call createItem again, nor need to set m_implicitHeightDirty

284 // and call polish because the sync createItem was called from addVisibleItems that

285 // is called from refill that will already do those if an item was added

286 if (modelIndex == m_asyncRequestedIndex) {

287 createItem(modelIndex, false);

288 m_implicitHeightDirty = true;

289 polish();

290 }

291}

292

293void AbstractDashView::onModelUpdated(const QQmlChangeSet &changeSet, bool reset)

294{

295 if (reset) {

296 cleanupExistingItems();

297 } else {

298 processModelRemoves(changeSet.removes());

299 }

300 polish();

301}

302

303

304void AbstractDashView::relayout()

305{

306 m_needsRelayout = true;

307 polish();

308}

309

310void AbstractDashView::onHeightChanged()

311{

312 polish();

313}

314

315void AbstractDashView::updatePolish()

316{

317 if (!model())

318 return;

319

320 if (m_needsRelayout) {

321 doRelayout();

322 m_needsRelayout = false;

323 m_implicitHeightDirty = true;

324 }

325

326 refill();

327

328 const qreal from = -m_displayMarginBeginning;

329 const qreal to = height() + m_displayMarginEnd;

330 updateItemCulling(from, to);

331

332 if (m_implicitHeightDirty) {

333 calculateImplicitHeight();

334 m_implicitHeightDirty = false;

335 }

336}

337

338void AbstractDashView::componentComplete()

339{

340 if (m_delegateModel)

341 m_delegateModel->componentComplete();

342

343 QQuickItem::componentComplete();

344

345 m_needsRelayout = true;

346

347 polish();

348}