meshcommands.h

Go to the documentation of this file.

 
#ifndef OPENSWMMVIS_MAP_MESHCOMMANDS_H
#define OPENSWMMVIS_MAP_MESHCOMMANDS_H
 
#include "map/mapundostack.h"
#include "mesh/meshedgebc.h"
#include "mesh/meshinfil.h"
#include "mesh/meshresult.h"
 
#include <QByteArray>
#include <QPair>
#include <QPointer>
#include <QString>
#include <QVariant>
#include <QVector>
 
class SWMM2DMeshLayer;
 
class MeshSetTriangleTagCommand : public MapCommand
{
public:
    MeshSetTriangleTagCommand(SWMM2DMeshLayer   *layer,
                              QVector<int>       triangles,
                              QString            newTag,
                              QVector<QString>   oldTags,
                              const QString     &text,
                              MapCanvas         *canvas,
                              QUndoCommand      *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 44; }
 
private:
    QPointer<SWMM2DMeshLayer> m_layer;
    QVector<int>              m_tris;
    QString                   m_newTag;
    QVector<QString>          m_oldTags;
};
 
class MeshSetTriangleAttributeCommand : public MapCommand
{
public:
    MeshSetTriangleAttributeCommand(SWMM2DMeshLayer      *layer,
                                    QByteArray            key,
                                    QVector<int>          triangles,
                                    QVector<double>       newValues,
                                    QVector<double>       oldValues,
                                    const QString        &text,
                                    MapCanvas            *canvas,
                                    QUndoCommand         *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 43; }
 
private:
    void apply(const QVector<double> &values);
 
    QPointer<SWMM2DMeshLayer> m_layer;
    QByteArray                m_key;
    QVector<int>              m_tris;
    QVector<double>           m_newValues;
    QVector<double>           m_oldValues;
};
 
class MeshSetVertexAttributeCommand : public MapCommand
{
public:
    MeshSetVertexAttributeCommand(SWMM2DMeshLayer          *layer,
                                  QByteArray                key,
                                  QVector<int>              vertices,
                                  QVector<mesh::MeshVertex> newAttrs,
                                  QVector<mesh::MeshVertex> oldAttrs,
                                  const QString            &text,
                                  MapCanvas                *canvas,
                                  QUndoCommand             *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 45; }
 
private:
    void apply(const QVector<mesh::MeshVertex> &attrs);
 
    QPointer<SWMM2DMeshLayer> m_layer;
    QByteArray                m_key;
    QVector<int>              m_verts;
    QVector<mesh::MeshVertex> m_newAttrs;
    QVector<mesh::MeshVertex> m_oldAttrs;
};
 
class MeshSetEdgeAttributeCommand : public MapCommand
{
public:
    MeshSetEdgeAttributeCommand(SWMM2DMeshLayer          *layer,
                                QByteArray                key,
                                QVector<int>              edgeSlots,
                                QVector<mesh::MeshEdgeBC> newBCs,
                                QVector<mesh::MeshEdgeBC> oldBCs,
                                const QString            &text,
                                MapCanvas                *canvas,
                                QUndoCommand             *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 46; }
 
private:
    void apply(const QVector<mesh::MeshEdgeBC> &bcs);
 
    QPointer<SWMM2DMeshLayer> m_layer;
    QByteArray                m_key;
    QVector<int>              m_slots;
    QVector<mesh::MeshEdgeBC> m_newBCs;
    QVector<mesh::MeshEdgeBC> m_oldBCs;
};
 
class MeshSetTriangleInfilCommand : public MapCommand
{
public:
    MeshSetTriangleInfilCommand(SWMM2DMeshLayer               *layer,
                                QVector<int>                   triangles,
                                mesh::InfilRow                 newRow,
                                QVector<mesh::InfilRow>        oldRows,
                                QVector<mesh::InfilProvenance> oldProv,
                                const QString                 &text,
                                MapCanvas                     *canvas,
                                QUndoCommand                  *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 49; }
 
private:
    QPointer<SWMM2DMeshLayer>      m_layer;
    QVector<int>                   m_tris;
    mesh::InfilRow                 m_newRow;
    QVector<mesh::InfilRow>        m_oldRows;
    QVector<mesh::InfilProvenance> m_oldProv;
};
 
class MeshSetInfilDefaultsCommand : public MapCommand
{
public:
    MeshSetInfilDefaultsCommand(SWMM2DMeshLayer         *layer,
                                QVector<QString>         tags,
                                QVector<mesh::InfilRow>  newRows,
                                QVector<mesh::InfilRow>  oldRows,
                                QVector<bool>            oldExisted,
                                const QString           &text,
                                MapCanvas               *canvas,
                                QUndoCommand            *parent = nullptr);
 
    void undo() override;
    void redo() override;
    int  id()   const override { return 50; }
 
private:
    QPointer<SWMM2DMeshLayer> m_layer;
    QVector<QString>          m_tags;
    QVector<mesh::InfilRow>   m_newRows;
    QVector<mesh::InfilRow>   m_oldRows;
    QVector<bool>             m_oldExisted;
};
 
namespace mesh {
 
int pushCellParamEdit(SWMM2DMeshLayer *layer, const QVector<int> &triangles,
                      const QByteArray &key, double value, MapCanvas *canvas);
 
int pushCellParamEdits(SWMM2DMeshLayer *layer, const QVector<int> &triangles,
                       const QVector<double> &values, const QByteArray &key,
                       const QString &text, MapCanvas *canvas);
 
int pushCellInfilEdit(SWMM2DMeshLayer *layer, const QVector<int> &triangles,
                      const InfilRow &row, MapCanvas *canvas);
 
int pushInfilDefaultsEdit(SWMM2DMeshLayer *layer,
                          const QVector<InfilDefaultRow> &rows,
                          MapCanvas *canvas);
 
int pushCellTagEdit(SWMM2DMeshLayer *layer, const QVector<int> &triangles,
                    const QString &tag, MapCanvas *canvas);
 
int pushVertexParamEdit(SWMM2DMeshLayer *layer, const QVector<int> &vertices,
                        const QByteArray &key, const QVariant &value,
                        MapCanvas *canvas);
 
int pushEdgeParamEdit(SWMM2DMeshLayer *layer,
                      const QVector<QPair<int, int>> &edges,
                      const QByteArray &key, const QVariant &value,
                      MapCanvas *canvas);
 
int pushEdgeBCEdit(SWMM2DMeshLayer *layer,
                   const QVector<QPair<int, int>> &edges,
                   const MeshEdgeBC &bc, MapCanvas *canvas);
 
} // namespace mesh
 
#endif // OPENSWMMVIS_MAP_MESHCOMMANDS_H