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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#ifndef QABSTRACTITEMMODEL_P_H
#define QABSTRACTITEMMODEL_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of QAbstractItemModel*. This header file may change from version
// to version without notice, or even be removed.
//
// We mean it.
//
//
#include "QtCore/qabstractitemmodel.h"
#include "QtCore/private/qobject_p.h"
#include "QtCore/qstack.h"
#include "QtCore/qset.h"
#include "QtCore/qhash.h"
QT_BEGIN_NAMESPACE
QT_REQUIRE_CONFIG(itemmodel);
class QPersistentModelIndexData
{
public:
QPersistentModelIndexData() {}
QPersistentModelIndexData(const QModelIndex &idx) : index(idx) {}
QModelIndex index;
QAtomicInt ref;
static QPersistentModelIndexData *create(const QModelIndex &index);
static void destroy(QPersistentModelIndexData *data);
};
class Q_CORE_EXPORT QAbstractItemModelPrivate : public QObjectPrivate
{
Q_DECLARE_PUBLIC(QAbstractItemModel)
public:
QAbstractItemModelPrivate();
~QAbstractItemModelPrivate();
void removePersistentIndexData(QPersistentModelIndexData *data);
void movePersistentIndexes(const QList<QPersistentModelIndexData *> &indexes, int change, const QModelIndex &parent,
Qt::Orientation orientation);
void rowsAboutToBeInserted(const QModelIndex &parent, int first, int last);
void rowsInserted(const QModelIndex &parent, int first, int last);
void rowsAboutToBeRemoved(const QModelIndex &parent, int first, int last);
void rowsRemoved(const QModelIndex &parent, int first, int last);
void columnsAboutToBeInserted(const QModelIndex &parent, int first, int last);
void columnsInserted(const QModelIndex &parent, int first, int last);
void columnsAboutToBeRemoved(const QModelIndex &parent, int first, int last);
void columnsRemoved(const QModelIndex &parent, int first, int last);
static QAbstractItemModel *staticEmptyModel();
static bool variantLessThan(const QVariant &v1, const QVariant &v2);
void itemsAboutToBeMoved(const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation);
void itemsMoved(const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation orientation);
bool allowMove(const QModelIndex &srcParent, int srcFirst, int srcLast, const QModelIndex &destinationParent, int destinationChild, Qt::Orientation orientation);
// ugly hack for QTreeModel, see QTBUG-94546
virtual void executePendingOperations() const;
inline QModelIndex createIndex(int row, int column, void *data = nullptr) const {
return q_func()->createIndex(row, column, data);
}
inline QModelIndex createIndex(int row, int column, int id) const {
return q_func()->createIndex(row, column, id);
}
inline bool indexValid(const QModelIndex &index) const {
return (index.row() >= 0) && (index.column() >= 0) && (index.model() == q_func());
}
void invalidatePersistentIndexes();
void invalidatePersistentIndex(const QModelIndex &index);
struct Change {
constexpr Change() : parent(), first(-1), last(-1), needsAdjust(false) {}
constexpr Change(const QModelIndex &p, int f, int l) : parent(p), first(f), last(l), needsAdjust(false) {}
QModelIndex parent;
int first, last;
// In cases such as this:
// - A
// - B
// - C
// - - D
// - - E
// - - F
//
// If B is moved to above E, C is the source parent in the signal and its row is 2. When the move is
// completed however, C is at row 1 and there is no row 2 at the same level in the model at all.
// The QModelIndex is adjusted to correct that in those cases before reporting it though the
// rowsMoved signal.
bool needsAdjust;
constexpr bool isValid() const { return first >= 0 && last >= 0; }
};
QStack<Change> changes;
struct Persistent {
Persistent() {}
QMultiHash<QModelIndex, QPersistentModelIndexData *> indexes;
QStack<QList<QPersistentModelIndexData *>> moved;
QStack<QList<QPersistentModelIndexData *>> invalidated;
void insertMultiAtEnd(const QModelIndex& key, QPersistentModelIndexData *data);
} persistent;
static const QHash<int,QByteArray> &defaultRoleNames();
static bool isVariantLessThan(const QVariant &left, const QVariant &right,
Qt::CaseSensitivity cs = Qt::CaseSensitive, bool isLocaleAware = false);
};
Q_DECLARE_TYPEINFO(QAbstractItemModelPrivate::Change, Q_RELOCATABLE_TYPE);
namespace QtPrivate {
/*!
\internal
This is a workaround for QTBUG-75172.
Some predefined model roles are supposed to use certain enum/flag
types (e.g. fetching Qt::TextAlignmentRole is supposed to return a
variant containing a Qt::Alignment object).
For historical reasons, a plain `int` was used sometimes. This is
surprising to end-users and also sloppy on Qt's part; users were
forced to use `int` rather than the correct datatype.
This function tries both the "right" type and plain `int`, for a
given QVariant. This fixes the problem (using the correct datatype)
but also keeps compatibility with existing code using `int`.
### Qt 7: get rid of this. Always use the correct datatype.
*/
template <typename T>
T legacyEnumValueFromModelData(const QVariant &data)
{
static_assert(std::is_enum_v<T>);
if (data.userType() == qMetaTypeId<T>()) {
return data.value<T>();
} else if (std::is_same_v<std::underlying_type_t<T>, int> ||
std::is_same_v<std::underlying_type_t<T>, uint>) {
return T(data.toInt());
}
return T();
}
template <typename T>
T legacyFlagValueFromModelData(const QVariant &data)
{
if (data.userType() == qMetaTypeId<T>()) {
return data.value<T>();
} else if (std::is_same_v<std::underlying_type_t<typename T::enum_type>, int> ||
std::is_same_v<std::underlying_type_t<typename T::enum_type>, uint>) {
return T::fromInt(data.toInt());
}
return T();
}
} // namespace QtPrivate
QT_END_NAMESPACE
#endif // QABSTRACTITEMMODEL_P_H
|
