← Back to branch summary

~ubuntu-branches/ubuntu/utopic/kdevplatform/utopic-proposed

« back to all changes in this revision

Viewing changes to util/placeholderitemproxymodel.cpp

  • Committer: Package Import Robot
  • Author(s): Scarlett Clark
  • Date: 2014-08-30 03:52:11 UTC
  • mfrom: (0.3.26)
  • Revision ID: package-import@ubuntu.com-20140830035211-wndqlc843eu2v8nk
Tags: 1.7.0-0ubuntu1
* New upstream release
* Add XS-Testsuite: autopkgtest

Show diffs side-by-side

added added

removed removed

Lines of Context:
util/placeholderitemproxymodel.cpp
 
1
/*
 
2
 * Copyright 2013 Kevin Funk <kfunk@kde.org>
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU General Public License as
 
6
 * published by the Free Software Foundation; either version 2 of
 
7
 * the License or (at your option) version 3 or any later version
 
8
 * accepted by the membership of KDE e.V. (or its successor approved
 
9
 * by the membership of KDE e.V.), which shall act as a proxy
 
10
 * defined in Section 14 of version 3 of the license.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
19
 *
 
20
 */
 
21
 
 
22
#include "placeholderitemproxymodel.h"
 
23
 
 
24
#include <KColorScheme>
 
25
 
 
26
using namespace KDevelop;
 
27
 
 
28
struct PlaceholderItemProxyModel::Private
 
29
{
 
30
    Private(PlaceholderItemProxyModel* qq)
 
31
        : q(qq)
 
32
    {}
 
33
 
 
34
    inline int sourceRowCount()
 
35
    {
 
36
        return q->sourceModel() ? q->sourceModel()->rowCount() : 0;
 
37
    }
 
38
 
 
39
    inline bool isPlaceholderRow(const QModelIndex& index) const
 
40
    {
 
41
        if (!q->sourceModel()) {
 
42
            return false;
 
43
        }
 
44
        return index.row() == q->sourceModel()->rowCount();
 
45
    }
 
46
 
 
47
    PlaceholderItemProxyModel* const q;
 
48
 
 
49
    /// column -> hint mapping
 
50
    QMap<int, QVariant> m_columnHints;
 
51
};
 
52
 
 
53
PlaceholderItemProxyModel::PlaceholderItemProxyModel(QObject* parent)
 
54
    : KIdentityProxyModel(parent)
 
55
    , d(new Private(this))
 
56
{}
 
57
 
 
58
PlaceholderItemProxyModel::~PlaceholderItemProxyModel()
 
59
{
 
60
}
 
61
 
 
62
QVariant PlaceholderItemProxyModel::columnHint(int column) const
 
63
{
 
64
    return d->m_columnHints.value(column);
 
65
}
 
66
 
 
67
void PlaceholderItemProxyModel::setColumnHint(int column, const QVariant& hint)
 
68
{
 
69
    if (column < 0) {
 
70
        return;
 
71
    }
 
72
 
 
73
    d->m_columnHints[column] = hint;
 
74
 
 
75
    const int row = d->sourceRowCount();
 
76
    emit dataChanged(index(row, 0), index(row, columnCount()));
 
77
}
 
78
 
 
79
Qt::ItemFlags PlaceholderItemProxyModel::flags(const QModelIndex& index) const
 
80
{
 
81
    if (d->isPlaceholderRow(index)) {
 
82
        Qt::ItemFlags flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled;
 
83
        const int column = index.column();
 
84
        // if the column doesn't provide a hint we assume that we can't edit this field
 
85
        if (d->m_columnHints.contains(column)) {
 
86
            flags |= Qt::ItemIsEditable;
 
87
        }
 
88
        return flags;
 
89
    }
 
90
 
 
91
    return KIdentityProxyModel::flags(index);
 
92
}
 
93
 
 
94
void PlaceholderItemProxyModel::setSourceModel(QAbstractItemModel* sourceModel)
 
