treemodel.h 6.58 KB
Newer Older
hjk's avatar
hjk committed
1
2
3
4
5
6
7
8
9
10
11
12
/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of Qt Creator.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
Eike Ziller's avatar
Eike Ziller committed
13
14
** conditions see http://www.qt.io/licensing.  For further information
** use the contact form at http://www.qt.io/contact-us.
hjk's avatar
hjk committed
15
16
17
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
Eike Ziller's avatar
Eike Ziller committed
18
19
20
21
22
23
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file.  Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
hjk's avatar
hjk committed
24
25
26
27
28
29
30
31
32
33
34
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/

#ifndef UTILS_TREEMODEL_H
#define UTILS_TREEMODEL_H

#include "utils_global.h"
hjk's avatar
hjk committed
35
#include "algorithm.h"
hjk's avatar
hjk committed
36
37
38

#include <QAbstractItemModel>

hjk's avatar
hjk committed
39
40
41
#include <functional>
#include <iterator>

hjk's avatar
hjk committed
42
43
44
45
46
47
namespace Utils {

class QTCREATOR_UTILS_EXPORT TreeItem
{
public:
    TreeItem();
48
    explicit TreeItem(const QStringList &displays);
hjk's avatar
hjk committed
49
50
51
52
53
54
55
56
57
58
59
60
61
62
    virtual ~TreeItem();

    virtual TreeItem *parent() const { return m_parent; }
    virtual TreeItem *child(int pos) const;
    virtual bool isLazy() const;
    virtual int columnCount() const;
    virtual int rowCount() const;
    virtual void populate();

    virtual QVariant data(int column, int role) const;
    virtual Qt::ItemFlags flags(int column) const;

    void prependChild(TreeItem *item);
    void appendChild(TreeItem *item);
63
64
    TreeItem *lastChild() const;
    int level() const;
hjk's avatar
hjk committed
65
66
67
68

    void setLazy(bool on);
    void setPopulated(bool on);
    void setFlags(Qt::ItemFlags flags);
69
    QVector<TreeItem *> children() const { return m_children; }
hjk's avatar
hjk committed
70
71
72
73
74
75
76
77
78
79

private:
    TreeItem(const TreeItem &) Q_DECL_EQ_DELETE;
    void operator=(const TreeItem &) Q_DECL_EQ_DELETE;

    void clear();
    void ensurePopulated() const;

    TreeItem *m_parent; // Not owned.
    QVector<TreeItem *> m_children; // Owned.
80
    QStringList *m_displays;
hjk's avatar
hjk committed
81
82
83
    bool m_lazy;
    mutable bool m_populated;
    Qt::ItemFlags m_flags;
84
85

    friend class TreeModel;
hjk's avatar
hjk committed
86
87
};

hjk's avatar
hjk committed
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
class QTCREATOR_UTILS_EXPORT UntypedTreeLevelItems
{
public:
    explicit UntypedTreeLevelItems(TreeItem *item, int level = 1);

    typedef TreeItem *value_type;

    class const_iterator
    {
    public:
        typedef std::forward_iterator_tag iterator_category;
        typedef TreeItem *value_type;
        typedef std::ptrdiff_t difference_type;
        typedef const value_type *pointer;
        typedef const value_type &reference;

        const_iterator(TreeItem *base, int level);

        TreeItem *operator*() { return m_item[m_depth]; }
        void operator++();

        bool operator==(const_iterator other) const;
        bool operator!=(const_iterator other) const { return !operator==(other); }

    private:
        void goDown();
        void goUpNextDown();

        int m_level;
        int m_depth;
        TreeItem *m_item[8];
        int m_pos[8];
        int m_size[8];
    };

    const_iterator begin() const;
    const_iterator end() const;

private:
    TreeItem *m_item;
    int m_level;
};

template <class T>
class QTCREATOR_UTILS_EXPORT TreeLevelItems
{
public:
    typedef T value_type;

    explicit TreeLevelItems(const UntypedTreeLevelItems &items) : m_items(items) {}

    struct const_iterator : public UntypedTreeLevelItems::const_iterator
    {
        typedef std::forward_iterator_tag iterator_category;
        typedef T value_type;
        typedef std::ptrdiff_t difference_type;
        typedef const value_type *pointer;
        typedef const value_type &reference;

        const_iterator(UntypedTreeLevelItems::const_iterator it) : UntypedTreeLevelItems::const_iterator(it) {}
        T operator*() { return static_cast<T>(UntypedTreeLevelItems::const_iterator::operator*()); }
    };

    const_iterator begin() const { return const_iterator(m_items.begin()); }
    const_iterator end() const { return const_iterator(m_items.end()); }

private:
    UntypedTreeLevelItems m_items;
};

hjk's avatar
hjk committed
158
159
160
161
162
163
164
165
166
167
168
169
170
class QTCREATOR_UTILS_EXPORT TreeModel : public QAbstractItemModel
{
public:
    explicit TreeModel(QObject *parent = 0);
    virtual ~TreeModel();

    int rowCount(const QModelIndex &idx = QModelIndex()) const;
    int columnCount(const QModelIndex &idx) const;

    QVariant data(const QModelIndex &idx, int role) const;
    QModelIndex index(int, int, const QModelIndex &idx) const;
    QModelIndex parent(const QModelIndex &idx) const;
    Qt::ItemFlags flags(const QModelIndex &idx) const;
hjk's avatar
hjk committed
171
    QVariant headerData(int section, Qt::Orientation orientation, int role) const;
hjk's avatar
hjk committed
172
173

    TreeItem *rootItem() const;
hjk's avatar
hjk committed
174
    void setRootItem(TreeItem *item);
hjk's avatar
hjk committed
175
176
177
    TreeItem *itemFromIndex(const QModelIndex &) const;
    QModelIndex indexFromItem(const TreeItem *needle) const;

178
179
180
181
    void appendItem(TreeItem *parent, TreeItem *item);
    void removeItem(TreeItem *item); // item is not destroyed.
    void updateItem(TreeItem *item); // call to trigger dataChanged

hjk's avatar
hjk committed
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
    UntypedTreeLevelItems untypedLevelItems(int level = 0, TreeItem *start = 0) const;
    UntypedTreeLevelItems untypedLevelItems(TreeItem *start) const;

    template <class T>
    TreeLevelItems<T> treeLevelItems(int level, TreeItem *start = 0) const
    {
        return TreeLevelItems<T>(untypedLevelItems(level, start));
    }

    template <class T>
    TreeLevelItems<T> treeLevelItems(TreeItem *start) const
    {
        return TreeLevelItems<T>(untypedLevelItems(start));
    }

    template <class T>
    T findItemAtLevel(int level, std::function<bool(T)> f, TreeItem *start = 0) const
    {
        return Utils::findOrDefault(treeLevelItems<T>(level, start), f);
    }

hjk's avatar
hjk committed
203
204
205
206
207
208
209
210
211
212
213
214
private:
    QModelIndex indexFromItemHelper(const TreeItem *needle,
        TreeItem *parentItem, const QModelIndex &parentIndex) const;

    void checkIndex(const QModelIndex &index) const;

    TreeItem *m_root; // Owned.
};

} // namespace Utils

#endif // UTILS_TREEMODEL_H