summaryrefslogtreecommitdiffstats
path: root/desktop-widgets
diff options
context:
space:
mode:
Diffstat (limited to 'desktop-widgets')
-rw-r--r--desktop-widgets/divelistview.cpp6
-rw-r--r--desktop-widgets/simplewidgets.cpp10
-rw-r--r--desktop-widgets/undocommands.cpp178
-rw-r--r--desktop-widgets/undocommands.h192
4 files changed, 266 insertions, 120 deletions
diff --git a/desktop-widgets/divelistview.cpp b/desktop-widgets/divelistview.cpp
index fbcd96fd6..945a7381e 100644
--- a/desktop-widgets/divelistview.cpp
+++ b/desktop-widgets/divelistview.cpp
@@ -679,10 +679,10 @@ void DiveListView::removeFromTrip()
//TODO: move this to C-code.
int i;
struct dive *d;
- QMap<struct dive*, dive_trip*> divesToRemove;
+ QVector<struct dive *> divesToRemove;
for_each_dive (i, d) {
if (d->selected && d->divetrip)
- divesToRemove.insert(d, d->divetrip);
+ divesToRemove.append(d);
}
if (divesToRemove.isEmpty())
return;
@@ -797,7 +797,7 @@ void DiveListView::deleteDive()
int i;
int lastDiveNr = -1;
- QList<struct dive*> deletedDives; //a list of all deleted dives to be stored in the undo command
+ QVector<struct dive*> deletedDives; //a list of all deleted dives to be stored in the undo command
for_each_dive (i, d) {
if (!d->selected)
continue;
diff --git a/desktop-widgets/simplewidgets.cpp b/desktop-widgets/simplewidgets.cpp
index 64845712d..25345551a 100644
--- a/desktop-widgets/simplewidgets.cpp
+++ b/desktop-widgets/simplewidgets.cpp
@@ -160,15 +160,15 @@ void RenumberDialog::buttonClicked(QAbstractButton *button)
{
if (ui.buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole) {
MainWindow::instance()->dive_list()->rememberSelection();
- // we remember a map from dive uuid to a pair of old number / new number
- QMap<int, QPair<int, int>> renumberedDives;
+ // we remember a list from dive uuid to a new number
+ QVector<QPair<int, int>> renumberedDives;
int i;
int newNr = ui.spinBox->value();
struct dive *dive = NULL;
for_each_dive (i, dive) {
if (!selectedOnly || dive->selected) {
invalidate_dive_cache(dive);
- renumberedDives.insert(dive->id, QPair<int, int>(dive->number, newNr++));
+ renumberedDives.append(QPair<int, int>(dive->id, newNr++));
}
}
UndoRenumberDives *undoCommand = new UndoRenumberDives(renumberedDives);
@@ -241,7 +241,7 @@ void ShiftTimesDialog::buttonClicked(QAbstractButton *button)
// DANGER, DANGER - this could get our dive_table unsorted...
int i;
struct dive *dive;
- QList<int> affectedDives;
+ QVector<int> affectedDives;
for_each_dive (i, dive) {
if (!dive->selected)
continue;
@@ -249,8 +249,6 @@ void ShiftTimesDialog::buttonClicked(QAbstractButton *button)
affectedDives.append(dive->id);
}
MainWindow::instance()->undoStack->push(new UndoShiftTime(affectedDives, amount));
- sort_table(&dive_table);
- mark_divelist_changed(true);
MainWindow::instance()->dive_list()->rememberSelection();
MainWindow::instance()->refreshDisplay();
MainWindow::instance()->dive_list()->restoreSelection();
diff --git a/desktop-widgets/undocommands.cpp b/desktop-widgets/undocommands.cpp
index 06879eb51..d58ac7a4b 100644
--- a/desktop-widgets/undocommands.cpp
+++ b/desktop-widgets/undocommands.cpp
@@ -3,170 +3,156 @@
#include "desktop-widgets/mainwindow.h"
#include "core/divelist.h"
#include "core/subsurface-string.h"
+#include "core/gettextfromc.h"
-UndoDeleteDive::UndoDeleteDive(QList<dive *> deletedDives) : diveList(deletedDives)
+UndoDeleteDive::UndoDeleteDive(const QVector<struct dive*> &divesToDeleteIn) : divesToDelete(divesToDeleteIn)
{
- setText("delete dive");
- if (diveList.count() > 1)
- setText(QString("delete %1 dives").arg(QString::number(diveList.count())));
+ setText(tr("delete %n dive(s)", "", divesToDelete.size()));
}
void UndoDeleteDive::undo()
{
// first bring back the trip(s)
- Q_FOREACH(struct dive_trip *trip, tripList)
- insert_trip(&trip);
+ for (auto &trip: tripsToAdd) {
+ dive_trip *t = trip.release(); // Give up ownership
+ insert_trip(&t); // Return ownership to backend
+ }
+ tripsToAdd.clear();
- // now walk the list of deleted dives
- for (int i = 0; i < diveList.count(); i++) {
- struct dive *d = diveList.at(i);
- // we adjusted the divetrip to point to the "new" divetrip
- if (d->divetrip) {
- struct dive_trip *trip = d->divetrip;
- tripflag_t tripflag = d->tripflag; // this gets overwritten in add_dive_to_trip()
- d->divetrip = NULL;
- d->next = NULL;
- d->pprev = NULL;
- add_dive_to_trip(d, trip);
- d->tripflag = tripflag;
- }
- record_dive(diveList.at(i));
+ for (DiveToAdd &d: divesToAdd) {
+ if (d.trip)
+ add_dive_to_trip(d.dive.get(), d.trip);
+ divesToDelete.append(d.dive.get()); // Delete dive on redo
+ add_single_dive(d.idx, d.dive.release()); // Return ownership to backend
}
mark_divelist_changed(true);
- tripList.clear();
+ divesToAdd.clear();
+
+ // Finally, do the UI stuff:
MainWindow::instance()->refreshDisplay();
}
void UndoDeleteDive::redo()
{
- QList<struct dive*> newList;
- for (int i = 0; i < diveList.count(); i++) {
- // make a copy of the dive before deleting it
- struct dive* d = alloc_dive();
- copy_dive(diveList.at(i), d);
- newList.append(d);
- // check for trip - if this is the last dive in the trip
- // the trip will get deleted, so we need to remember it as well
- if (d->divetrip && d->divetrip->nrdives == 1) {
- dive_trip *undo_trip = clone_empty_trip(d->divetrip);
- // update all the dives who were in this trip to point to the copy of the
- // trip that we are about to delete implicitly when deleting its last dive below
- Q_FOREACH(struct dive *inner_dive, newList) {
- if (inner_dive->divetrip == d->divetrip)
- inner_dive->divetrip = undo_trip;
- }
- d->divetrip = undo_trip;
- tripList.append(undo_trip);
+ for (dive *d: divesToDelete) {
+ int idx = get_divenr(d);
+ if (idx < 0) {
+ qWarning() << "Deletion of unknown dive!";
+ continue;
+ }
+ // remove dive from trip - if this is the last dive in the trip
+ // remove the whole trip.
+ dive_trip *trip = unregister_dive_from_trip(d, false);
+ if (trip && trip->nrdives == 0) {
+ unregister_trip(trip); // Remove trip from backend
+ tripsToAdd.emplace_back(trip); // Take ownership of trip
}
- //delete the dive
- int nr;
- if ((nr = get_divenr(diveList.at(i))) >= 0)
- delete_single_dive(nr);
+
+ unregister_dive(idx); // Remove dive from backend
+ divesToAdd.push_back({ OwningDivePtr(d), trip, idx });
+ // Take ownership for dive
}
+ divesToDelete.clear();
mark_divelist_changed(true);
+
+ // Finally, do the UI stuff:
MainWindow::instance()->refreshDisplay();
- diveList.clear();
- diveList = newList;
}
-UndoShiftTime::UndoShiftTime(QList<int> changedDives, int amount)
+UndoShiftTime::UndoShiftTime(QVector<int> changedDives, int amount)
: diveList(changedDives), timeChanged(amount)
{
- setText("shift time");
+ setText(tr("delete %n dive(s)", "", changedDives.size()));
}
void UndoShiftTime::undo()
{
for (int i = 0; i < diveList.count(); i++) {
- struct dive* d = get_dive_by_uniq_id(diveList.at(i));
+ dive *d = get_dive_by_uniq_id(diveList.at(i));
d->when -= timeChanged;
}
+ // Changing times may have unsorted the dive table
+ sort_table(&dive_table);
mark_divelist_changed(true);
+
+ // Negate the time-shift so that the next call does the reverse
+ timeChanged = -timeChanged;
+
+ // Finally, do the UI stuff:
MainWindow::instance()->refreshDisplay();
}
void UndoShiftTime::redo()
{
- for (int i = 0; i < diveList.count(); i++) {
- struct dive* d = get_dive_by_uniq_id(diveList.at(i));
- d->when += timeChanged;
- }
- mark_divelist_changed(true);
- MainWindow::instance()->refreshDisplay();
+ // Same as undo(), since after undo() we reversed the timeOffset
+ undo();
}
-UndoRenumberDives::UndoRenumberDives(QMap<int, QPair<int, int> > originalNumbers)
+UndoRenumberDives::UndoRenumberDives(const QVector<QPair<int, int>> &divesToRenumberIn) : divesToRenumber(divesToRenumberIn)
{
- oldNumbers = originalNumbers;
- if (oldNumbers.count() > 1)
- setText(QString("renumber %1 dives").arg(QString::number(oldNumbers.count())));
- else
- setText("renumber dive");
+ setText(tr("renumber %n dive(s)", "", divesToRenumber.count()));
}
void UndoRenumberDives::undo()
{
- foreach (int key, oldNumbers.keys()) {
- struct dive* d = get_dive_by_uniq_id(key);
- d->number = oldNumbers.value(key).first;
+ for (auto &pair: divesToRenumber) {
+ dive *d = get_dive_by_uniq_id(pair.first);
+ if (!d)
+ continue;
+ std::swap(d->number, pair.second);
}
mark_divelist_changed(true);
+
+ // Finally, do the UI stuff:
MainWindow::instance()->refreshDisplay();
}
void UndoRenumberDives::redo()
{
- foreach (int key, oldNumbers.keys()) {
- struct dive* d = get_dive_by_uniq_id(key);
- d->number = oldNumbers.value(key).second;
- }
- mark_divelist_changed(true);
- MainWindow::instance()->refreshDisplay();
+ // Redo and undo do the same thing!
+ undo();
}
-
-UndoRemoveDivesFromTrip::UndoRemoveDivesFromTrip(QMap<dive *, dive_trip *> removedDives)
+UndoRemoveDivesFromTrip::UndoRemoveDivesFromTrip(const QVector<dive *> &divesToRemoveIn) : divesToRemove(divesToRemoveIn)
{
- divesToUndo = removedDives;
- setText("remove dive(s) from trip");
+ setText(tr("remove %n dive(s) from trip", "", divesToRemove.size()));
}
void UndoRemoveDivesFromTrip::undo()
{
// first bring back the trip(s)
- Q_FOREACH(struct dive_trip *trip, tripList)
- insert_trip(&trip);
- tripList.clear();
-
- QMapIterator<dive*, dive_trip*> i(divesToUndo);
- while (i.hasNext()) {
- i.next();
- add_dive_to_trip(i.key(), i.value());
+ for (auto &trip: tripsToAdd) {
+ dive_trip *t = trip.release(); // Give up ownership
+ insert_trip(&t); // Return ownership to backend
}
- mark_divelist_changed(true);
+ tripsToAdd.clear();
+
+ for (auto &pair: divesToAdd)
+ add_dive_to_trip(pair.first, pair.second);
+ divesToAdd.clear();
+
+ // Finally, do the UI stuff:
MainWindow::instance()->refreshDisplay();
}
void UndoRemoveDivesFromTrip::redo()
{
- QMapIterator<dive*, dive_trip*> i(divesToUndo);
- while (i.hasNext()) {
- i.next();
- // If the trip will be deleted, remember it so that we can restore it later.
- dive_trip *trip = i.value();
- if (trip->nrdives == 1) {
- dive_trip *cloned_trip = clone_empty_trip(trip);
- tripList.append(cloned_trip);
- // Rewrite the dive list, such that the dives will be added to the resurrected trip.
- for (dive_trip *&old_trip: divesToUndo) {
- if (old_trip == trip)
- old_trip = cloned_trip;
- }
+ for (dive *d: divesToRemove) {
+ // remove dive from trip - if this is the last dive in the trip
+ // remove the whole trip.
+ dive_trip *trip = unregister_dive_from_trip(d, false);
+ if (!trip)
+ continue; // This was not part of a trip
+ if (trip->nrdives == 0) {
+ unregister_trip(trip); // Remove trip from backend
+ tripsToAdd.emplace_back(trip); // Take ownership of trip
}
- remove_dive_from_trip(i.key(), false);
+ divesToAdd.emplace_back(d, trip);
}
mark_divelist_changed(true);
+
+ // Finally, do the UI stuff:
MainWindow::instance()->refreshDisplay();
}
diff --git a/desktop-widgets/undocommands.h b/desktop-widgets/undocommands.h
index 4e485e5ed..bbc1f05bd 100644
--- a/desktop-widgets/undocommands.h
+++ b/desktop-widgets/undocommands.h
@@ -2,50 +2,212 @@
#ifndef UNDOCOMMANDS_H
#define UNDOCOMMANDS_H
+#include "core/dive.h"
+
#include <QUndoCommand>
-#include <QMap>
+#include <QCoreApplication> // For Q_DECLARE_TR_FUNCTIONS
+#include <QVector>
+#include <memory>
+
+// The classes declared in this file represent units-of-work, which can be exectuted / undone
+// repeatedly. The command objects are collected in a linear list implemented in the QUndoStack class.
+// They contain the information that is necessary to either perform or undo the unit-of-work.
+// The usage is:
+// constructor: generate information that is needed for executing the unit-of-work
+// redo(): performs the unit-of-work and generates the information that is needed for undo()
+// undo(): undos the unit-of-work and regenerates the initial information needed in redo()
+// The needed information is mostly kept in pointers to dives and/or trips, which have to be added
+// or removed.
+// For this to work it is crucial that
+// 1) Pointers to dives and trips remain valid as long as referencing command-objects exist.
+// 2) The dive-table is not resorted, because dives are inserted at given indices.
+//
+// Thus, if a command deletes a dive or a trip, the actual object must not be deleted. Instead,
+// the command object removes pointers to the dive/trip object from the backend and takes ownership.
+// To reverse such a deletion, the object is re-injected into the backend and ownership is given up.
+// Once ownership of a dive is taken, any reference to it was removed from the backend. Thus,
+// subsequent redo()/undo() actions cannot access this object and integrity of the data is ensured.
+//
+// As an example, consider the following course of events: Dive 1 is renumbered and deleted, dive 2
+// is added and renumbered. The undo list looks like this (---> non-owning, ***> owning pointers,
+// ===> next item in list)
+//
+// Undo-List
+// +-----------------+ +---------------+ +------------+ +-----------------+
+// | Renumber dive 1 |====>| Delete dive 1 |====>| Add dive 2 |====>| Renumber dive 2 |
+// +------------------ +---------------+ +------------+ +-----------------+
+// | * | |
+// | +--------+ * | +--------+ |
+// +----->| Dive 1 |<****** +--->| Dive 2 |<------+
+// +--------+ +--------+
+// ^
+// +---------+ *
+// | Backend |****************
+// +---------+
+// Two points of note:
+// 1) Every dive is owned by either the backend or exactly one command object.
+// 2) All references to dive 1 are *before* the owner "delete dive 2", thus the pointer is always valid.
+// 3) References by the backend are *always* owning.
+//
+// The user undos the last two commands. The situation now looks like this:
+//
+//
+// Undo-List Redo-List
+// +-----------------+ +---------------+ +------------+ +-----------------+
+// | Renumber dive 1 |====>| Delete dive 1 | | Add dive 2 |<====| Renumber dive 2 |
+// +------------------ +---------------+ +------------+ +-----------------+
+// | * * |
+// | +--------+ * * +--------+ |
+// +----->| Dive 1 |<****** ****>| Dive 2 |<------+
+// +--------+ +--------+
+//
+// +---------+
+// | Backend |
+// +---------+
+// Again:
+// 1) Every dive is owned by either the backend (here none) or exactly one command object.
+// 2) All references to dive 1 are *before* the owner "delete dive 1", thus the pointer is always valid.
+// 3) All references to dive 2 are *after* the owner "add dive 2", thus the pointer is always valid.
+//
+// The user undos one more command:
+//
+// Undo-List Redo-List
+// +-----------------+ +---------------+ +------------+ +-----------------+
+// | Renumber dive 1 | | Delete dive 1 |<====| Add dive 2 |<====| Renumber dive 2 |
+// +------------------ +---------------+ +------------+ +-----------------+
+// | | * |
+// | +--------+ | * +--------+ |
+// +----->| Dive 1 |<-----+ ****>| Dive 2 |<------+
+// +--------+ +--------+
+// ^
+// * +---------+
+// ***************| Backend |
+// +---------+
+// Same points as above.
+// The user now adds a dive 3. The redo list will be deleted:
+//
+// Undo-List
+// +-----------------+ +------------+
+// | Renumber dive 1 |=============================================>| Add dive 3 |
+// +------------------ +------------+
+// | |
+// | +--------+ +--------+ |
+// +----->| Dive 1 | | Dive 3 |<---+
+// +--------+ +--------+
+// ^ ^
+// * +---------+ *
+// ***************| Backend |****************
+// +---------+
+// Note:
+// 1) Dive 2 was deleted with the "add dive 2" command, because that was the owner.
+// 2) Dive 1 was not deleted, because it is owned by the backend.
+//
+// To take ownership of dives/trips, the OnwingDivePtr and OwningTripPtr types are used. These
+// are simply derived from std::unique_ptr and therefore use well-established semantics.
+// Expressed in C-terms: std::unique_ptr<T> is exactly the same as T* with the following
+// twists:
+// 1) default-initialized to NULL.
+// 2) if it goes out of scope (local scope or containing object destroyed), it does:
+// if (ptr) free_function(ptr);
+// whereby free_function can be configured (defaults to delete ptr).
+// 3) assignment between two std::unique_ptr<T> compiles only if the source is reset (to NULL).
+// (hence the name - there's a *unique* owner).
+// While this sounds trivial, experience shows that this distinctly simplifies memory-management
+// (it's not necessary to manually delete all vector items in the destructur, etc).
+// Note that Qt's own implementation (QScoperPointer) is not up to the job, because it doesn't implement
+// move-semantics and Qt's containers are incompatible, owing to COW semantics.
+//
+// Usage:
+// OwningDivePtr dPtr; // Initialize to null-state: not owning any dive.
+// OwningDivePtr dPtr(dive); // Take ownership of dive (which is of type struct dive *).
+// // If dPtr goes out of scope, the dive will be freed with free_dive().
+// struct dive *d = dPtr.release(); // Give up ownership of dive. dPtr is reset to null.
+// struct dive *d = d.get(); // Get pointer dive, but don't release ownership.
+// dPtr.reset(dive2); // Delete currently owned dive with free_dive() and get ownership of dive2.
+// dPtr.reset(); // Delete currently owned dive and reset to null.
+// dPtr2 = dPtr1; // Fails to compile.
+// dPtr2 = std::move(dPtr1); // dPtr2 takes ownership, dPtr1 is reset to null.
+// OwningDivePtr fun();
+// dPtr1 = fun(); // Compiles. Simply put: the compiler knows that the result of fun() will
+// // be trashed and therefore can be moved-from.
+// std::vector<OwningDivePtr> v: // Define an empty vector of owning pointers.
+// v.emplace_back(dive); // Take ownership of dive and add at end of vector
+// // If the vector goes out of scope, all dives will be freed with free_dive().
+// v.clear(v); // Reset the vector to zero length. If the elements weren't release()d,
+// // the pointed-to dives are freed with free_dive()
+
+// Classes used to automatically call free_dive()/free_trip for owning pointers that go out of scope.
+struct DiveDeleter {
+ void operator()(dive *d) { free_dive(d); }
+};
+struct TripDeleter {
+ void operator()(dive_trip *t) { free_trip(t); }
+};
+
+// Owning pointers to dive and dive_trip objects.
+typedef std::unique_ptr<dive, DiveDeleter> OwningDivePtr;
+typedef std::unique_ptr<dive_trip, TripDeleter> OwningTripPtr;
class UndoDeleteDive : public QUndoCommand {
+ Q_DECLARE_TR_FUNCTIONS(Command)
public:
- UndoDeleteDive(QList<struct dive*> deletedDives);
+ UndoDeleteDive(const QVector<dive *> &divesToDelete);
+private:
void undo() override;
void redo() override;
-private:
- QList<struct dive*> diveList;
- QList<struct dive_trip*> tripList;
+ // For redo
+ QVector<struct dive*> divesToDelete;
+
+ // For undo
+ struct DiveToAdd {
+ OwningDivePtr dive; // Dive to add
+ dive_trip *trip; // Trip, may be null
+ int idx; // Position in divelist
+ };
+ std::vector<OwningTripPtr> tripsToAdd;
+ std::vector<DiveToAdd> divesToAdd;
};
class UndoShiftTime : public QUndoCommand {
+ Q_DECLARE_TR_FUNCTIONS(Command)
public:
- UndoShiftTime(QList<int> changedDives, int amount);
+ UndoShiftTime(QVector<int> changedDives, int amount);
+private:
void undo() override;
void redo() override;
-private:
- QList<int> diveList;
+ // For redo and undo
+ QVector<int> diveList;
int timeChanged;
};
class UndoRenumberDives : public QUndoCommand {
+ Q_DECLARE_TR_FUNCTIONS(Command)
public:
- UndoRenumberDives(QMap<int, QPair<int, int> > originalNumbers);
+ UndoRenumberDives(const QVector<QPair<int, int>> &divesToRenumber);
+private:
void undo() override;
void redo() override;
-private:
- QMap<int,QPair<int, int> > oldNumbers;
+ // For redo and undo: pairs of dive-id / new number
+ QVector<QPair<int, int>> divesToRenumber;
};
class UndoRemoveDivesFromTrip : public QUndoCommand {
+ Q_DECLARE_TR_FUNCTIONS(Command)
public:
- UndoRemoveDivesFromTrip(QMap<struct dive*, dive_trip*> removedDives);
+ UndoRemoveDivesFromTrip(const QVector<dive *> &divesToRemove);
+private:
void undo() override;
void redo() override;
-private:
- QMap<struct dive*, dive_trip*> divesToUndo;
- QList<struct dive_trip*> tripList;
+ // For redo
+ QVector<dive *> divesToRemove;
+
+ // For undo
+ std::vector<std::pair<dive *, dive_trip *>> divesToAdd;
+ std::vector<OwningTripPtr> tripsToAdd;
};
#endif // UNDOCOMMANDS_H
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2025-01-19 01:00:33 +0000