95
{
 
96
    KIdentityProxyModel::setSourceModel(sourceModel);
 
97
    // TODO: Listen to layoutDataChanged signals?
 
98
}
 
99
 
 
100
int PlaceholderItemProxyModel::rowCount(const QModelIndex& parent) const
 
101
{
 
102
    if (!sourceModel())
 
103
        return 0;
 
104
 
 
105
    // only flat models supported for now, assert early in case that's not true
 
106
    Q_ASSERT(!parent.isValid());
 
107
    Q_UNUSED(parent);
 
108
    return sourceModel()->rowCount() + 1;
 
109
}
 
110
 
 
111
QVariant PlaceholderItemProxyModel::data(const QModelIndex& proxyIndex, int role) const
 
112
{
 
113
    const int column = proxyIndex.column();
 
114
    if (d->isPlaceholderRow(proxyIndex)) {
 
115
        switch (role) {
 
116
        case Qt::DisplayRole:
 
117
            return columnHint(column);
 
118
        case Qt::ForegroundRole: {
 
119
            const KColorScheme scheme(QPalette::Normal);
 
120
            return scheme.foreground(KColorScheme::InactiveText);
 
121
        }
 
122
        default:
 
123
            return QVariant();
 
124
        }
 
125
    }
 
126
    return KIdentityProxyModel::data(proxyIndex, role);
 
127
}
 
128
 
 
129
QModelIndex PlaceholderItemProxyModel::parent(const QModelIndex& child) const
 
130
{
 
131
    if (d->isPlaceholderRow(child)) {
 
132
        return QModelIndex();
 
133
    }
 
134
 
 
135
    return KIdentityProxyModel::parent(child);
 
136
}
 
137
 
 
138
QModelIndex PlaceholderItemProxyModel::buddy(const QModelIndex& index) const
 
139
{
 
140
    if (d->isPlaceholderRow(index)) {
 
141
        return index;
 
142
    }
 
143
    return KIdentityProxyModel::buddy(index);
 
144
}
 
145
 
 
146
QModelIndex PlaceholderItemProxyModel::mapToSource(const QModelIndex& proxyIndex) const
 
147
{
 
148
    if (d->isPlaceholderRow(proxyIndex)) {
 
149
        return QModelIndex();
 
150
    }
 
151
    return KIdentityProxyModel::mapToSource(proxyIndex);
 
152
}
 
153
 
 
154
bool PlaceholderItemProxyModel::setData(const QModelIndex& index, const QVariant& value, int role)
 
155
{
 
156
    const int column = index.column();
 
157
    if (d->isPlaceholderRow(index) && role == Qt::EditRole && d->m_columnHints.contains(column)) {
 
158
        const bool accept = validateRow(index, value);
 
159
        // if validation fails, clear the complete line
 
160
        if (!accept) {
 
161
            emit dataChanged(index, index);
 
162
            return false;
 
163
        }
 
164
 
 
165
        // update view
 
166
        emit dataChanged(index, index);
 
167
 
 
168
        // notify observers
 
169
        emit dataInserted(column, value);
 
170
        return true;
 
171
    }
 
172
    return KIdentityProxyModel::setData(index, value, role);
 
173
}
 
174
 
 
175
QModelIndex PlaceholderItemProxyModel::index(int row, int column, const QModelIndex& parent) const
 
176
{
 
177
    Q_ASSERT(!parent.isValid());
 
178
    Q_UNUSED(parent);
 
179
 
 
180
    const bool isPlaceHolderRow = (sourceModel() ? row == sourceModel()->rowCount() : false);
 
181
    if (isPlaceHolderRow) {
 
182
        return createIndex(row, column);
 
183
    }
 
184
    return KIdentityProxyModel::index(row, column, parent);
 
185
}
 
186
 
 
187
bool PlaceholderItemProxyModel::validateRow(const QModelIndex& index, const QVariant& value) const
 
188
{
 
189
    Q_UNUSED(index);
 
190
    return !value.toString().isEmpty();
 
191
}
 
192
 
 
193
#include "moc_placeholderitemproxymodel.cpp"