blob: f10da04d90ebb5202a1f949a1ec81fee7b23ee1e (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
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
158
159
160
|
/*********
*
* In the name of the Father, and of the Son, and of the Holy Spirit.
*
* This file is part of BibleTime's source code, http://www.bibletime.info/.
*
* Copyright 1999-2009 by the BibleTime developers.
* The BibleTime source code is licensed under the GNU General Public License
* version 2.0.
*
**********/
#ifndef ITEM_H
#define ITEM_H
#include <QIcon>
#include <QList>
#include <QString>
#include <QtGlobal>
#include <QVariant>
class CSwordModuleInfo;
namespace BookshelfModel {
class Item {
public:
enum Type {
ITEM_ROOT = 0,
ITEM_CATEGORY = 1,
ITEM_LANGUAGE = 2,
ITEM_MODULE = 3,
ITEM_INDEXING = 4
};
Item(Type type);
virtual ~Item();
/**
\brief Returns the type of this item.
*/
inline Type type() const {
return m_type;
}
/**
\brief Returns a pointer to the parent item of this item.
\retval 0 if this item has no parent.
*/
inline Item *parent() const {
return m_parent;
}
/**
\brief Returns the list of child items of this node.
*/
inline QList<Item*> &children() {
return m_children;
}
/**
\brief Returns the index of this item under its parent.
\retval -1 if this item has no parent.
*/
inline int childIndex() const {
if (m_parent == 0) return -1;
return m_parent->m_children.indexOf(const_cast<Item*>(this));
}
/**
\brief Returns the position for where the given child item would be
inserted.
\param[in] newItem Pointer to the item that would be inserted.
*/
int indexFor(Item *newItem);
/**
\brief Inserts the given item as a child at the given index.
\pre The given index is a valid position for the item.
\param[in] index The child index to insert the item at.
\param[in] newItem The item to insert.
*/
inline void insertChild(int index, Item *newItem) {
Q_ASSERT(newItem != 0);
Q_ASSERT(index >= 0 && index <= m_children.size());
m_children.insert(index, newItem);
newItem->setParent(this);
}
template <class T>
T *getGroupItem(CSwordModuleInfo *module, int &outIndex) {
for (int i(0); i < m_children.size(); i++) {
Q_ASSERT(m_children.at(i)->type() == T::GROUP_TYPE);
T *item(static_cast<T*>(m_children.at(i)));
if (item->fitFor(module)) {
outIndex = i;
return item;
}
}
return 0;
}
/**
\brief Returns data for this item.
*/
virtual QVariant data(int role = Qt::DisplayRole) const;
/**
\brief Returns the check state of this item.
*/
inline Qt::CheckState checkState() const {
return m_checkState;
}
/**
\brief Sets the check state of this item.
\param[in] state new check state.
*/
inline void setCheckState(const Qt::CheckState state) {
m_checkState = state;
}
/**
\brief Returns whether this item is fit to contain the given module.
\param[in] module The module to check with.
\retval true If this item is a group and can contain the given module.
\retval false This item is not a group or is a wrong group.
*/
inline virtual bool fitFor(CSwordModuleInfo *module) const {
Q_UNUSED(module);
return false;
}
/**
\brief Comparsion operator used sorting child items.
*/
virtual bool operator<(const Item &other) const;
protected:
inline void setParent(Item *parent) {
Q_ASSERT(parent != 0);
m_parent = parent;
}
protected:
Type m_type;
Item *m_parent;
QList<Item*> m_children;
Qt::CheckState m_checkState;
};
class RootItem: public Item {
public:
inline RootItem() : Item(Item::ITEM_ROOT) {}
};
} // Namespace BookshelfModel
#endif // ITEM_H
|
