Refactoring: move undo commands to top level

In the future we might want to use undo-commands for mobile as
well (even if not implementing undo).

Therefore, move the undo-command source from desktop-widgets
to their own commands top-level folder.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>

1 files changed, 0 insertions, 999 deletions

diff --git a/desktop-widgets/command_divelist.cpp b/desktop-widgets/command_divelist.cpp
deleted file mode 100644
index 4b4ef4ab8..000000000
--- a/desktop-widgets/command_divelist.cpp
+++ /dev/null
@@ -1,999 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-
-#include "command_divelist.h"
-#include "command_private.h"
-#include "core/divelist.h"
-#include "core/display.h" // for amount_selected
-#include "core/qthelper.h"
-#include "core/subsurface-qt/DiveListNotifier.h"
-#include "qt-models/filtermodels.h"
-#include "../profile-widget/profilewidget2.h"
-
-#include <array>
-
-namespace Command {
-
-// This helper function removes a dive, takes ownership of the dive and adds it to a DiveToAdd structure.
-// If the trip the dive belongs to becomes empty, it is removed and added to the tripsToAdd vector.
-// It is crucial that dives are added in reverse order of deletion, so that the indices are correctly
-// set and that the trips are added before they are used!
-DiveToAdd DiveListBase::removeDive(struct dive *d, std::vector<OwningTripPtr> &tripsToAdd)
-{
-	// If the dive was the current dive, reset the current dive. The calling
-	// command is responsible of finding a new dive.
-	if (d == current_dive)
-		current_dive = nullptr;
-
-	// remove dive from trip and site - if this is the last dive in the trip
-	// remove the whole trip.
-	DiveToAdd res;
-	res.trip = unregister_dive_from_trip(d);
-	if (d->dive_site)
-		diveSiteCountChanged(d->dive_site);
-	res.site = unregister_dive_from_dive_site(d);
-	if (res.trip && res.trip->dives.nr == 0) {
-		remove_trip(res.trip, &trip_table);	// Remove trip from backend
-		tripsToAdd.emplace_back(res.trip);	// Take ownership of trip
-	}
-
-	int idx = get_divenr(d);
-	if (idx < 0)
-		qWarning("Deletion of unknown dive!");
-
-	res.dive.reset(unregister_dive(idx));		// Remove dive from backend
-
-	return res;
-}
-
-void DiveListBase::diveSiteCountChanged(struct dive_site *ds)
-{
-	if (std::find(sitesCountChanged.begin(), sitesCountChanged.end(), ds) == sitesCountChanged.end())
-		sitesCountChanged.push_back(ds);
-}
-
-// This helper function adds a dive and returns ownership to the backend. It may also add a dive trip.
-// It is crucial that dives are added in reverse order of deletion (see comment above)!
-// Returns pointer to added dive (which is owned by the backend!)
-dive *DiveListBase::addDive(DiveToAdd &d)
-{
-	if (d.trip)
-		add_dive_to_trip(d.dive.get(), d.trip);
-	if (d.site) {
-		add_dive_to_dive_site(d.dive.get(), d.site);
-		diveSiteCountChanged(d.site);
-	}
-	dive *res = d.dive.release();		// Give up ownership of dive
-
-	// Set the filter flag according to current filter settings
-	bool show = MultiFilterSortModel::instance()->showDive(res);
-	res->hidden_by_filter = !show;
-
-	int idx = dive_table_get_insertion_index(&dive_table, res);
-	add_to_dive_table(&dive_table, idx, res);	// Return ownership to backend
-	invalidate_dive_cache(res);		// Ensure that dive is written in git_save()
-
-	return res;
-}
-
-// Some signals are sent in batches per trip. To avoid writing the same loop
-// twice, this template takes a vector of trip / dive pairs, sorts it
-// by trip and then calls a function-object with trip and a QVector of dives in that trip.
-// The dives are sorted by the dive_less_than() function defined in the core.
-// Input parameters:
-//	- dives: a vector of trip,dive pairs, which will be sorted and processed in batches by trip.
-//	- action: a function object, taking a trip-pointer and a QVector of dives, which will be called for each batch.
-template<typename Function>
-void processByTrip(std::vector<std::pair<dive_trip *, dive *>> &dives, Function action)
-{
-	// Sort lexicographically by trip then according to the dive_less_than() function.
-	std::sort(dives.begin(), dives.end(),
-		  [](const std::pair<dive_trip *, dive *> &e1, const std::pair<dive_trip *, dive *> &e2)
-		  { return e1.first == e2.first ? dive_less_than(e1.second, e2.second) : e1.first < e2.first; });
-
-	// Then, process the dives in batches by trip
-	size_t i, j; // Begin and end of batch
-	for (i = 0; i < dives.size(); i = j) {
-		dive_trip *trip = dives[i].first;
-		for (j = i + 1; j < dives.size() && dives[j].first == trip; ++j)
-			; // pass
-		// Copy dives into a QVector. Some sort of "range_view" would be ideal, but Qt doesn't work this way.
-		QVector<dive *> divesInTrip(j - i);
-		for (size_t k = i; k < j; ++k)
-			divesInTrip[k - i] = dives[k].second;
-
-		// Finally, emit the signal
-		action(trip, divesInTrip);
-	}
-}
-
-// This helper function calls removeDive() on a list of dives to be removed and
-// returns a vector of corresponding DiveToAdd objects, which can later be readded.
-// Moreover, a vector of deleted trips is returned, if trips became empty.
-// The passed in vector is cleared.
-DivesAndTripsToAdd DiveListBase::removeDives(DivesAndSitesToRemove &divesAndSitesToDelete)
-{
-	std::vector<DiveToAdd> divesToAdd;
-	std::vector<OwningTripPtr> tripsToAdd;
-	std::vector<OwningDiveSitePtr> sitesToAdd;
-	divesToAdd.reserve(divesAndSitesToDelete.dives.size());
-	sitesToAdd.reserve(divesAndSitesToDelete.sites.size());
-
-	// Make sure that the dive list is sorted. The added dives will be sent in a signal
-	// and the recipients assume that the dives are sorted the same way as they are
-	// in the core list.
-	std::sort(divesAndSitesToDelete.dives.begin(), divesAndSitesToDelete.dives.end(), dive_less_than);
-
-	for (dive *d: divesAndSitesToDelete.dives)
-		divesToAdd.push_back(removeDive(d, tripsToAdd));
-	divesAndSitesToDelete.dives.clear();
-
-	for (dive_site *ds: divesAndSitesToDelete.sites) {
-		int idx = unregister_dive_site(ds);
-		sitesToAdd.emplace_back(ds);
-		emit diveListNotifier.diveSiteDeleted(ds, idx);
-	}
-	divesAndSitesToDelete.sites.clear();
-
-	// We send one dives-deleted signal per trip (see comments in DiveListNotifier.h).
-	// Therefore, collect all dives in an array and sort by trip.
-	std::vector<std::pair<dive_trip *, dive *>> dives;
-	dives.reserve(divesToAdd.size());
-	for (const DiveToAdd &entry: divesToAdd)
-		dives.push_back({ entry.trip, entry.dive.get() });
-
-	// Send signals.
-	processByTrip(dives, [&](dive_trip *trip, const QVector<dive *> &divesInTrip) {
-		// Check if this trip is supposed to be deleted, by checking if it was marked as "add it".
-		bool deleteTrip = trip &&
-				  std::find_if(tripsToAdd.begin(), tripsToAdd.end(), [trip](const OwningTripPtr &ptr)
-					       { return ptr.get() == trip; }) != tripsToAdd.end();
-		emit diveListNotifier.divesDeleted(trip, deleteTrip, divesInTrip);
-	});
-	return { std::move(divesToAdd), std::move(tripsToAdd), std::move(sitesToAdd) };
-}
-
-// This helper function is the counterpart fo removeDives(): it calls addDive() on a list
-// of dives to be (re)added and returns a vector of the added dives. It does this in reverse
-// order, so that trips are created appropriately and indexing is correct.
-// The passed in vector is cleared.
-DivesAndSitesToRemove DiveListBase::addDives(DivesAndTripsToAdd &toAdd)
-{
-	std::vector<dive *> res;
-	std::vector<dive_site *> sites;
-	std::vector<std::pair<dive_trip *, dive *>> dives;
-	res.resize(toAdd.dives.size());
-	sites.reserve(toAdd.sites.size());
-	dives.reserve(toAdd.sites.size());
-
-	// Make sure that the dive list is sorted. The added dives will be sent in a signal
-	// and the recipients assume that the dives are sorted the same way as they are
-	// in the core list.
-	std::sort(toAdd.dives.begin(), toAdd.dives.end(),
-		  [](const DiveToAdd &d, const DiveToAdd &d2)
-		  { return dive_less_than(d.dive.get(), d2.dive.get()); });
-
-	// Now, add the dives
-	// Note: the idiomatic STL-way would be std::transform, but let's use a loop since
-	// that is closer to classical C-style.
-	auto it2 = res.rbegin();
-	for (auto it = toAdd.dives.rbegin(); it != toAdd.dives.rend(); ++it, ++it2) {
-		*it2 = addDive(*it);
-		dives.push_back({ (*it2)->divetrip, *it2 });
-	}
-	toAdd.dives.clear();
-
-	// If the dives belong to new trips, add these as well.
-	// Remember the pointers so that we can later check if a trip was newly added
-	std::vector<dive_trip *> addedTrips;
-	addedTrips.reserve(toAdd.trips.size());
-	for (OwningTripPtr &trip: toAdd.trips) {
-		addedTrips.push_back(trip.get());
-		insert_trip(trip.release(), &trip_table); // Return ownership to backend
-	}
-	toAdd.trips.clear();
-
-	// Finally, add any necessary dive sites
-	for (OwningDiveSitePtr &ds: toAdd.sites) {
-		sites.push_back(ds.get());
-		int idx = register_dive_site(ds.release()); // Return ownership to backend
-		emit diveListNotifier.diveSiteAdded(sites.back(), idx);
-	}
-	toAdd.sites.clear();
-
-	// Send signals by trip.
-	processByTrip(dives, [&](dive_trip *trip, const QVector<dive *> &divesInTrip) {
-		// Now, let's check if this trip is supposed to be created, by checking if it was marked as "add it".
-		bool createTrip = trip && std::find(addedTrips.begin(), addedTrips.end(), trip) != addedTrips.end();
-		// Finally, emit the signal
-		emit diveListNotifier.divesAdded(trip, createTrip, divesInTrip);
-	});
-	return { res, sites };
-}
-
-// This helper function renumbers dives according to an array of id/number pairs.
-// The old numbers are stored in the array, thus calling this function twice has no effect.
-static void renumberDives(QVector<QPair<dive *, int>> &divesToRenumber)
-{
-	QVector<dive *> dives;
-	dives.reserve(divesToRenumber.size());
-	for (auto &pair: divesToRenumber) {
-		dive *d = pair.first;
-		if (!d)
-			continue;
-		std::swap(d->number, pair.second);
-		dives.push_back(d);
-		invalidate_dive_cache(d);
-	}
-
-	// Send signals.
-	emit diveListNotifier.divesChanged(dives, DiveField::NR);
-}
-
-// This helper function moves a dive to a trip. The old trip is recorded in the
-// passed-in structure. This means that calling the function twice on the same
-// object is a no-op concerning the dive. If the old trip was deleted from the
-// core, an owning pointer to the removed trip is returned, otherwise a null pointer.
-static OwningTripPtr moveDiveToTrip(DiveToTrip &diveToTrip)
-{
-	// Firstly, check if we move to the same trip and bail if this is a no-op.
-	if (diveToTrip.trip == diveToTrip.dive->divetrip)
-		return {};
-
-	// Remove from old trip
-	OwningTripPtr res;
-
-	// Remove dive from trip - if this is the last dive in the trip, remove the whole trip.
-	dive_trip *trip = unregister_dive_from_trip(diveToTrip.dive);
-	if (trip && trip->dives.nr == 0) {
-		remove_trip(trip, &trip_table);	// Remove trip from backend
-		res.reset(trip);
-	}
-
-	// Store old trip and get new trip we should associate this dive with
-	std::swap(trip, diveToTrip.trip);
-	add_dive_to_trip(diveToTrip.dive, trip);
-	invalidate_dive_cache(diveToTrip.dive);		// Ensure that dive is written in git_save()
-	return res;
-}
-
-// This helper function moves a set of dives between trips using the
-// moveDiveToTrip function. Before doing so, it adds the necessary trips to
-// the core. Trips that are removed from the core because they are empty
-// are recorded in the passed in struct. The vectors of trips and dives
-// are reversed. Thus, calling the function twice on the same object is
-// a no-op.
-static void moveDivesBetweenTrips(DivesToTrip &dives)
-{
-	// We collect an array of created trips so that we can instruct
-	// the model to create a new entry
-	std::vector<dive_trip *> createdTrips;
-	createdTrips.reserve(dives.tripsToAdd.size());
-
-	// First, bring back the trip(s)
-	for (OwningTripPtr &trip: dives.tripsToAdd) {
-		dive_trip *t = trip.release();	// Give up ownership
-		createdTrips.push_back(t);
-		insert_trip(t, &trip_table);	// Return ownership to backend
-	}
-	dives.tripsToAdd.clear();
-
-	for (DiveToTrip &dive: dives.divesToMove) {
-		OwningTripPtr tripToAdd = moveDiveToTrip(dive);
-		// register trips that we'll have to readd
-		if (tripToAdd)
-			dives.tripsToAdd.push_back(std::move(tripToAdd));
-	}
-
-	// We send one signal per from-trip/to-trip pair.
-	// First, collect all dives in a struct and sort by from-trip/to-trip.
-	struct DiveMoved {
-		dive_trip *from;
-		dive_trip *to;
-		dive *d;
-	};
-	std::vector<DiveMoved> divesMoved;
-	divesMoved.reserve(dives.divesToMove.size());
-	for (const DiveToTrip &entry: dives.divesToMove)
-		divesMoved.push_back({ entry.trip, entry.dive->divetrip, entry.dive });
-
-	// Sort lexicographically by from-trip, to-trip and by start-time.
-	// Use std::tie() for lexicographical sorting.
-	std::sort(divesMoved.begin(), divesMoved.end(), [] ( const DiveMoved &d1, const DiveMoved &d2)
-		  { return std::tie(d1.from, d1.to, d1.d->when) < std::tie(d2.from, d2.to, d2.d->when); });
-
-	// Now, process the dives in batches by trip
-	// TODO: this is a bit different from the cases above, so we don't use the processByTrip template,
-	// but repeat the loop here. We might think about generalizing the template, if more of such
-	// "special cases" appear.
-	size_t i, j; // Begin and end of batch
-	for (i = 0; i < divesMoved.size(); i = j) {
-		dive_trip *from = divesMoved[i].from;
-		dive_trip *to = divesMoved[i].to;
-		for (j = i + 1; j < divesMoved.size() && divesMoved[j].from == from && divesMoved[j].to == to; ++j)
-			; // pass
-		// Copy dives into a QVector. Some sort of "range_view" would be ideal, but Qt doesn't work this way.
-		QVector<dive *> divesInTrip(j - i);
-		for (size_t k = i; k < j; ++k)
-			divesInTrip[k - i] = divesMoved[k].d;
-
-		// Check if the from-trip was deleted: If yes, it was recorded in the tripsToAdd structure.
-		// Only set the flag if this is that last time this trip is featured.
-		bool deleteFrom = from &&
-				  std::find_if(divesMoved.begin() + j, divesMoved.end(), // Is this the last occurence of "from"?
-					       [from](const DiveMoved &entry) { return entry.from == from; }) == divesMoved.end() &&
-				  std::find_if(dives.tripsToAdd.begin(), dives.tripsToAdd.end(), // Is "from" in tripsToAdd?
-					       [from](const OwningTripPtr &trip) { return trip.get() == from; }) != dives.tripsToAdd.end();
-		// Check if the to-trip has to be created. For this purpose, we saved an array of trips to be created.
-		bool createTo = false;
-		if (to) {
-			// Check if the element is there...
-			auto it = std::find(createdTrips.begin(), createdTrips.end(), to);
-
-			// ...if it is - remove it as we don't want the model to create the trip twice!
-			if (it != createdTrips.end()) {
-				createTo = true;
-				// erase/remove would be more performant, but this is irrelevant in the big scheme of things.
-				createdTrips.erase(it);
-			}
-		}
-
-		// Finally, emit the signal
-		emit diveListNotifier.divesMovedBetweenTrips(from, to, deleteFrom, createTo, divesInTrip);
-	}
-
-	// Reverse the tripsToAdd and the divesToAdd, so that on undo/redo the operations
-	// will be performed in reverse order.
-	std::reverse(dives.tripsToAdd.begin(), dives.tripsToAdd.end());
-	std::reverse(dives.divesToMove.begin(), dives.divesToMove.end());
-}
-
-void DiveListBase::initWork()
-{
-}
-
-void DiveListBase::finishWork()
-{
-	for (dive_site *ds: sitesCountChanged)
-		emit diveListNotifier.diveSiteDiveCountChanged(ds);
-}
-
-void DiveListBase::undo()
-{
-	auto marker = diveListNotifier.enterCommand();
-	initWork();
-	undoit();
-	finishWork();
-}
-
-void DiveListBase::redo()
-{
-	auto marker = diveListNotifier.enterCommand();
-	initWork();
-	redoit();
-	finishWork();
-}
-
-AddDive::AddDive(dive *d, bool autogroup, bool newNumber)
-{
-	setText(tr("add dive"));
-	// By convention, d is a pointer to "displayed dive" or a temporary variable and can be overwritten.
-	d->maxdepth.mm = 0;
-	d->dc.maxdepth.mm = 0;
-	fixup_dive(d);
-
-	// this only matters if undoit were called before redoit
-	currentDive = nullptr;
-
-	// Get an owning pointer to a moved dive.
-	OwningDivePtr divePtr(move_dive(d));
-	divePtr->selected = false; // If we clone a planned dive, it might have been selected.
-				   // We have to clear the flag, as selections will be managed
-				   // on dive-addition.
-
-	// If we alloc a new-trip for autogrouping, get an owning pointer to it.
-	OwningTripPtr allocTrip;
-	dive_trip *trip = divePtr->divetrip;
-	dive_site *site = divePtr->dive_site;
-	// We have to delete the pointers to trip and site, because this would prevent the core from adding to the
-	// trip or site and we would get the count-of-dives in the trip or site wrong. Yes, that's all horribly subtle!
-	divePtr->divetrip = nullptr;
-	divePtr->dive_site = nullptr;
-	if (!trip && autogroup) {
-		bool alloc;
-		trip = get_trip_for_new_dive(divePtr.get(), &alloc);
-		if (alloc)
-			allocTrip.reset(trip);
-	}
-
-	int idx = dive_table_get_insertion_index(&dive_table, divePtr.get());
-	if (newNumber)
-		divePtr->number = get_dive_nr_at_idx(idx);
-
-	divesToAdd.dives.push_back({ std::move(divePtr), trip, site });
-	if (allocTrip)
-		divesToAdd.trips.push_back(std::move(allocTrip));
-}
-
-bool AddDive::workToBeDone()
-{
-	return true;
-}
-
-void AddDive::redoit()
-{
-	// Remember selection so that we can undo it
-	selection = getDiveSelection();
-	currentDive = current_dive;
-
-	divesAndSitesToRemove = addDives(divesToAdd);
-	sort_trip_table(&trip_table); // Though unlikely, adding a dive may reorder trips
-
-	// Select the newly added dive
-	setSelection(divesAndSitesToRemove.dives, divesAndSitesToRemove.dives[0]);
-}
-
-void AddDive::undoit()
-{
-	// Simply remove the dive that was previously added...
-	divesToAdd = removeDives(divesAndSitesToRemove);
-	sort_trip_table(&trip_table); // Though unlikely, removing a dive may reorder trips
-
-	// ...and restore the selection
-	setSelection(selection, currentDive);
-}
-
-ImportDives::ImportDives(struct dive_table *dives, struct trip_table *trips, struct dive_site_table *sites, int flags, const QString &source)
-{
-	setText(tr("import %n dive(s) from %1", "", dives->nr).arg(source));
-
-	// this only matters if undoit were called before redoit
-	currentDive = nullptr;
-
-	struct dive_table dives_to_add = { 0 };
-	struct dive_table dives_to_remove = { 0 };
-	struct trip_table trips_to_add = { 0 };
-	struct dive_site_table sites_to_add = { 0 };
-	process_imported_dives(dives, trips, sites, flags, &dives_to_add, &dives_to_remove, &trips_to_add, &sites_to_add);
-
-	// Add trips to the divesToAdd.trips structure
-	divesToAdd.trips.reserve(trips_to_add.nr);
-	for (int i = 0; i < trips_to_add.nr; ++i)
-		divesToAdd.trips.emplace_back(trips_to_add.trips[i]);
-
-	// Add sites to the divesToAdd.sites structure
-	divesToAdd.sites.reserve(sites_to_add.nr);
-	for (int i = 0; i < sites_to_add.nr; ++i)
-		divesToAdd.sites.emplace_back(sites_to_add.dive_sites[i]);
-
-	// Add dives to the divesToAdd.dives structure
-	divesToAdd.dives.reserve(dives_to_add.nr);
-	for (int i = 0; i < dives_to_add.nr; ++i) {
-		OwningDivePtr divePtr(dives_to_add.dives[i]);
-		divePtr->selected = false; // See above in AddDive::AddDive()
-		dive_trip *trip = divePtr->divetrip;
-		divePtr->divetrip = nullptr; // See above in AddDive::AddDive()
-		dive_site *site = divePtr->dive_site;
-		divePtr->dive_site = nullptr; // See above in AddDive::AddDive()
-
-		divesToAdd.dives.push_back({ std::move(divePtr), trip, site });
-	}
-
-	// Add dive to be deleted to the divesToRemove structure
-	divesAndSitesToRemove.dives.reserve(dives_to_remove.nr);
-	for (int i = 0; i < dives_to_remove.nr; ++i)
-		divesAndSitesToRemove.dives.push_back(dives_to_remove.dives[i]);
-}
-
-bool ImportDives::workToBeDone()
-{
-	return !divesToAdd.dives.empty();
-}
-
-void ImportDives::redoit()
-{
-	// Remember selection so that we can undo it
-	currentDive = current_dive;
-
-	// Add new dives and sites
-	DivesAndSitesToRemove divesAndSitesToRemoveNew = addDives(divesToAdd);
-
-	// Remove old dives and sites
-	divesToAdd = removeDives(divesAndSitesToRemove);
-
-	// Select the newly added dives
-	setSelection(divesAndSitesToRemoveNew.dives, divesAndSitesToRemoveNew.dives.back());
-
-	// Remember dives and sites to remove
-	divesAndSitesToRemove = std::move(divesAndSitesToRemoveNew);
-}
-
-void ImportDives::undoit()
-{
-	// Add new dives and sites
-	DivesAndSitesToRemove divesAndSitesToRemoveNew = addDives(divesToAdd);
-
-	// Remove old dives and sites
-	divesToAdd = removeDives(divesAndSitesToRemove);
-
-	// Remember dives and sites to remove
-	divesAndSitesToRemove = std::move(divesAndSitesToRemoveNew);
-
-	// ...and restore the selection
-	setSelection(selection, currentDive);
-}
-
-DeleteDive::DeleteDive(const QVector<struct dive*> &divesToDeleteIn)
-{
-	divesToDelete.dives = divesToDeleteIn.toStdVector();
-	setText(tr("delete %n dive(s)", "", divesToDelete.dives.size()));
-}
-
-bool DeleteDive::workToBeDone()
-{
-	return !divesToDelete.dives.empty();
-}
-
-void DeleteDive::undoit()
-{
-	divesToDelete = addDives(divesToAdd);
-	sort_trip_table(&trip_table); // Though unlikely, removing a dive may reorder trips
-
-	// Select all re-added dives and make the first one current
-	dive *currentDive = !divesToDelete.dives.empty() ? divesToDelete.dives[0] : nullptr;
-	setSelection(divesToDelete.dives, currentDive);
-}
-
-void DeleteDive::redoit()
-{
-	divesToAdd = removeDives(divesToDelete);
-	sort_trip_table(&trip_table); // Though unlikely, adding a dive may reorder trips
-
-	// Deselect all dives and select dive that was close to the first deleted dive
-	dive *newCurrent = nullptr;
-	if (!divesToAdd.dives.empty()) {
-		timestamp_t when = divesToAdd.dives[0].dive->when;
-		newCurrent = find_next_visible_dive(when);
-	}
-	if (newCurrent)
-		setSelection(std::vector<dive *>{ newCurrent }, newCurrent);
-	else
-		setSelection(std::vector<dive *>(), nullptr);
-}
-
-
-ShiftTime::ShiftTime(const QVector<dive *> &changedDives, int amount)
-	: diveList(changedDives), timeChanged(amount)
-{
-	setText(tr("shift time of %n dives", "", changedDives.count()));
-}
-
-void ShiftTime::redoit()
-{
-	std::vector<dive_trip *> trips;
-	for (dive *d: diveList) {
-		d->when += timeChanged;
-		if (d->divetrip && std::find(trips.begin(), trips.end(), d->divetrip) == trips.end())
-			trips.push_back(d->divetrip);
-	}
-
-	// Changing times may have unsorted the dive and trip tables
-	sort_dive_table(&dive_table);
-	sort_trip_table(&trip_table);
-	for (dive_trip *trip: trips)
-		sort_dive_table(&trip->dives); // Keep the trip-table in order
-
-	// Send signals
-	emit diveListNotifier.divesTimeChanged(timeChanged, diveList);
-	emit diveListNotifier.divesChanged(diveList, DiveField::DATETIME);
-
-	// Select the changed dives
-	setSelection(diveList.toStdVector(), diveList[0]);
-
-	// Negate the time-shift so that the next call does the reverse
-	timeChanged = -timeChanged;
-}
-
-bool ShiftTime::workToBeDone()
-{
-	return !diveList.isEmpty();
-}
-
-void ShiftTime::undoit()
-{
-	// Same as redoit(), since after redoit() we reversed the timeOffset
-	redoit();
-}
-
-
-RenumberDives::RenumberDives(const QVector<QPair<dive *, int>> &divesToRenumberIn) : divesToRenumber(divesToRenumberIn)
-{
-	setText(tr("renumber %n dive(s)", "", divesToRenumber.count()));
-}
-
-void RenumberDives::undoit()
-{
-	renumberDives(divesToRenumber);
-
-	// Select the changed dives
-	std::vector<dive *> dives;
-	dives.reserve(divesToRenumber.size());
-	for (const QPair<dive *, int> &item: divesToRenumber)
-		dives.push_back(item.first);
-	setSelection(dives, dives[0]);
-}
-
-bool RenumberDives::workToBeDone()
-{
-	return !divesToRenumber.isEmpty();
-}
-
-void RenumberDives::redoit()
-{
-	// Redo and undo do the same thing!
-	undoit();
-}
-
-bool TripBase::workToBeDone()
-{
-	return !divesToMove.divesToMove.empty();
-}
-
-void TripBase::redoit()
-{
-	moveDivesBetweenTrips(divesToMove);
-	sort_trip_table(&trip_table); // Though unlikely, moving dives may reorder trips
-
-	// Select the moved dives
-	std::vector<dive *> dives;
-	dives.reserve(divesToMove.divesToMove.size());
-	for (const DiveToTrip &item: divesToMove.divesToMove)
-		dives.push_back(item.dive);
-	setSelection(dives, dives[0]);
-}
-
-void TripBase::undoit()
-{
-	// Redo and undo do the same thing!
-	redoit();
-}
-
-RemoveDivesFromTrip::RemoveDivesFromTrip(const QVector<dive *> &divesToRemove)
-{
-	setText(tr("remove %n dive(s) from trip", "", divesToRemove.size()));
-	divesToMove.divesToMove.reserve(divesToRemove.size());
-	for (dive *d: divesToRemove) {
-		// If a user manually removes a dive from a trip, don't autogroup this dive.
-		// The flag will not be reset on undo, but that should be acceptable.
-		d->notrip = true;
-		divesToMove.divesToMove.push_back( {d, nullptr} );
-	}
-}
-
-RemoveAutogenTrips::RemoveAutogenTrips()
-{
-	setText(tr("remove autogenerated trips"));
-	// TODO: don't touch core-innards directly
-	int i;
-	struct dive *dive;
-	for_each_dive(i, dive) {
-		if (dive->divetrip && dive->divetrip->autogen)
-			divesToMove.divesToMove.push_back( {dive, nullptr} );
-	}
-}
-
-AddDivesToTrip::AddDivesToTrip(const QVector<dive *> &divesToAddIn, dive_trip *trip)
-{
-	setText(tr("add %n dives to trip", "", divesToAddIn.size()));
-	for (dive *d: divesToAddIn)
-		divesToMove.divesToMove.push_back( {d, trip} );
-}
-
-CreateTrip::CreateTrip(const QVector<dive *> &divesToAddIn)
-{
-	setText(tr("create trip"));
-
-	if (divesToAddIn.isEmpty())
-		return;
-
-	dive_trip *trip = create_trip_from_dive(divesToAddIn[0]);
-	divesToMove.tripsToAdd.emplace_back(trip);
-	for (dive *d: divesToAddIn)
-		divesToMove.divesToMove.push_back( {d, trip} );
-}
-
-AutogroupDives::AutogroupDives()
-{
-	setText(tr("autogroup dives"));
-
-	dive_trip *trip;
-	bool alloc;
-	int from, to;
-	for(int i = 0; (trip = get_dives_to_autogroup(&dive_table, i, &from, &to, &alloc)) != NULL; i = to) {
-		// If this is an allocated trip, take ownership
-		if (alloc)
-			divesToMove.tripsToAdd.emplace_back(trip);
-		for (int j = from; j < to; ++j)
-			divesToMove.divesToMove.push_back( { get_dive(j), trip } );
-	}
-}
-
-MergeTrips::MergeTrips(dive_trip *trip1, dive_trip *trip2)
-{
-	if (trip1 == trip2)
-		return;
-	dive_trip *newTrip = combine_trips(trip1, trip2);
-	divesToMove.tripsToAdd.emplace_back(newTrip);
-	for (int i = 0; i < trip1->dives.nr; ++i)
-		divesToMove.divesToMove.push_back( { trip1->dives.dives[i], newTrip } );
-	for (int i = 0; i < trip2->dives.nr; ++i)
-		divesToMove.divesToMove.push_back( { trip2->dives.dives[i], newTrip } );
-}
-
-// std::array<dive *, 2> is the same as struct *dive[2], with the fundamental
-// difference that it can be returned from functions. Thus, this constructor
-// can be chained with the result of a function.
-SplitDivesBase::SplitDivesBase(dive *d, std::array<dive *, 2> newDives)
-{
-	// If either of the new dives is null, simply return. Empty arrays indicate that nothing is to be done.
-	if (!newDives[0] || !newDives[1])
-		return;
-
-	// Currently, the core code selects the dive -> this is not what we want, as
-	// we manually manage the selection post-command.
-	// TODO: Reset selection in core.
-	newDives[0]->selected = false;
-	newDives[1]->selected = false;
-
-	// The new dives will be registered to the dive site using the site member
-	// of the DiveToAdd structure. For this to work, we must set the dive's
-	// dive_site member to null. Yes, that's subtle!
-	newDives[0]->dive_site = nullptr;
-	newDives[1]->dive_site = nullptr;
-
-	diveToSplit.dives.push_back(d);
-	splitDives.dives.resize(2);
-	splitDives.dives[0].dive.reset(newDives[0]);
-	splitDives.dives[0].trip = d->divetrip;
-	splitDives.dives[0].site = d->dive_site;
-	splitDives.dives[1].dive.reset(newDives[1]);
-	splitDives.dives[1].trip = d->divetrip;
-	splitDives.dives[1].site = d->dive_site;
-}
-
-bool SplitDivesBase::workToBeDone()
-{
-	return !diveToSplit.dives.empty();
-}
-
-void SplitDivesBase::redoit()
-{
-	divesToUnsplit = addDives(splitDives);
-	unsplitDive = removeDives(diveToSplit);
-
-	// Select split dives and make first dive current
-	setSelection(divesToUnsplit.dives, divesToUnsplit.dives[0]);
-}
-
-void SplitDivesBase::undoit()
-{
-	// Note: reverse order with respect to redoit()
-	diveToSplit = addDives(unsplitDive);
-	splitDives = removeDives(divesToUnsplit);
-
-	// Select unsplit dive and make it current
-	setSelection(diveToSplit.dives, diveToSplit.dives[0] );
-}
-
-static std::array<dive *, 2> doSplitDives(const dive *d, duration_t time)
-{
-	// Split the dive
-	dive *new1, *new2;
-	if (time.seconds < 0)
-		split_dive(d, &new1, &new2);
-	else
-		split_dive_at_time(d, time, &new1, &new2);
-
-	return { new1, new2 };
-}
-
-SplitDives::SplitDives(dive *d, duration_t time) : SplitDivesBase(d, doSplitDives(d, time))
-{
-	setText(tr("split dive"));
-}
-
-static std::array<dive *, 2> splitDiveComputer(const dive *d, int dc_num)
-{
-	// Refuse to do anything if the dive has only one dive computer.
-	// Yes, this should have been checked by the UI, but let's just make sure.
-	if (!d->dc.next)
-		return { nullptr, nullptr};
-
-	dive *new1, *new2;
-	split_divecomputer(d, dc_num, &new1, &new2);
-
-	return { new1, new2 };
-}
-
-SplitDiveComputer::SplitDiveComputer(dive *d, int dc_num) : SplitDivesBase(d, splitDiveComputer(d, dc_num))
-{
-	setText(tr("split dive computer"));
-}
-
-DiveComputerBase::DiveComputerBase(dive *old_dive, dive *new_dive, int dc_nr_after_in) : dc_nr_before(dc_number),
-	dc_nr_after(dc_nr_after_in)
-{
-	if (!new_dive)
-		return;
-
-	diveToRemove.dives.push_back(old_dive);
-
-	// Currently, the core code selects the dive -> this is not what we want, as
-	// we manually manage the selection post-command.
-	// TODO: Reset selection in core.
-	new_dive->selected = false;
-
-	// Reset references to trip and site in the new dive, as the undo command
-	// will add the dive to the trip and site.
-	new_dive->divetrip = nullptr;
-	new_dive->dive_site = nullptr;
-
-	diveToAdd.dives.resize(1);
-	diveToAdd.dives[0].dive.reset(new_dive);
-	diveToAdd.dives[0].trip = old_dive->divetrip;
-	diveToAdd.dives[0].site = old_dive->dive_site;
-}
-
-bool DiveComputerBase::workToBeDone()
-{
-	return !diveToRemove.dives.empty() || !diveToAdd.dives.empty();
-}
-
-void DiveComputerBase::redoit()
-{
-	DivesAndSitesToRemove addedDive = addDives(diveToAdd);
-	diveToAdd = removeDives(diveToRemove);
-	diveToRemove = std::move(addedDive);
-
-	dc_number = dc_nr_after;
-
-	// Select added dive and make it current.
-	// This automatically replots the profile.
-	setSelection(diveToRemove.dives, diveToRemove.dives[0]);
-
-	std::swap(dc_nr_before, dc_nr_after);
-}
-
-void DiveComputerBase::undoit()
-{
-	// Undo and redo do the same
-	redoit();
-}
-
-MoveDiveComputerToFront::MoveDiveComputerToFront(dive *d, int dc_num)
-	: DiveComputerBase(d, make_first_dc(d, dc_num), 0)
-{
-	setText(tr("move dive computer to front"));
-}
-
-DeleteDiveComputer::DeleteDiveComputer(dive *d, int dc_num)
-	: DiveComputerBase(d, clone_delete_divecomputer(d, dc_num), std::min(count_divecomputers(d) - 1, dc_num))
-{
-	setText(tr("delete dive computer"));
-}
-
-MergeDives::MergeDives(const QVector <dive *> &dives)
-{
-	setText(tr("merge dive"));
-
-	// Just a safety check - if there's not two or more dives - do nothing
-	// The caller should have made sure that this doesn't happen.
-	if (dives.count() < 2) {
-		qWarning("Merging less than two dives");
-		return;
-	}
-
-	dive_trip *preferred_trip;
-	dive_site *preferred_site;
-	OwningDivePtr d(merge_dives(dives[0], dives[1], dives[1]->when - dives[0]->when, false, &preferred_trip, &preferred_site));
-
-	// Currently, the core code selects the dive -> this is not what we want, as
-	// we manually manage the selection post-command.
-	// TODO: Remove selection code from core.
-	d->selected = false;
-
-	// Set the preferred dive trip, so that for subsequent merges the better trip can be selected
-	d->divetrip = preferred_trip;
-	for (int i = 2; i < dives.count(); ++i) {
-		d.reset(merge_dives(d.get(), dives[i], dives[i]->when - d->when, false, &preferred_trip, &preferred_site));
-		// Set the preferred dive trip and site, so that for subsequent merges the better trip and site can be selected
-		d->divetrip = preferred_trip;
-		d->dive_site = preferred_site;
-	}
-
-	// We got our preferred trip and site, so now the references can be deleted from the newly generated dive
-	d->divetrip = nullptr;
-	d->dive_site = nullptr;
-
-	// The merged dive gets the number of the first dive with a non-zero number
-	for (const dive *dive: dives) {
-		if (dive->number) {
-			d->number = dive->number;
-			break;
-		}
-	}
-
-	// We will only renumber the remaining dives if the joined dives are consecutive.
-	// Otherwise all bets are off concerning what the user wanted and doing nothing seems
-	// like the best option.
-	int idx = get_divenr(dives[0]);
-	int num = dives.count();
-	if (idx < 0 || idx + num > dive_table.nr) {
-		// It was the callers responsibility to pass only known dives.
-		// Something is seriously wrong - give up.
-		qWarning("Merging unknown dives");
-		return;
-	}
-	// std::equal compares two ranges. The parameters are (begin_range1, end_range1, begin_range2).
-	// Here, we can compare C-arrays, because QVector guarantees contiguous storage.
-	if (std::equal(&dives[0], &dives[0] + num, &dive_table.dives[idx]) &&
-	    dives[0]->number && dives.last()->number && dives[0]->number < dives.last()->number) {
-		// We have a consecutive set of dives. Rename all following dives according to the
-		// number of erased dives. This considers that there might be missing numbers.
-		// Comment copied from core/divelist.c:
-		// So if you had a dive list  1 3 6 7 8, and you
-		// merge 1 and 3, the resulting numbered list will
-		// be 1 4 5 6, because we assume that there were
-		// some missing dives (originally dives 4 and 5),
-		// that now will still be missing (dives 2 and 3
-		// in the renumbered world).
-		//
-		// Obviously the normal case is that everything is
-		// consecutive, and the difference will be 1, so the
-		// above example is not supposed to be normal.
-		int diff = dives.last()->number - dives[0]->number;
-		divesToRenumber.reserve(dive_table.nr - idx - num);
-		int previousnr = dives[0]->number;
-		for (int i = idx + num; i < dive_table.nr; ++i) {
-			int newnr = dive_table.dives[i]->number - diff;
-
-			// Stop renumbering if stuff isn't in order (see also core/divelist.c)
-			if (newnr <= previousnr)
-				break;
-			divesToRenumber.append(QPair<dive *,int>(dive_table.dives[i], newnr));
-			previousnr = newnr;
-		}
-	}
-
-	mergedDive.dives.resize(1);
-	mergedDive.dives[0].dive = std::move(d);
-	mergedDive.dives[0].trip = preferred_trip;
-	mergedDive.dives[0].site = preferred_site;
-	divesToMerge.dives = dives.toStdVector();
-}
-
-bool MergeDives::workToBeDone()
-{
-	return !mergedDive.dives.empty();
-}
-
-void MergeDives::redoit()
-{
-	renumberDives(divesToRenumber);
-	diveToUnmerge = addDives(mergedDive);
-	unmergedDives = removeDives(divesToMerge);
-
-	// Select merged dive and make it current
-	setSelection(diveToUnmerge.dives, diveToUnmerge.dives[0]);
-}
-
-void MergeDives::undoit()
-{
-	divesToMerge = addDives(unmergedDives);
-	mergedDive = removeDives(diveToUnmerge);
-	renumberDives(divesToRenumber);
-
-	// Select unmerged dives and make first one current
-	setSelection(divesToMerge.dives, divesToMerge.dives[0]);
-}
-
-} // namespace Command