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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
// SPDX-License-Identifier: GPL-2.0
#ifndef DIVETRIPMODEL_H
#define DIVETRIPMODEL_H
#include "core/dive.h"
#include "core/subsurface-qt/DiveListNotifier.h"
#include <QAbstractItemModel>
struct DiveFilter;
// There are two different representations of the dive list:
// 1) Tree view: two-level model where dives are grouped by trips
// 2) List view: one-level model where dives are sorted by one out
// of many keys (e.g. date, depth, etc.).
//
// These two representations are realized by two classes, viz.
// DiveTripModelTree and DiveTripModelList. Both classes derive
// from DiveTripModelBase, which implements common features (e.g.
// definition of the column types, access of data from the core
// structures) and a common interface.
//
// The currently active model is set via DiveTripModelBase::resetModel().
// This will create a new model. The model can be accessed with
// DiveTripModelBase::instance(). A pointer obtained by instance()
// is invalidated by a call to resetModel()! Yes, this is surprising
// behavior, so care must be taken.
class DiveTripModelBase : public QAbstractItemModel {
Q_OBJECT
public:
enum Column {
NR,
DATE,
RATING,
DEPTH,
DURATION,
TEMPERATURE,
TOTALWEIGHT,
SUIT,
CYLINDER,
GAS,
SAC,
OTU,
MAXCNS,
TAGS,
PHOTOS,
BUDDIES,
COUNTRY,
LOCATION,
COLUMNS
};
enum ExtraRoles {
STAR_ROLE = Qt::UserRole + 1,
IS_TRIP_ROLE,
DIVE_ROLE,
TRIP_ROLE,
DIVE_IDX,
SHOWN_ROLE,
SELECTED_ROLE
};
enum Layout {
TREE,
LIST,
};
// Functions implemented by base class
static DiveTripModelBase *instance();
// Reset the model using the given layout. After this call instance() will return
// a newly allocated object and the old model will have been destroyed! Thus, the
// caller is responsible for removing all references to any previous model obtained
// by instance().
static void resetModel(Layout layout);
// Call after having set the model to be informed of the current selection.
void initSelection();
// Clear all dives
void clear();
Qt::ItemFlags flags(const QModelIndex &index) const;
QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
DiveTripModelBase(QObject *parent = 0);
int columnCount(const QModelIndex&) const;
virtual void recalculateFilter() = 0;
// Used for sorting. This is a bit of a layering violation, as sorting should be performed
// by the higher-up QSortFilterProxyModel, but it makes things so much easier!
virtual bool lessThan(const QModelIndex &i1, const QModelIndex &i2) const = 0;
signals:
// The propagation of selection changes is complex.
// The control flow of dive-selection goes:
// Commands/DiveListNotifier ---(dive */dive_trip *)---> DiveTripModel ---(QModelIndex)---> DiveListView
// i.e. The command objects send changes in terms of pointer-to-dives, which the DiveTripModel transforms
// into QModelIndexes according to the current view (tree/list). Finally, the DiveListView transforms these
// indexes into local indexes according to current sorting/filtering and instructs the QSelectionModel to
// perform the appropriate actions.
void selectionChanged(const QVector<QModelIndex> &indexes);
void currentDiveChanged(QModelIndex index);
protected:
// Access trip and dive data
static QVariant diveData(const struct dive *d, int column, int role);
static QVariant tripData(const dive_trip *trip, int column, int role);
void sendShownChangedSignals(const std::vector<char> &changed, quintptr parentIndex);
virtual dive *diveOrNull(const QModelIndex &index) const = 0; // Returns a dive if this index represents a dive, null otherwise
virtual void clearData() = 0;
};
class DiveTripModelTree : public DiveTripModelBase
{
Q_OBJECT
public slots:
void divesAdded(dive_trip *trip, bool addTrip, const QVector<dive *> &dives);
void divesDeleted(dive_trip *trip, bool deleteTrip, const QVector<dive *> &dives);
void divesMovedBetweenTrips(dive_trip *from, dive_trip *to, bool deleteFrom, bool createTo, const QVector<dive *> &dives);
void diveSiteChanged(dive_site *ds, int field);
void divesChanged(const QVector<dive *> &dives);
void divesTimeChanged(timestamp_t delta, const QVector<dive *> &dives);
void divesSelected(const QVector<dive *> &dives, dive *current);
void tripChanged(dive_trip *trip, TripField);
public:
DiveTripModelTree(QObject *parent = nullptr);
private:
int rowCount(const QModelIndex &parent) const override;
void clearData() override;
QModelIndex index(int row, int column, const QModelIndex &parent) const override;
QModelIndex parent(const QModelIndex &index) const override;
QVariant data(const QModelIndex &index, int role) const override;
bool lessThan(const QModelIndex &i1, const QModelIndex &i2) const override;
void divesSelectedTrip(dive_trip *trip, const QVector<dive *> &dives, QVector<QModelIndex> &);
dive *diveOrNull(const QModelIndex &index) const override;
void recalculateFilter();
void divesChangedTrip(dive_trip *trip, const QVector<dive *> &dives);
void divesTimeChangedTrip(dive_trip *trip, timestamp_t delta, const QVector<dive *> &dives);
bool calculateFilterForTrip(const std::vector<dive *> &dives, const DiveFilter *filter, quintptr parentIndex);
// The tree model has two levels. At the top level, we have either trips or dives
// that do not belong to trips. Such a top-level item is represented by the "Item"
// struct, which is based on the dive_or_trip structure.
// If it is a trip, additionally, the dives are collected in a vector.
// The items are ordered chronologically according to the dive_or_trip_less_than()
// function, which guarantees a stable ordering even in the case of equal timestamps.
// For dives and trips, it place dives chronologically after trips, so that in
// the default-descending view they are shown before trips.
struct Item {
dive_or_trip d_or_t;
std::vector<dive *> dives; // std::vector<> instead of QVector for insert() with three iterators
bool shown;
Item(dive_trip *t, const QVector<dive *> &dives);
Item(dive_trip *t, dive *d); // Initialize a trip with one dive
Item(dive *d); // Initialize a top-level dive
bool isDive(const dive *) const; // Helper function: is this the give dive?
dive *getDive() const; // Helper function: returns top-level-dive or null
timestamp_t when() const; // Helper function: start time of dive *or* trip
};
std::vector<Item> items; // Use std::vector for convenience of emplace_back()
dive_or_trip tripOrDive(const QModelIndex &index) const;
// Returns either a pointer to a trip or a dive, or twice null of index is invalid
// null, something is really wrong
// Addition and deletion of dives
void addDivesToTrip(int idx, const QVector<dive *> &dives);
void topLevelChanged(int idx);
// Access trips and dives
int findTripIdx(const dive_trip *trip) const;
int findDiveIdx(const dive *d) const; // Find _top_level_ dive
int findDiveInTrip(int tripIdx, const dive *d) const; // Find dive inside trip. Second parameter is index of trip
int findInsertionIndex(const dive_trip *trip) const; // Where to insert trip
// Comparison function between dive and arbitrary entry
static bool dive_before_entry(const dive *d, const Item &entry);
};
class DiveTripModelList : public DiveTripModelBase
{
Q_OBJECT
public slots:
void divesAdded(dive_trip *trip, bool addTrip, const QVector<dive *> &dives);
void divesDeleted(dive_trip *trip, bool deleteTrip, const QVector<dive *> &dives);
void diveSiteChanged(dive_site *ds, int field);
void divesChanged(const QVector<dive *> &dives);
void divesTimeChanged(timestamp_t delta, const QVector<dive *> &dives);
// Does nothing in list view.
//void divesMovedBetweenTrips(dive_trip *from, dive_trip *to, bool deleteFrom, bool createTo, const QVector<dive *> &dives);
void divesSelected(const QVector<dive *> &dives, dive *current);
public:
DiveTripModelList(QObject *parent = nullptr);
private:
int rowCount(const QModelIndex &parent) const override;
void clearData() override;
QModelIndex index(int row, int column, const QModelIndex &parent) const override;
QModelIndex parent(const QModelIndex &index) const override;
QVariant data(const QModelIndex &index, int role) const override;
bool lessThan(const QModelIndex &i1, const QModelIndex &i2) const override;
dive *diveOrNull(const QModelIndex &index) const override;
void recalculateFilter();
std::vector<dive *> items; // TODO: access core data directly
};
#endif
|
