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
|
// SPDX-License-Identifier: GPL-2.0
// Note: this header file is used by the undo-machinery and should not be included elsewhere.
#ifndef COMMAND_DIVELIST_H
#define COMMAND_DIVELIST_H
#include "command_base.h"
#include <QVector>
// We put everything in a namespace, so that we can shorten names without polluting the global namespace
namespace Command {
// This helper structure describes a dive that we want to add.
// Potentially it also adds a trip (if deletion of the dive resulted in deletion of the trip)
struct DiveToAdd {
OwningDivePtr dive; // Dive to add
OwningTripPtr tripToAdd; // Not-null if we also have to add a dive
dive_trip *trip; // Trip the dive belongs to, may be null
int idx; // Position in divelist
};
// This helper structure describes a dive that should be moved to / removed from
// a trip. If the "trip" member is null, the dive is removed from its trip (if
// it is in a trip, that is)
struct DiveToTrip
{
struct dive *dive;
dive_trip *trip;
};
// This helper structure describes a number of dives to add to /remove from /
// move between trips.
// It has ownership of the trips (if any) that have to be added before hand.
struct DivesToTrip
{
std::vector<DiveToTrip> divesToMove; // If dive_trip is null, remove from trip
std::vector<OwningTripPtr> tripsToAdd;
};
class AddDive : public Base {
public:
AddDive(dive *dive, bool autogroup);
private:
void undo() override;
void redo() override;
bool workToBeDone() override;
// For redo
// Note: we use a vector even though we add only a single dive, so
// that we can reuse the multi-dive functions of the other commands.
std::vector<DiveToAdd> divesToAdd;
// For undo
std::vector<dive *> divesToRemove;
};
class DeleteDive : public Base {
public:
DeleteDive(const QVector<dive *> &divesToDelete);
private:
void undo() override;
void redo() override;
bool workToBeDone() override;
// For redo
std::vector<struct dive*> divesToDelete;
std::vector<OwningTripPtr> tripsToAdd;
std::vector<DiveToAdd> divesToAdd;
};
class ShiftTime : public Base {
public:
ShiftTime(const QVector<dive *> &changedDives, int amount);
private:
void undo() override;
void redo() override;
bool workToBeDone() override;
// For redo and undo
QVector<dive *> diveList;
int timeChanged;
};
class RenumberDives : public Base {
public:
RenumberDives(const QVector<QPair<dive *, int>> &divesToRenumber);
private:
void undo() override;
void redo() override;
bool workToBeDone() override;
// For redo and undo: pairs of dive-id / new number
QVector<QPair<dive *, int>> divesToRenumber;
};
// The classes RemoveDivesFromTrip, RemoveAutogenTrips, CreateTrip, AutogroupDives
// and MergeTrips all do the same thing, just the intialization differs.
// Therefore, define a base class with the proper data-structures, redo()
// and undo() functions and derive to specialize the initialization.
class TripBase : public Base {
protected:
void undo() override;
void redo() override;
bool workToBeDone() override;
// For redo and undo
DivesToTrip divesToMove;
};
struct RemoveDivesFromTrip : public TripBase {
RemoveDivesFromTrip(const QVector<dive *> &divesToRemove);
};
struct RemoveAutogenTrips : public TripBase {
RemoveAutogenTrips();
};
struct AddDivesToTrip : public TripBase {
AddDivesToTrip(const QVector<dive *> &divesToAdd, dive_trip *trip);
};
struct CreateTrip : public TripBase {
CreateTrip(const QVector<dive *> &divesToAdd);
};
struct AutogroupDives : public TripBase {
AutogroupDives();
};
struct MergeTrips : public TripBase {
MergeTrips(dive_trip *trip1, dive_trip *trip2);
};
class SplitDives : public Base {
public:
// If time is < 0, split at first surface interval
SplitDives(dive *d, duration_t time);
private:
void undo() override;
void redo() override;
bool workToBeDone() override;
// For redo
// For each dive to split, we remove one from and put two dives into the backend
dive *diveToSplit;
DiveToAdd splitDives[2];
// For undo
// For each dive to unsplit, we remove two dives from and add one into the backend
DiveToAdd unsplitDive;
dive *divesToUnsplit[2];
};
class MergeDives : public Base {
public:
MergeDives(const QVector<dive *> &dives);
private:
void undo() override;
void redo() override;
bool workToBeDone() override;
// For redo
// Add one and remove a batch of dives
DiveToAdd mergedDive;
std::vector<dive *> divesToMerge;
// For undo
// Remove one and add a batch of dives
dive *diveToUnmerge;
std::vector<DiveToAdd> unmergedDives;
// For undo and redo
QVector<QPair<dive *, int>> divesToRenumber;
};
} // namespace Command
#endif // COMMAND_DIVELIST_H
|
