mirror of
https://github.com/subsurface/subsurface.git
synced 2024-11-28 05:00:20 +00:00
d057af43b4
Don't access the global variable dc_number, which might not make sense on mobile. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
489 lines
15 KiB
C++
489 lines
15 KiB
C++
// SPDX-License-Identifier: GPL-2.0
|
|
// Note: this header file is used by the undo-machinery and should not be included elsewhere.
|
|
|
|
#ifndef COMMAND_EDIT_H
|
|
#define COMMAND_EDIT_H
|
|
|
|
#include "command_base.h"
|
|
#include "command.h" // for EditCylinderType
|
|
#include "core/divecomputer.h"
|
|
#include "core/subsurface-qt/divelistnotifier.h"
|
|
|
|
#include <QVector>
|
|
|
|
// These are commands that edit individual fields of a set of dives.
|
|
// The implementation is very OO-style. Out-of-fashion and certainly
|
|
// not elegant, but in line with Qt's OO-based design.
|
|
// The actual code is in a common base class "Command::EditBase". To
|
|
// read and set the fields, the base class calls virtual functions of
|
|
// the derived classes.
|
|
//
|
|
// To deal with different data types, the base class is implemented
|
|
// as a template. The template parameter is the type to be read or
|
|
// set. Thus, switch-cascades and union trickery can be avoided.
|
|
|
|
// We put everything in a namespace, so that we can shorten names without polluting the global namespace
|
|
namespace Command {
|
|
|
|
// Base class for commands that have a list of dives.
|
|
// This is used for extracting the number of dives and show a
|
|
// warning message when multiple dives are edited.
|
|
class EditDivesBase : public Base {
|
|
protected:
|
|
EditDivesBase(bool currentDiveOnly);
|
|
EditDivesBase(dive *d);
|
|
std::vector<dive *> dives; // Dives to be edited.
|
|
|
|
// On undo, we set the selection and current dive at the time of the operation.
|
|
std::vector<dive *> selectedDives;
|
|
struct dive *current;
|
|
public:
|
|
int numDives() const;
|
|
};
|
|
|
|
template <typename T>
|
|
class EditBase : public EditDivesBase {
|
|
protected:
|
|
T value; // Value to be set
|
|
T old; // Previous value
|
|
|
|
void undo() override;
|
|
void redo() override;
|
|
bool workToBeDone() override;
|
|
|
|
public:
|
|
EditBase(T newValue, bool currentDiveOnly);
|
|
EditBase(T newValue, dive *d);
|
|
|
|
protected:
|
|
// Get and set functions to be overriden by sub-classes.
|
|
virtual void set(struct dive *d, T) const = 0;
|
|
virtual T data(struct dive *d) const = 0;
|
|
virtual QString fieldName() const = 0; // Name of the field, used to create the undo menu-entry
|
|
virtual DiveField fieldId() const = 0;
|
|
};
|
|
|
|
// The individual Edit-commands define a virtual function that return the field-id.
|
|
// For reasons, which I don't fully understand, the C++ makers are strictly opposed
|
|
// to "virtual member constants" so we have to define these functions. To make
|
|
// things a bit more compact we do this automatically with the following template.
|
|
// Of course, we could directly encode the value in the EditBase-template, but
|
|
// that would lead to a multiplication of the created code.
|
|
template <typename T, DiveField::Flags ID>
|
|
class EditTemplate : public EditBase<T> {
|
|
private:
|
|
using EditBase<T>::EditBase; // Use constructor of base class.
|
|
DiveField fieldId() const override final; // final prevents further overriding - then just don't use this template
|
|
};
|
|
|
|
// Automatically generate getter and setter in the case of simple assignments.
|
|
// The third parameter is a pointer to a member of the dive structure.
|
|
template <typename T, DiveField::Flags ID, T dive::*PTR>
|
|
class EditDefaultSetter : public EditTemplate<T, ID> {
|
|
private:
|
|
using EditTemplate<T, ID>::EditTemplate;
|
|
void set(struct dive *d, T) const override final; // final prevents further overriding - then just don't use this template
|
|
T data(struct dive *d) const override final; // final prevents further overriding - then just don't use this template
|
|
};
|
|
|
|
// Automatically generate getter and setter in the case for string assignments.
|
|
// The third parameter is a pointer to a C-style string in the dive structure.
|
|
template <DiveField::Flags ID, char *dive::*PTR>
|
|
class EditStringSetter : public EditTemplate<QString, ID> {
|
|
private:
|
|
using EditTemplate<QString, ID>::EditTemplate;
|
|
void set(struct dive *d, QString) const override final; // final prevents further overriding - then just don't use this template
|
|
QString data(struct dive *d) const override final; // final prevents further overriding - then just don't use this template
|
|
};
|
|
|
|
class EditNotes : public EditStringSetter<DiveField::NOTES, &dive::notes> {
|
|
public:
|
|
using EditStringSetter::EditStringSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditSuit : public EditStringSetter<DiveField::SUIT, &dive::suit> {
|
|
public:
|
|
using EditStringSetter::EditStringSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditRating : public EditDefaultSetter<int, DiveField::RATING, &dive::rating> {
|
|
public:
|
|
using EditDefaultSetter::EditDefaultSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditVisibility : public EditDefaultSetter<int, DiveField::VISIBILITY, &dive::visibility> {
|
|
public:
|
|
using EditDefaultSetter::EditDefaultSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditWaveSize : public EditDefaultSetter<int, DiveField::WAVESIZE, &dive::wavesize> {
|
|
public:
|
|
using EditDefaultSetter::EditDefaultSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditCurrent : public EditDefaultSetter<int, DiveField::CURRENT, &dive::current> {
|
|
public:
|
|
using EditDefaultSetter::EditDefaultSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditSurge : public EditDefaultSetter<int, DiveField::SURGE, &dive::surge> {
|
|
public:
|
|
using EditDefaultSetter::EditDefaultSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditChill : public EditDefaultSetter<int, DiveField::CHILL, &dive::chill> {
|
|
public:
|
|
using EditDefaultSetter::EditDefaultSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditAirTemp : public EditTemplate<int, DiveField::AIR_TEMP> {
|
|
public:
|
|
using EditTemplate::EditTemplate; // Use constructor of base class.
|
|
void set(struct dive *d, int value) const override;
|
|
int data(struct dive *d) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditWaterTemp : public EditTemplate<int, DiveField::WATER_TEMP> {
|
|
public:
|
|
using EditTemplate::EditTemplate; // Use constructor of base class.
|
|
void set(struct dive *d, int value) const override;
|
|
int data(struct dive *d) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditAtmPress : public EditTemplate<int, DiveField::ATM_PRESS> {
|
|
public:
|
|
using EditTemplate::EditTemplate; // Use constructor of base class.
|
|
void set(struct dive *d, int value) const override;
|
|
int data(struct dive *d) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditWaterTypeUser : public EditTemplate<int, DiveField::SALINITY> {
|
|
public:
|
|
using EditTemplate::EditTemplate; // Use constructor of base class.
|
|
void set(struct dive *d, int value) const override;
|
|
int data(struct dive *d) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditDuration : public EditTemplate<int, DiveField::DURATION> {
|
|
public:
|
|
using EditTemplate::EditTemplate; // Use constructor of base class.
|
|
void set(struct dive *d, int value) const override;
|
|
int data(struct dive *d) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditDepth : public EditTemplate<int, DiveField::DEPTH> {
|
|
public:
|
|
using EditTemplate::EditTemplate; // Use constructor of base class.
|
|
void set(struct dive *d, int value) const override;
|
|
int data(struct dive *d) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditDiveSite : public EditTemplate<struct dive_site *, DiveField::DIVESITE> {
|
|
public:
|
|
using EditTemplate::EditTemplate; // Use constructor of base class.
|
|
void set(struct dive *d, struct dive_site *value) const override;
|
|
struct dive_site *data(struct dive *d) const override;
|
|
QString fieldName() const override;
|
|
|
|
// We specialize these so that we can send dive-site changed signals.
|
|
void undo() override;
|
|
void redo() override;
|
|
};
|
|
|
|
// Edit dive site, but add a new dive site first. Reuses the code of EditDiveSite by
|
|
// deriving from it and hooks into undo() and redo() to add / remove the dive site.
|
|
class EditDiveSiteNew : public EditDiveSite {
|
|
public:
|
|
OwningDiveSitePtr diveSiteToAdd;
|
|
struct dive_site *diveSiteToRemove;
|
|
EditDiveSiteNew(const QString &newName, bool currentDiveOnly);
|
|
void undo() override;
|
|
void redo() override;
|
|
};
|
|
|
|
class EditMode : public EditTemplate<int, DiveField::MODE> {
|
|
int index;
|
|
public:
|
|
EditMode(int indexIn, int newValue, bool currentDiveOnly);
|
|
void set(struct dive *d, int i) const override;
|
|
int data(struct dive *d) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditInvalid : public EditDefaultSetter<bool, DiveField::INVALID, &dive::invalid> {
|
|
public:
|
|
using EditDefaultSetter::EditDefaultSetter; // Use constructor of base class.
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
// Fields that work with tag-lists (tags, buddies, dive guides) work differently and therefore
|
|
// have their own base class. In this case, it's not a template, as all these lists are base
|
|
// on strings.
|
|
class EditTagsBase : public EditDivesBase {
|
|
bool workToBeDone() override;
|
|
|
|
QStringList newList; // Temporary until initialized
|
|
public:
|
|
EditTagsBase(const QStringList &newList, bool currentDiveOnly);
|
|
|
|
protected:
|
|
QStringList tagsToAdd;
|
|
QStringList tagsToRemove;
|
|
void undo() override;
|
|
void redo() override;
|
|
|
|
// Getters, setters and parsers to be overriden by sub-classes.
|
|
virtual QStringList data(struct dive *d) const = 0;
|
|
virtual void set(struct dive *d, const QStringList &v) const = 0;
|
|
virtual QString fieldName() const = 0; // Name of the field, used to create the undo menu-entry
|
|
virtual DiveField fieldId() const = 0;
|
|
};
|
|
|
|
// See comments for EditTemplate
|
|
template <DiveField::Flags ID>
|
|
class EditTagsTemplate : public EditTagsBase {
|
|
private:
|
|
using EditTagsBase::EditTagsBase; // Use constructor of base class.
|
|
DiveField fieldId() const override final; // final prevents further overriding - then just don't use this template
|
|
};
|
|
|
|
class EditTags : public EditTagsTemplate<DiveField::TAGS> {
|
|
public:
|
|
using EditTagsTemplate::EditTagsTemplate; // Use constructor of base class.
|
|
QStringList data(struct dive *d) const override;
|
|
void set(struct dive *d, const QStringList &v) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditBuddies : public EditTagsTemplate<DiveField::BUDDY> {
|
|
public:
|
|
using EditTagsTemplate::EditTagsTemplate; // Use constructor of base class.
|
|
QStringList data(struct dive *d) const override;
|
|
void set(struct dive *d, const QStringList &v) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
class EditDiveGuide : public EditTagsTemplate<DiveField::DIVEGUIDE> {
|
|
public:
|
|
using EditTagsTemplate::EditTagsTemplate; // Use constructor of base class.
|
|
QStringList data(struct dive *d) const override;
|
|
void set(struct dive *d, const QStringList &v) const override;
|
|
QString fieldName() const override;
|
|
};
|
|
|
|
// Fields we have to remember to undo paste
|
|
struct PasteState {
|
|
dive *d;
|
|
dive_site *divesite;
|
|
QString notes;
|
|
QString diveguide;
|
|
QString buddy;
|
|
QString suit;
|
|
int rating;
|
|
int wavesize;
|
|
int visibility;
|
|
int current;
|
|
int surge;
|
|
int chill;
|
|
tag_entry *tags;
|
|
struct cylinder_table cylinders;
|
|
struct weightsystem_table weightsystems;
|
|
int number;
|
|
timestamp_t when;
|
|
|
|
PasteState(dive *d, const dive *data, dive_components what); // Read data from dive data for dive d
|
|
~PasteState();
|
|
void swap(dive_components what); // Exchange values here and in dive
|
|
};
|
|
|
|
class PasteDives : public Base {
|
|
dive_components what;
|
|
std::vector<PasteState> dives;
|
|
public:
|
|
PasteDives(const dive *d, dive_components what);
|
|
private:
|
|
void undo() override;
|
|
void redo() override;
|
|
bool workToBeDone() override;
|
|
};
|
|
|
|
class ReplanDive : public Base {
|
|
dive *d;
|
|
|
|
// Exchange these data with current dive
|
|
timestamp_t when;
|
|
depth_t maxdepth, meandepth;
|
|
struct cylinder_table cylinders;
|
|
struct divecomputer dc;
|
|
char *notes;
|
|
pressure_t surface_pressure;
|
|
duration_t duration;
|
|
int salinity;
|
|
public:
|
|
// Dive computer(s) and cylinders(s) of the source dive will be reset!
|
|
ReplanDive(dive *source);
|
|
~ReplanDive();
|
|
private:
|
|
void undo() override;
|
|
void redo() override;
|
|
bool workToBeDone() override;
|
|
};
|
|
|
|
class EditProfile : public Base {
|
|
dive *d;
|
|
int dcNr;
|
|
|
|
depth_t maxdepth, meandepth, dcmaxdepth;
|
|
duration_t duration;
|
|
struct divecomputer dc;
|
|
public:
|
|
// Note: source must be clean (i.e. fixup_dive must have been called on it).
|
|
EditProfile(const dive *source, int dcNr, EditProfileType type, int count);
|
|
~EditProfile();
|
|
private:
|
|
void undo() override;
|
|
void redo() override;
|
|
bool workToBeDone() override;
|
|
};
|
|
|
|
class AddWeight : public EditDivesBase {
|
|
public:
|
|
AddWeight(bool currentDiveOnly);
|
|
private:
|
|
void undo() override;
|
|
void redo() override;
|
|
bool workToBeDone() override;
|
|
};
|
|
|
|
class EditWeightBase : public EditDivesBase {
|
|
protected:
|
|
EditWeightBase(int index, bool currentDiveOnly);
|
|
~EditWeightBase();
|
|
|
|
weightsystem_t ws;
|
|
std::vector<int> indices; // An index for each dive in the dives vector.
|
|
bool workToBeDone() override;
|
|
};
|
|
|
|
class RemoveWeight : public EditWeightBase {
|
|
public:
|
|
RemoveWeight(int index, bool currentDiveOnly);
|
|
private:
|
|
void undo() override;
|
|
void redo() override;
|
|
};
|
|
|
|
class EditWeight : public EditWeightBase {
|
|
public:
|
|
EditWeight(int index, weightsystem_t ws, bool currentDiveOnly); // Clones ws
|
|
~EditWeight();
|
|
private:
|
|
weightsystem_t new_ws;
|
|
void undo() override;
|
|
void redo() override;
|
|
};
|
|
|
|
class AddCylinder : public EditDivesBase {
|
|
public:
|
|
AddCylinder(bool currentDiveOnly);
|
|
~AddCylinder();
|
|
private:
|
|
cylinder_t cyl;
|
|
std::vector<int> indexes; // An index for each dive in the dives vector.
|
|
void undo() override;
|
|
void redo() override;
|
|
bool workToBeDone() override;
|
|
};
|
|
|
|
class EditCylinderBase : public EditDivesBase {
|
|
protected:
|
|
EditCylinderBase(int index, bool currentDiveOnly, bool nonProtectedOnly, int sameCylinderFlags);
|
|
~EditCylinderBase();
|
|
|
|
std::vector<cylinder_t> cyl;
|
|
std::vector<int> indexes; // An index for each dive in the dives vector.
|
|
bool workToBeDone() override;
|
|
};
|
|
|
|
class RemoveCylinder : public EditCylinderBase {
|
|
public:
|
|
RemoveCylinder(int index, bool currentDiveOnly);
|
|
private:
|
|
void undo() override;
|
|
void redo() override;
|
|
};
|
|
|
|
// Instead of implementing an undo command for every single field in a cylinder,
|
|
// we only have one and pass an edit "type". We either edit the type, pressure
|
|
// or gasmix fields. This has mostly historical reasons rooted in the way the
|
|
// CylindersModel code works. The model works for undo and also in the planner
|
|
// without undo. Having a single undo-command simplifies the code there.
|
|
class EditCylinder : public EditCylinderBase {
|
|
public:
|
|
EditCylinder(int index, cylinder_t cyl, EditCylinderType type, bool currentDiveOnly); // Clones cylinder
|
|
private:
|
|
EditCylinderType type;
|
|
void undo() override;
|
|
void redo() override;
|
|
};
|
|
|
|
class EditSensors : public Base
|
|
{
|
|
public:
|
|
EditSensors(int cylIndex, int fromCylinder, int dcNr);
|
|
|
|
private:
|
|
struct dive *d;
|
|
struct divecomputer *dc;
|
|
int toCylinder;
|
|
int fromCylinder;
|
|
void mapSensors(int toCyl, int fromCyl);
|
|
void undo() override;
|
|
void redo() override;
|
|
bool workToBeDone() override;
|
|
};
|
|
|
|
#ifdef SUBSURFACE_MOBILE
|
|
// Edit a full dive. This is used on mobile where we don't have per-field granularity.
|
|
// It may add or edit a dive site.
|
|
class EditDive : public Base {
|
|
public:
|
|
EditDive(dive *oldDive, dive *newDive, dive_site *createDs, dive_site *editDs, location_t dsLocation); // Takes ownership of newDive
|
|
private:
|
|
dive *oldDive; // Dive that is going to be overwritten
|
|
OwningDivePtr newDive; // New data
|
|
dive_site *newDiveSite;
|
|
int changedFields;
|
|
|
|
dive_site *siteToRemove;
|
|
OwningDiveSitePtr siteToAdd;
|
|
|
|
dive_site *siteToEdit;
|
|
location_t dsLocation;
|
|
|
|
void undo() override;
|
|
void redo() override;
|
|
bool workToBeDone() override;
|
|
|
|
void exchangeDives();
|
|
void editDs();
|
|
};
|
|
|
|
#endif // SUBSURFACE_MOBILE
|
|
|
|
} // namespace Command
|
|
#endif
|