Differential D3805 Diff 19034 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​
26​PlaceholderModel::PlaceholderModel(QObject *parent)
27​ : AbstractModel(parent)
28​ , m_dropPlaceholderIndex(-1)
29​{
30​}
31​
32​PlaceholderModel::~PlaceholderModel()
33​{
34​}
35​
36​QString PlaceholderModel::description() const
37​{
38​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
39​ return abstractModel->description();
40​
41​ } else {
42​ return QString();
43​ }
44​}
45​
46​QAbstractItemModel *PlaceholderModel::sourceModel() const
47​{
48​ return m_sourceModel;
49​}
50​
51​void PlaceholderModel::setSourceModel(QAbstractItemModel *sourceModel)
52​{
53​ disconnectSignals();
54​
55​ beginResetModel();
56​
57​ m_sourceModel = sourceModel;
58​
59​ connectSignals();
60​
61​ endResetModel();
62​
63​ emit countChanged();
64​ emit sourceModelChanged();
65​ emit descriptionChanged();
66​}
67​
68​bool PlaceholderModel::canFetchMore(const QModelIndex &parent) const
69​{
70​ return m_sourceModel && m_sourceModel->canFetchMore(indexToSourceIndex(parent));
71​}
72​
73​void PlaceholderModel::fetchMore(const QModelIndex &parent)
74​{
75​ if (m_sourceModel) {
76​ m_sourceModel->fetchMore(indexToSourceIndex(parent));
77​ }
78​}
79​
80​QModelIndex PlaceholderModel::index(int row, int column, const QModelIndex &parent) const
81​{
82​ Q_UNUSED(parent)
83​
84​ return m_sourceModel ? createIndex(row, column)
85​ : QModelIndex();
86​}
87​
88​QModelIndex PlaceholderModel::parent(const QModelIndex &index) const
89​{
90​ Q_UNUSED(index)
91​
92​ return QModelIndex();
93​}
94​
95​QVariant PlaceholderModel::data(const QModelIndex &index, int role) const
96​{
97​ const auto row = index.row();
98​
99​ if (m_dropPlaceholderIndex == row) {
100​ switch (role) {
101​ case Kicker::IsDropPlaceholderRole:
102​ return true;
103​
104​ // TODO: Maybe it would be nice to show something here?
105​ // case Qt::DisplayRole:
106​ // return "placeholder";
107​ //
108​ // case Qt::DecorationRole:
109​ // return "select";
110​
111​ default:
112​ return QVariant();
113​
114​ }
115​ }
116​
117​ return m_sourceModel ? m_sourceModel->data(indexToSourceIndex(index), role)
118​ : QVariant();
119​}
120​
121​int PlaceholderModel::rowCount(const QModelIndex &parent) const
122​{
123​ if (!m_sourceModel || parent.isValid()) {
124​ return 0;
125​ }
126​
127​ return m_sourceModel->rowCount()
128​ + (m_dropPlaceholderIndex != -1 ? 1 : 0);
129​}
130​
131​QModelIndex PlaceholderModel::indexToSourceIndex(const QModelIndex& index) const
132​{
133​ if (!m_sourceModel || !index.isValid()) {
134​ return QModelIndex();
135​ }
136​
137​ const auto row = index.row();
138​ const auto column = index.column();
139​
140​ return index.parent().isValid() ?
141​ // We do not support tree models
142​ QModelIndex() :
143​
144​ // If we are on top-level, lets add a placeholder
145​ m_sourceModel->index(
146​ row - (m_dropPlaceholderIndex != -1 && row > m_dropPlaceholderIndex ? 1 : 0),
147​ column,
148​ QModelIndex()
149​ );
150​}
151​
152​int PlaceholderModel::sourceRowToRow(int sourceRow) const
153​{
154​ return sourceRow +
155​ (m_dropPlaceholderIndex != -1 && sourceRow >= m_dropPlaceholderIndex ? 1 : 0);
156​}
157​
158​int PlaceholderModel::rowToSourceRow(int row) const
159​{
160​ return row == m_dropPlaceholderIndex ? -1 :
161​ row - (m_dropPlaceholderIndex != -1 && row > m_dropPlaceholderIndex ? 1 : 0);
162​}
163​
164​QModelIndex PlaceholderModel::sourceIndexToIndex(const QModelIndex& sourceIndex) const
165​{
166​ if (!m_sourceModel || !sourceIndex.isValid()) {
167​ return QModelIndex();
168​ }
169​
170​ const auto sourceRow = sourceIndex.row();
171​ const auto sourceColumn = sourceIndex.column();
172​
173​ return sourceIndex.parent().isValid() ?
174​ // We do not support tree-models
175​ QModelIndex() :
176​
177​ // If we are on top-level, lets add a placeholder
178​ index(
179​ sourceRowToRow(sourceRow),
180​ sourceColumn,
181​ QModelIndex()
182​ );
183​}
184​
185​bool PlaceholderModel::trigger(int row, const QString &actionId, const QVariant &argument)
186​{
187​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
188​ return abstractModel->trigger(rowToSourceRow(row), actionId, argument);
189​
190​ } else {
191​ return false;
192​ }
193​}
194​
195​QString PlaceholderModel::labelForRow(int row)
196​{
197​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
198​ return abstractModel->labelForRow(rowToSourceRow(row));
199​
200​ } else {
201​ return QString();
202​ }
203​
204​}
205​
206​AbstractModel* PlaceholderModel::modelForRow(int row)
207​{
208​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
209​ return abstractModel->modelForRow(rowToSourceRow(row));
210​
211​ } else {
212​ return 0;
213​ }
214​}
215​
216​AbstractModel* PlaceholderModel::favoritesModel()
217​{
218​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
219​ return abstractModel->favoritesModel();
220​
221​ } else {
222​ return AbstractModel::favoritesModel();
223​ }
224​}
225​
226​int PlaceholderModel::separatorCount() const
227​{
228​ if (auto abstractModel = qobject_cast<AbstractModel *>(m_sourceModel)) {
229​ return abstractModel->separatorCount();
230​
231​ } else {
232​ return 0;
233​ }
234​}
235​
236​void PlaceholderModel::reset()
237​{
238​ emit beginResetModel();
239​ emit endResetModel();
240​ emit countChanged();
241​ emit separatorCountChanged();
242​}
243​
244​void PlaceholderModel::connectSignals()
245​{
246​ if (!m_sourceModel) {
247​ return;
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​ }
249​
250​ const auto sourceModelPtr = m_sourceModel.data();
251​
252​ connect(sourceModelPtr, SIGNAL(destroyed()), this, SLOT(reset()));
253​
254​ connect(sourceModelPtr, &QAbstractItemModel::dataChanged,
255​ this, [this] (const QModelIndex &from, const QModelIndex &to, const QVector<int> &roles) {
256​ emit dataChanged(sourceIndexToIndex(from),
257​ sourceIndexToIndex(to),
258​ roles);
259​ });
260​
261​ connect(sourceModelPtr, &QAbstractItemModel::rowsAboutToBeInserted,
262​ this, [this] (const QModelIndex &parent, int from, int to) {
263​ if (parent.isValid()) {
264​ qWarning() << "We do not support tree models";
265​
266​ } else {
267​ beginInsertRows(QModelIndex(),
268​ sourceRowToRow(from),
269​ sourceRowToRow(to));
270​
271​ }
272​ });
273​
274​ connect(sourceModelPtr, &QAbstractItemModel::rowsInserted,
275​ this, [this] {
276​ endInsertRows();
277​ emit countChanged();
278​ });
279​
280​
281​ connect(sourceModelPtr, &QAbstractItemModel::rowsAboutToBeMoved,
282​ this, [this] (const QModelIndex &source, int from, int to, const QModelIndex &dest, int destRow) {
283​ if (source.isValid() || dest.isValid()) {
284​ qWarning() << "We do not support tree models";
285​
286​ } else {
287​ beginMoveRows(QModelIndex(),
288​ sourceRowToRow(from),
289​ sourceRowToRow(to),
290​ QModelIndex(),
291​ sourceRowToRow(destRow));
292​ }
293​ });
294​
295​ connect(sourceModelPtr, &QAbstractItemModel::rowsMoved,
296​ this, [this] {
297​ endMoveRows();
298​ });
299​
300​
301​ connect(sourceModelPtr, &QAbstractItemModel::rowsAboutToBeRemoved,
302​ this, [this] (const QModelIndex &parent, int from, int to) {
303​ if (parent.isValid()) {
304​ qWarning() << "We do not support tree models";
305​
306​ } else {
307​ beginRemoveRows(QModelIndex(),
308​ sourceRowToRow(from),
309​ sourceRowToRow(to));
310​ }
311​ });
312​
313​ connect(sourceModelPtr, &QAbstractItemModel::rowsRemoved,
314​ this, [this] {
315​ endRemoveRows();
316​ emit countChanged();
317​ });
318​
319​
320​ connect(sourceModelPtr, &QAbstractItemModel::modelAboutToBeReset,
321​ this, [this] {
322​ beginResetModel();
323​ });
324​
325​ connect(sourceModelPtr, &QAbstractItemModel::modelReset,
326​ this, [this] {
327​ endResetModel();
328​ emit countChanged();
329​ });
330​
331​ // We do not have persistant indices
332​ // connect(sourceModelPtr, &QAbstractItemModel::layoutAboutToBeChanged),
333​ // this, &PlaceholderModel::layoutAboutToBeChanged);
334​ // connect(sourceModelPtr, &QAbstractItemModel::layoutChanged),
335​ // this, SIGNAL(layoutChanged(QList<QPersistentModelIndex>,QAbstractItemModel::LayoutChangeHint)),
336​ // Qt::UniqueConnection);
337​}
338​
339​void PlaceholderModel::disconnectSignals()
340​{
341​ if (!m_sourceModel) {
342​ return;
343​ }
344​
345​ disconnect(m_sourceModel, 0, this, 0);
346​}
347​
348​int PlaceholderModel::dropPlaceholderIndex() const
349​{
350​ return m_dropPlaceholderIndex;
351​}
352​
353​void PlaceholderModel::setDropPlaceholderIndex(int index)
354​{
355​ if (index == m_dropPlaceholderIndex) return;
356​
357​ if (index == -1 && m_dropPlaceholderIndex != -1) {
358​ // Removing the placeholder
359​ beginRemoveRows(QModelIndex(), m_dropPlaceholderIndex, m_dropPlaceholderIndex);
360​ m_dropPlaceholderIndex = index;
361​ endRemoveRows();
362​
363​ emit countChanged();
364​
365​ } else if (index != -1 && m_dropPlaceholderIndex == -1) {
366​ // Creating the placeholder
367​ beginInsertRows(QModelIndex(), index, index);
368​ m_dropPlaceholderIndex = index;
369​ endInsertRows();
370​
371​ emit countChanged();
372​
373​ } else if (m_dropPlaceholderIndex != index) {
374​ // Moving the placeholder
375​ int modelTo = index + (index > m_dropPlaceholderIndex ? 1 : 0);
376​
377​ if (beginMoveRows(
378​ QModelIndex(), m_dropPlaceholderIndex, m_dropPlaceholderIndex,
379​ QModelIndex(), modelTo)) {
380​ m_dropPlaceholderIndex = index;
381​ endMoveRows();
382​ }
383​ }
384​
385​ emit dropPlaceholderIndexChanged();
386​}