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
208
209
210
211
|
// SPDX-License-Identifier: GPL-2.0
#include "command_divesite.h"
#include "core/divesite.h"
#include "core/subsurface-qt/DiveListNotifier.h"
#include "core/qthelper.h"
#include "core/subsurface-string.h"
#include "qt-models/divelocationmodel.h"
namespace Command {
// Helper functions to add / remove a set of dive sites
// Add a set of dive sites to the core. The dives that were associated with
// that dive site will be restored to that dive site.
static std::vector<dive_site *> addDiveSites(std::vector<OwningDiveSitePtr> &sites)
{
std::vector<dive_site *> res;
res.reserve(sites.size());
for (OwningDiveSitePtr &ds: sites) {
// Readd the dives that belonged to this site
for (int i = 0; i < ds->dives.nr; ++i) {
// TODO: send dive site changed signal
ds->dives.dives[i]->dive_site = ds.get();
}
// Add dive site to core, but remember a non-owning pointer first.
res.push_back(ds.get());
int idx = register_dive_site(ds.release()); // Return ownership to backend.
emit diveListNotifier.diveSiteAdded(res.back(), idx); // Inform frontend of new dive site.
}
// Clear vector of unused owning pointers
sites.clear();
return res;
}
// Remove a set of dive sites. Get owning pointers to them. The dives are set to
// being at no dive site, but the dive site will retain a list of dives, so
// that the dives can be readded to the site on undo.
static std::vector<OwningDiveSitePtr> removeDiveSites(std::vector<dive_site *> &sites)
{
std::vector<OwningDiveSitePtr> res;
res.reserve(sites.size());
for (dive_site *ds: sites) {
// Reset the dive_site field of the affected dives
for (int i = 0; i < ds->dives.nr; ++i) {
// TODO: send dive site changed signal
ds->dives.dives[i]->dive_site = nullptr;
}
// Remove dive site from core and take ownership.
int idx = unregister_dive_site(ds);
res.emplace_back(ds);
emit diveListNotifier.diveSiteDeleted(ds, idx); // Inform frontend of removed dive site.
}
sites.clear();
return res;
}
AddDiveSite::AddDiveSite(const QString &name)
{
setText(tr("add dive site"));
sitesToAdd.emplace_back(alloc_dive_site());
sitesToAdd.back()->name = copy_qstring(name);
}
bool AddDiveSite::workToBeDone()
{
return true;
}
void AddDiveSite::redo()
{
sitesToRemove = std::move(addDiveSites(sitesToAdd));
}
void AddDiveSite::undo()
{
sitesToAdd = std::move(removeDiveSites(sitesToRemove));
}
DeleteDiveSites::DeleteDiveSites(const QVector<dive_site *> &sites) : sitesToRemove(sites.toStdVector())
{
setText(tr("delete %n dive site(s)", "", sites.size()));
}
bool DeleteDiveSites::workToBeDone()
{
return !sitesToRemove.empty();
}
void DeleteDiveSites::redo()
{
sitesToAdd = std::move(removeDiveSites(sitesToRemove));
}
void DeleteDiveSites::undo()
{
sitesToRemove = std::move(addDiveSites(sitesToAdd));
}
// Helper function: swap C and Qt string
static void swap(char *&c, QString &q)
{
QString s = c;
free(c);
c = copy_qstring(q);
q = s;
}
EditDiveSiteName::EditDiveSiteName(dive_site *dsIn, const QString &name) : ds(dsIn),
value(name)
{
setText(tr("Edit dive site name"));
}
bool EditDiveSiteName::workToBeDone()
{
return value != QString(ds->name);
}
void EditDiveSiteName::redo()
{
swap(ds->name, value);
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::NAME); // Inform frontend of changed dive site.
}
void EditDiveSiteName::undo()
{
// Undo and redo do the same
redo();
}
EditDiveSiteDescription::EditDiveSiteDescription(dive_site *dsIn, const QString &description) : ds(dsIn),
value(description)
{
setText(tr("Edit dive site description"));
}
bool EditDiveSiteDescription::workToBeDone()
{
return value != QString(ds->description);
}
void EditDiveSiteDescription::redo()
{
swap(ds->description, value);
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::DESCRIPTION); // Inform frontend of changed dive site.
}
void EditDiveSiteDescription::undo()
{
// Undo and redo do the same
redo();
}
EditDiveSiteNotes::EditDiveSiteNotes(dive_site *dsIn, const QString ¬es) : ds(dsIn),
value(notes)
{
setText(tr("Edit dive site notes"));
}
bool EditDiveSiteNotes::workToBeDone()
{
return value != QString(ds->notes);
}
void EditDiveSiteNotes::redo()
{
swap(ds->notes, value);
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::NOTES); // Inform frontend of changed dive site.
}
void EditDiveSiteNotes::undo()
{
// Undo and redo do the same
redo();
}
EditDiveSiteCountry::EditDiveSiteCountry(dive_site *dsIn, const QString &country) : ds(dsIn),
value(country)
{
setText(tr("Edit dive site country"));
}
bool EditDiveSiteCountry::workToBeDone()
{
return !same_string(qPrintable(value), taxonomy_get_country(&ds->taxonomy));
}
void EditDiveSiteCountry::redo()
{
QString old = taxonomy_get_country(&ds->taxonomy);
taxonomy_set_country(&ds->taxonomy, copy_qstring(value), taxonomy_origin::GEOMANUAL);
value = old;
emit diveListNotifier.diveSiteChanged(ds, LocationInformationModel::TAXONOMY); // Inform frontend of changed dive site.
}
void EditDiveSiteCountry::undo()
{
// Undo and redo do the same
redo();
}
} // namespace Command
|
