Differential D3805 Diff 19301 applets/kicker/plugin/placeholdermodel.cpp

Changeset View

Standalone View

View Options

applets/kicker/plugin/placeholdermodel.cpp

  • This file was added.
1​/***************************************************************************
2​ * Copyright (C) 2015 by Eike Hein <hein@kde.org> *
3​ * Copyright (C) 2017 by Ivan Cukic <ivan.cukic@kde.org> *
4​ * *
5​ * This program is free software; you can redistribute it and/or modify *
6​ * it under the terms of the GNU General Public License as published by *
7​ * the Free Software Foundation; either version 2 of the License, or *
8​ * (at your option) any later version. *
9​ * *
10​ * This program is distributed in the hope that it will be useful, *
11​ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12​ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13​ * GNU General Public License for more details. *
14​ * *
15​ * You should have received a copy of the GNU General Public License *
16​ * along with this program; if not, write to the *
17​ * Free Software Foundation, Inc., *
18​ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA . *
19​ ***************************************************************************/
20​
21​#include "placeholdermodel.h"
22​#include "actionlist.h"
23​
24​#include <QDebug>
25​#include <QTimer>
26​
27​PlaceholderModel::PlaceholderModel(QObject *parent)
28​ : AbstractModel(parent)
29​ , m_dropPlaceholderIndex(-1)
30​ , m_isTriggerInhibited(false)
31​{
32​ connect(&m_triggerInhibitor, &QTimer::timeout,
33​ this, [&] {
34​ qDebug() << "%%% Inhibit stopped";
35​ m_isTriggerInhibited = false;
36​ });
37​
38​ m_triggerInhibitor.setInterval(500);
39​ m_triggerInhibitor.setSingleShot(true);
40​}
41​
42​void PlaceholderModel::inhibitTriggering()
43​{
44​ qDebug() << "%%% Inhibit started";
45​ m_isTriggerInhibited = true;
46​ m_triggerInhibitor.start();
47​}
48​
49​PlaceholderModel::~PlaceholderModel()
50​{
51​}
52​
53​QString PlaceholderModel::description() const
54​{
55​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
56​ return abstractModel->description();
57​
58​ } else {
59​ return QString();
60​ }
61​}
62​
63​QAbstractItemModel *PlaceholderModel::sourceModel() const
64​{
65​ return m_sourceModel;
66​}
67​
68​void PlaceholderModel::setSourceModel(QAbstractItemModel *sourceModel)
69​{
70​ disconnectSignals();
71​
72​ beginResetModel();
73​
74​ m_sourceModel = sourceModel;
75​
76​ connectSignals();
77​
78​ endResetModel();
79​
80​ emit countChanged();
81​ emit sourceModelChanged();
82​ emit descriptionChanged();
83​}
84​
85​bool PlaceholderModel::canFetchMore(const QModelIndex &parent) const
86​{
87​ return m_sourceModel && m_sourceModel->canFetchMore(indexToSourceIndex(parent));
88​}
89​
90​void PlaceholderModel::fetchMore(const QModelIndex &parent)
91​{
92​ if (m_sourceModel) {
93​ m_sourceModel->fetchMore(indexToSourceIndex(parent));
94​ }
95​}
96​
97​QModelIndex PlaceholderModel::index(int row, int column, const QModelIndex &parent) const
98​{
99​ Q_UNUSED(parent)
100​
101​ return m_sourceModel ? createIndex(row, column)
102​ : QModelIndex();
103​}
104​
105​QModelIndex PlaceholderModel::parent(const QModelIndex &index) const
106​{
107​ Q_UNUSED(index)
108​
109​ return QModelIndex();
110​}
111​
112​QVariant PlaceholderModel::data(const QModelIndex &index, int role) const
113​{
114​ const auto row = index.row();
115​
116​ if (m_dropPlaceholderIndex == row) {
117​ switch (role) {
118​ case Kicker::IsDropPlaceholderRole:
119​ return true;
120​
121​ // TODO: Maybe it would be nice to show something here?
122​ // case Qt::DisplayRole:
123​ // return "placeholder";
124​ //
125​ // case Qt::DecorationRole:
126​ // return "select";
127​
128​ default:
129​ return QVariant();
130​
131​ }
132​ }
133​
134​ return m_sourceModel ? m_sourceModel->data(indexToSourceIndex(index), role)
135​ : QVariant();
136​}
137​
138​int PlaceholderModel::rowCount(const QModelIndex &parent) const
139​{
140​ if (!m_sourceModel || parent.isValid()) {
141​ return 0;
142​ }
143​
144​ return m_sourceModel->rowCount()
145​ + (m_dropPlaceholderIndex != -1 ? 1 : 0);
146​}
147​
148​QModelIndex PlaceholderModel::indexToSourceIndex(const QModelIndex& index) const
149​{
150​ if (!m_sourceModel || !index.isValid()) {
151​ return QModelIndex();
152​ }
153​
154​ const auto row = index.row();
155​ const auto column = index.column();
156​
157​ return index.parent().isValid() ?
158​ // We do not support tree models
159​ QModelIndex() :
160​
161​ // If we are on top-level, lets add a placeholder
162​ m_sourceModel->index(
163​ row - (m_dropPlaceholderIndex != -1 && row > m_dropPlaceholderIndex ? 1 : 0),
164​ column,
165​ QModelIndex()
166​ );
167​}
168​
169​int PlaceholderModel::sourceRowToRow(int sourceRow) const
170​{
171​ return sourceRow +
172​ (m_dropPlaceholderIndex != -1 && sourceRow >= m_dropPlaceholderIndex ? 1 : 0);
173​}
174​
175​int PlaceholderModel::rowToSourceRow(int row) const
176​{
177​ return row == m_dropPlaceholderIndex ? -1 :
178​ row - (m_dropPlaceholderIndex != -1 && row > m_dropPlaceholderIndex ? 1 : 0);
179​}
180​
181​QModelIndex PlaceholderModel::sourceIndexToIndex(const QModelIndex& sourceIndex) const
182​{
183​ if (!m_sourceModel || !sourceIndex.isValid()) {
184​ return QModelIndex();
185​ }
186​
187​ const auto sourceRow = sourceIndex.row();
188​ const auto sourceColumn = sourceIndex.column();
189​
190​ return sourceIndex.parent().isValid() ?
191​ // We do not support tree-models
192​ QModelIndex() :
193​
194​ // If we are on top-level, lets add a placeholder
195​ index(
196​ sourceRowToRow(sourceRow),
197​ sourceColumn,
198​ QModelIndex()
199​ );
200​}
201​
202​bool PlaceholderModel::trigger(int row, const QString &actionId, const QVariant &argument)
203​{
204​ if (m_isTriggerInhibited) return false;
205​
206​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
207​ return abstractModel->trigger(rowToSourceRow(row), actionId, argument);
208​
209​ } else {
210​ return false;
211​ }
212​}
213​
214​QString PlaceholderModel::labelForRow(int row)
215​{
216​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
217​ return abstractModel->labelForRow(rowToSourceRow(row));
218​
219​ } else {
220​ return QString();
221​ }
222​
223​}
224​
225​AbstractModel* PlaceholderModel::modelForRow(int row)
226​{
227​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
228​ return abstractModel->modelForRow(rowToSourceRow(row));
229​
230​ } else {
231​ return 0;
232​ }
233​}
234​
235​AbstractModel* PlaceholderModel::favoritesModel()
236​{
237​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
238​ return abstractModel->favoritesModel();
239​
240​ } else {
241​ return AbstractModel::favoritesModel();
242​ }
243​}
244​
245​int PlaceholderModel::separatorCount() const
246​{
247​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
martUnsubmitted
Done

here on opensuse (older gcc) in order to make it build i need to do
connect(m_sourceModel.data(), ...

to all connect(m_sourceModel

mart: here on opensuse (older gcc) in order to make it build i need to do connect(m_sourceModel.data…
248​ return abstractModel->separatorCount();
249​
250​ } else {
251​ return 0;
252​ }
253​}
254​
255​void PlaceholderModel::reset()
256​{
257​ emit beginResetModel();
258​ emit endResetModel();
259​ emit countChanged();
260​ emit separatorCountChanged();
261​}
262​
263​void PlaceholderModel::connectSignals()
264​{
265​ if (!m_sourceModel) {
266​ return;
267​ }
268​
269​ const auto sourceModelPtr = m_sourceModel.data();
270​
271​ connect(sourceModelPtr, SIGNAL(destroyed()), this, SLOT(reset()));
272​
273​ connect(sourceModelPtr, &QAbstractItemModel::dataChanged,
274​ this, [this] (const QModelIndex &from, const QModelIndex &to, const QVector<int> &roles) {
275​ emit dataChanged(sourceIndexToIndex(from),
276​ sourceIndexToIndex(to),
277​ roles);
278​ });
279​
280​ connect(sourceModelPtr, &QAbstractItemModel::rowsAboutToBeInserted,
281​ this, [this] (const QModelIndex &parent, int from, int to) {
282​ if (parent.isValid()) {
283​ qWarning() << "We do not support tree models";
284​
285​ } else {
286​ beginInsertRows(QModelIndex(),
287​ sourceRowToRow(from),
288​ sourceRowToRow(to));
289​
290​ }
291​ });
292​
293​ connect(sourceModelPtr, &QAbstractItemModel::rowsInserted,
294​ this, [this] {
295​ endInsertRows();
296​ emit countChanged();
297​ });
298​
299​
300​ connect(sourceModelPtr, &QAbstractItemModel::rowsAboutToBeMoved,
301​ this, [this] (const QModelIndex &source, int from, int to, const QModelIndex &dest, int destRow) {
302​ if (source.isValid() || dest.isValid()) {
303​ qWarning() << "We do not support tree models";
304​
305​ } else {
306​ beginMoveRows(QModelIndex(),
307​ sourceRowToRow(from),
308​ sourceRowToRow(to),
309​ QModelIndex(),
310​ sourceRowToRow(destRow));
311​ }
312​ });
313​
314​ connect(sourceModelPtr, &QAbstractItemModel::rowsMoved,
315​ this, [this] {
316​ endMoveRows();
317​ });
318​
319​
320​ connect(sourceModelPtr, &QAbstractItemModel::rowsAboutToBeRemoved,
321​ this, [this] (const QModelIndex &parent, int from, int to) {
322​ if (parent.isValid()) {
323​ qWarning() << "We do not support tree models";
324​
325​ } else {
326​ beginRemoveRows(QModelIndex(),
327​ sourceRowToRow(from),
328​ sourceRowToRow(to));
329​ }
330​ });
331​
332​ connect(sourceModelPtr, &QAbstractItemModel::rowsRemoved,
333​ this, [this] {
334​ endRemoveRows();
335​ emit countChanged();
336​ });
337​
338​
339​ connect(sourceModelPtr, &QAbstractItemModel::modelAboutToBeReset,
340​ this, [this] {
341​ beginResetModel();
342​ });
343​
344​ connect(sourceModelPtr, &QAbstractItemModel::modelReset,
345​ this, [this] {
346​ endResetModel();
347​ emit countChanged();
348​ });
349​
350​ // We do not have persistant indices
351​ // connect(sourceModelPtr, &QAbstractItemModel::layoutAboutToBeChanged),
352​ // this, &PlaceholderModel::layoutAboutToBeChanged);
353​ // connect(sourceModelPtr, &QAbstractItemModel::layoutChanged),
354​ // this, SIGNAL(layoutChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)),
355​ // Qt::UniqueConnection);
356​}
357​
358​void PlaceholderModel::disconnectSignals()
359​{
360​ if (!m_sourceModel) {
361​ return;
362​ }
363​
364​ disconnect(m_sourceModel, 0, this, 0);
365​}
366​
367​int PlaceholderModel::dropPlaceholderIndex() const
368​{
369​ return m_dropPlaceholderIndex;
370​}
371​
372​void PlaceholderModel::setDropPlaceholderIndex(int index)
373​{
374​ if (index == m_dropPlaceholderIndex) return;
375​
376​ inhibitTriggering();
377​
378​ if (index == -1 && m_dropPlaceholderIndex != -1) {
379​ // Removing the placeholder
380​ beginRemoveRows(QModelIndex(), m_dropPlaceholderIndex, m_dropPlaceholderIndex);
381​ m_dropPlaceholderIndex = index;
382​ endRemoveRows();
383​
384​ emit countChanged();
385​
386​ } else if (index != -1 && m_dropPlaceholderIndex == -1) {
387​ // Creating the placeholder
388​ beginInsertRows(QModelIndex(), index, index);
389​ m_dropPlaceholderIndex = index;
390​ endInsertRows();
391​
392​ emit countChanged();
393​
394​ } else if (m_dropPlaceholderIndex != index) {
395​ // Moving the placeholder
396​ int modelTo = index + (index > m_dropPlaceholderIndex ? 1 : 0);
397​
398​ if (beginMoveRows(
399​ QModelIndex(), m_dropPlaceholderIndex, m_dropPlaceholderIndex,
400​ QModelIndex(), modelTo)) {
401​ m_dropPlaceholderIndex = index;
402​ endMoveRows();
403​ }
404​ }
405​
406​ emit dropPlaceholderIndexChanged();
407​}