TYActions.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef __TY_ACTIONS__
#define __TY_ACTIONS__
 
#include "TYAppDefines.h"
#include "TYAction.h"
#include "TYModelerFrame.h"
 
class TYModelerAction : public TYAction
{
public:
    TYModelerAction(TYModelerFrame* pModeler, const QString& actionName)
        : TYAction(actionName), _pModeler(pModeler)
    {
        _pInteractor = _pModeler->getView();
    }
 
    virtual ~TYModelerAction() {}
 
    virtual void undo() = 0;
    virtual void redo() = 0;
 
protected:
    TYRenderWindowInteractor* _pInteractor;
    TYModelerFrame* _pModeler;
};
 
class TYAddAccSurfToAccSurfNodeAction : public TYModelerAction
{
public:
    TYAddAccSurfToAccSurfNodeAction(LPTYAcousticSurfaceGeoNode pAccSurfGeoNode,
                                    LPTYAcousticSurfaceNode pAccSurfNode, TYModelerFrame* pModeler,
                                    const QString& actionName);
    TYAddAccSurfToAccSurfNodeAction(LPTYAcousticSurface pAccSurf, LPTYAcousticSurfaceNode pAccSurfNode,
                                    TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYAddAccSurfToAccSurfNodeAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYAcousticSurfaceGeoNode _pAccSurfGeoNode;
    LPTYAcousticSurfaceNode _pAccSurfNode;
};
 
class TYRemAccSurfToAccSurfNodeAction : public TYModelerAction
{
public:
    TYRemAccSurfToAccSurfNodeAction(LPTYAcousticSurfaceGeoNode pAccSurfGeoNode,
                                    LPTYAcousticSurfaceNode pAccSurfNode, TYModelerFrame* pModeler,
                                    const QString& actionName);
    TYRemAccSurfToAccSurfNodeAction(LPTYAcousticSurface pAccSurf, LPTYAcousticSurfaceNode pAccSurfNode,
                                    TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYRemAccSurfToAccSurfNodeAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYAcousticSurfaceGeoNode _pAccSurfGeoNode;
    LPTYAcousticSurfaceNode _pAccSurfNode;
};
 
class TYAddAccVolToAccVolNodeAction : public TYModelerAction
{
public:
    TYAddAccVolToAccVolNodeAction(LPTYAcousticVolumeGeoNode pAccVolGeoNode,
                                  LPTYAcousticVolumeNode pAccVolNode, TYModelerFrame* pModeler,
                                  const QString& actionName);
    TYAddAccVolToAccVolNodeAction(LPTYAcousticVolume pAccVol, LPTYAcousticVolumeNode pAccVolNode,
                                  TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYAddAccVolToAccVolNodeAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYAcousticVolumeGeoNode _pAccVolGeoNode;
    LPTYAcousticVolumeNode _pAccVolNode;
};
 
class TYRemAccVolToAccVolNodeAction : public TYModelerAction
{
public:
    TYRemAccVolToAccVolNodeAction(LPTYAcousticVolumeGeoNode pAccVolGeoNode,
                                  LPTYAcousticVolumeNode pAccVolNode, TYModelerFrame* pModeler,
                                  const QString& actionName);
    TYRemAccVolToAccVolNodeAction(LPTYAcousticVolume pAccVol, LPTYAcousticVolumeNode pAccVolNode,
                                  TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYRemAccVolToAccVolNodeAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYAcousticVolumeGeoNode _pAccVolGeoNode;
    LPTYAcousticVolumeNode _pAccVolNode;
};
 
class TYAddMachineToEtageAction : public TYModelerAction
{
public:
    TYAddMachineToEtageAction(LPTYMachineGeoNode pMachineGeoNode, LPTYEtage pEtage, TYModelerFrame* pModeler,
                              const QString& actionName);
    TYAddMachineToEtageAction(LPTYMachine pMachine, LPTYEtage pEtage, TYModelerFrame* pModeler,
                              const QString& actionName);
    virtual ~TYAddMachineToEtageAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYMachineGeoNode _pMachineGeoNode;
    LPTYEtage _pEtage;
};
 
class TYRemMachineToEtageAction : public TYModelerAction
{
public:
    TYRemMachineToEtageAction(LPTYMachineGeoNode pMachineGeoNode, LPTYEtage pEtage, TYModelerFrame* pModeler,
                              const QString& actionName);
    TYRemMachineToEtageAction(LPTYMachine pMachine, LPTYEtage pEtage, TYModelerFrame* pModeler,
                              const QString& actionName);
    virtual ~TYRemMachineToEtageAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYMachineGeoNode _pMachineGeoNode;
    LPTYEtage _pEtage;
};
 
// BEGIN
class TYAddElementToEtageAction : public TYModelerAction
{
public:
    TYAddElementToEtageAction(SmartPtr<TYGeometryNode> pElementGeoNode, LPTYEtage pEtage,
                              TYModelerFrame* pModeler, const QString& actionName);
    TYAddElementToEtageAction(LPTYElement pElement, LPTYEtage pEtage, TYModelerFrame* pModeler,
                              const QString& actionName);
    virtual ~TYAddElementToEtageAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    SmartPtr<TYGeometryNode> _pElementGeoNode;
    LPTYUserSourcePonctuelle _pSrcPonct;
    LPTYEtage _pEtage;
};
 
class TYRemElementToEtageAction : public TYModelerAction
{
public:
    TYRemElementToEtageAction(SmartPtr<TYGeometryNode> pElementGeoNode, LPTYEtage pEtage,
                              TYModelerFrame* pModeler, const QString& actionName);
    TYRemElementToEtageAction(LPTYElement pElement, LPTYEtage pEtage, TYModelerFrame* pModeler,
                              const QString& actionName);
    virtual ~TYRemElementToEtageAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    SmartPtr<TYGeometryNode> _pElementGeoNode;
    LPTYUserSourcePonctuelle _pSrcPonct;
    LPTYEtage _pEtage;
};
 
// END
 
class TYAddElementToTopoAction : public TYModelerAction
{
public:
    TYAddElementToTopoAction(SmartPtr<TYGeometryNode> pElementGeoNode, LPTYTopographie pTopo,
                             TYModelerFrame* pModeler, const QString& actionName);
    TYAddElementToTopoAction(LPTYElement pElement, LPTYTopographie pTopo, TYModelerFrame* pModeler,
                             const QString& actionName);
    virtual ~TYAddElementToTopoAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    SmartPtr<TYGeometryNode> _pElementGeoNode;
    LPTYTopographie _pTopo;
};
 
class TYRemElementToTopoAction : public TYModelerAction
{
public:
    TYRemElementToTopoAction(SmartPtr<TYGeometryNode> pElementGeoNode, LPTYTopographie pTopo,
                             TYModelerFrame* pModeler, const QString& actionName);
    TYRemElementToTopoAction(LPTYElement pElement, LPTYTopographie pTopo, TYModelerFrame* pModeler,
                             const QString& actionName);
    virtual ~TYRemElementToTopoAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    SmartPtr<TYGeometryNode> _pElementGeoNode;
    LPTYTopographie _pTopo;
};
 
class TYAddElementToInfraAction : public TYModelerAction
{
public:
    TYAddElementToInfraAction(SmartPtr<TYGeometryNode> pElementGeoNode, LPTYInfrastructure pInfra,
                              TYModelerFrame* pModeler, const QString& actionName);
    TYAddElementToInfraAction(LPTYElement pElement, LPTYInfrastructure pInfra, TYModelerFrame* pModeler,
                              const QString& actionName);
    virtual ~TYAddElementToInfraAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    SmartPtr<TYGeometryNode> _pElementGeoNode;
    LPTYUserSourcePonctuelle _pSrcPonct;
    LPTYInfrastructure _pInfra;
};
 
class TYRemElementToInfraAction : public TYModelerAction
{
public:
    TYRemElementToInfraAction(SmartPtr<TYGeometryNode> pElementGeoNode, LPTYInfrastructure pInfra,
                              TYModelerFrame* pModeler, const QString& actionName);
    TYRemElementToInfraAction(LPTYElement pElement, LPTYInfrastructure pInfra, TYModelerFrame* pModeler,
                              const QString& actionName);
    virtual ~TYRemElementToInfraAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    SmartPtr<TYGeometryNode> _pElementGeoNode;
    LPTYUserSourcePonctuelle _pSrcPonct;
    LPTYInfrastructure _pInfra;
};
 
class TYResizeRectAction : public TYModelerAction
{
public:
    TYResizeRectAction(LPTYRectangle pRect, const float& newSizeX, const float& newSizeY,
                       TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYResizeRectAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYRectangle _pRect;
    float _oldSize[2];
    float _newSize[2];
};
 
class TYResizeAccBoxAction : public TYModelerAction
{
public:
    TYResizeAccBoxAction(LPTYAcousticBox pBox, const float& newSizeX, const float& newSizeY,
                         const float& newSizeZ, TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYResizeAccBoxAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYAcousticBox _pBox;
    float _oldSize[3];
    float _newSize[3];
};
 
class TYResizeAccCylAction : public TYModelerAction
{
public:
    TYResizeAccCylAction(LPTYAcousticCylinder pCyl, const double& newDiameter, const double& newHauteur,
                         TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYResizeAccCylAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYAcousticCylinder _pCyl;
    double _oldDiameter;
    double _oldHauteur;
    double _newDiameter;
    double _newHauteur;
};
 
class TYResizeAccSemiCylAction : public TYModelerAction
{
public:
    TYResizeAccSemiCylAction(LPTYAcousticSemiCylinder pSemiCyl, const double& newDiameter,
                             const double& newHauteur, TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYResizeAccSemiCylAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYAcousticSemiCylinder _pSemiCyl;
    double _oldDiameter;
    double _oldHauteur;
    double _newDiameter;
    double _newHauteur;
};
 
class TYMoveGeoNodeAction : public TYModelerAction
{
public:
    TYMoveGeoNodeAction(SmartPtr<TYGeometryNode> pGeoNode, const TYPoint& oldPos, const TYPoint& newPos,
                        TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYMoveGeoNodeAction();
 
    void setNewPos(const TYPoint& newPos)
    {
        _newPos = newPos;
    }
 
    virtual void undo();
    virtual void redo();
 
protected:
    SmartPtr<TYGeometryNode> _pGeoNode;
    TYPoint _oldPos;
    TYPoint _newPos;
};
 
class TYRotateGeoNodeAction : public TYModelerAction
{
public:
    TYRotateGeoNodeAction(SmartPtr<TYGeometryNode> pGeoNode, const TYRepere& oldRepere,
                          const TYRepere& newRepere, TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYRotateGeoNodeAction();
 
    void setNewRepere(const TYRepere& newRepere)
    {
        _newRepere = newRepere;
    }
 
    virtual void undo();
    virtual void redo();
 
protected:
    SmartPtr<TYGeometryNode> _pGeoNode;
    TYRepere _oldRepere;
    TYRepere _newRepere;
};
 
class TYMovePointEtageAction : public TYModelerAction
{
public:
    TYMovePointEtageAction(LPTYEtage pEtage, const int& ptId, const TYPoint& oldPos, const TYPoint& newPos,
                           TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYMovePointEtageAction();
 
    void setNewPos(const TYPoint& newPos)
    {
        _newPos = newPos;
    }
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYEtage _pEtage;
    int _ptId;
    TYPoint _oldPos;
    TYPoint _newPos;
};
 
class TYMoveSrcPonctAction : public TYModelerAction
{
public:
    TYMoveSrcPonctAction(LPTYSourcePonctuelle pSrcPonct, const TYPoint& oldPos, const TYPoint& newPos,
                         TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYMoveSrcPonctAction();
 
    void setNewPos(const TYPoint& newPos)
    {
        _newPos = newPos;
    }
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYSourcePonctuelle _pSrcPonct;
    TYPoint _oldPos;
    TYPoint _newPos;
};
 
class TYOrienteSrcPonctAction : public TYModelerAction
{
public:
    TYOrienteSrcPonctAction(LPTYSourcePonctuelle pSrcPonct, const OVector3D& oldOrient,
                            const OVector3D& newOrient, TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYOrienteSrcPonctAction();
 
    void setNewOrient(const OVector3D& newOrient)
    {
        _newOrient = newOrient;
    }
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYSourcePonctuelle _pSrcPonct;
    OVector3D _oldOrient;
    OVector3D _newOrient;
};
 
class TYMovePointControlAction : public TYModelerAction
{
public:
    TYMovePointControlAction(LPTYPointControl pPointControl, const TYPoint& oldPos, const TYPoint& newPos,
                             TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYMovePointControlAction();
 
    void setNewPos(const TYPoint& newPos)
    {
        _newPos = newPos;
    }
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYPointControl _pPointControl;
    TYPoint _oldPos;
    TYPoint _newPos;
};
 
class TYSetPointRefSiteAction : public TYModelerAction
{
public:
    TYSetPointRefSiteAction(LPTYSiteNode& pSite, const TYPoint& oldPos, const TYPoint& newPos,
                            TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYSetPointRefSiteAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYSiteNode _pSite;
    TYPoint _oldPos;
    TYPoint _newPos;
};
 
class TYSetOrientationSiteAction : public TYModelerAction
{
public:
    TYSetOrientationSiteAction(LPTYSiteNode& pSite, const TYSegment& oldOrient, const TYSegment& newOrient,
                               TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYSetOrientationSiteAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYSiteNode _pSite;
    TYSegment _oldOrient;
    TYSegment _newOrient;
};
 
class TYSetEchelleSiteAction : public TYModelerAction
{
public:
    TYSetEchelleSiteAction(LPTYSiteNode& pSite, float oldEchelle, float newEchelle, TYModelerFrame* pModeler,
                           const QString& actionName);
    virtual ~TYSetEchelleSiteAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYSiteNode _pSite;
    float _oldEchelle;
    float _newEchelle;
};
 
class TYSetEmpriseTopoAction : public TYModelerAction
{
public:
    TYSetEmpriseTopoAction(LPTYTopographie pTopo, const TYTabPoint& newEmprise, TYModelerFrame* pModeler,
                           const QString& actionName);
    virtual ~TYSetEmpriseTopoAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYTopographie _pTopo;
    TYTabPoint _oldEmprise;
    TYTabPoint _newEmprise;
};
 
class TYAddPointControlAction : public TYModelerAction
{
public:
    TYAddPointControlAction(LPTYProjet pProjet, LPTYPointControl pPtControl, TYModelerFrame* pModeler,
                            const QString& actionName);
    virtual ~TYAddPointControlAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYProjet _pProjet;
    LPTYPointControl _pPtControl;
};
 
class TYRemPointControlAction : public TYModelerAction
{
public:
    TYRemPointControlAction(LPTYProjet pProjet, LPTYPointControl pPtControl, TYModelerFrame* pModeler,
                            const QString& actionName);
    virtual ~TYRemPointControlAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYProjet _pProjet;
    LPTYPointControl _pPtControl;
};
 
class TYAddMaillageToProjetAction : public TYModelerAction
{
public:
    TYAddMaillageToProjetAction(LPTYMaillageGeoNode pMaillageGeoNode, LPTYProjet pProjet,
                                TYModelerFrame* pModeler, const QString& actionName);
    TYAddMaillageToProjetAction(LPTYMaillage pMaillage, LPTYProjet pProjet, TYModelerFrame* pModeler,
                                const QString& actionName);
    virtual ~TYAddMaillageToProjetAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYProjet _pProjet;
    LPTYMaillageGeoNode _pMaillageGeoNode;
};
 
class TYRemMaillageToProjetAction : public TYModelerAction
{
public:
    TYRemMaillageToProjetAction(LPTYMaillageGeoNode pMaillageGeoNode, LPTYProjet pProjet,
                                TYModelerFrame* pModeler, const QString& actionName);
    TYRemMaillageToProjetAction(LPTYMaillage pMaillage, LPTYProjet pProjet, TYModelerFrame* pModeler,
                                const QString& actionName);
    virtual ~TYRemMaillageToProjetAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYProjet _pProjet;
    LPTYMaillageGeoNode _pMaillageGeoNode;
};
 
class TYAddSiteNodeToSiteNodeAction : public TYModelerAction
{
public:
    TYAddSiteNodeToSiteNodeAction(LPTYSiteNodeGeoNode pSiteNodeGeoNode, LPTYSiteNode pSiteNodeParent,
                                  TYModelerFrame* pModeler, const QString& actionName);
    TYAddSiteNodeToSiteNodeAction(LPTYSiteNode pSiteNode, LPTYSiteNode pSiteNodeParent,
                                  TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYAddSiteNodeToSiteNodeAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYSiteNode _pSiteNodeParent;
    LPTYSiteNodeGeoNode _pSiteNodeGeoNode;
};
 
class TYRemSiteNodeToSiteNodeAction : public TYModelerAction
{
public:
    TYRemSiteNodeToSiteNodeAction(LPTYSiteNodeGeoNode pSiteNodeGeoNode, LPTYSiteNode pSiteNodeParent,
                                  TYModelerFrame* pModeler, const QString& actionName);
    TYRemSiteNodeToSiteNodeAction(LPTYSiteNode pSiteNode, LPTYSiteNode pSiteNodeParent,
                                  TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYRemSiteNodeToSiteNodeAction();
 
    virtual void undo();
    virtual void redo();
 
protected:
    LPTYSiteNode _pSiteNodeParent;
    LPTYSiteNodeGeoNode _pSiteNodeGeoNode;
};
 
class TYMovePointPolyLineAction : public TYModelerAction
{
public:
    TYMovePointPolyLineAction(LPTYElement pElt, TYTabPoint& polyLine, int ptId, const TYPoint& oldPos,
                              const TYPoint& newPos, TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYMovePointPolyLineAction();
 
    void setNewPos(const TYPoint& newPos)
    {
        _newPos = newPos;
    }
 
    virtual void undo();
 
    virtual void redo();
 
protected:
    LPTYElement _pElt;
    TYTabPoint& _polyLine;
    int _ptId;
    TYPoint _oldPos;
    TYPoint _newPos;
};
 
class TYInsertPointPolyLineAction : public TYModelerAction
{
public:
    TYInsertPointPolyLineAction(LPTYElement pElt, TYTabPoint& polyLine, int ptId, const TYPoint& pt,
                                TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYInsertPointPolyLineAction();
 
    virtual void undo();
 
    virtual void redo();
 
protected:
    LPTYElement _pElt;
    TYTabPoint& _polyLine;
    int _ptId;
    TYPoint _pt;
};
 
class TYRemovePointPolyLineAction : public TYModelerAction
{
public:
    TYRemovePointPolyLineAction(LPTYElement pElt, TYTabPoint& polyLine, int ptId, const TYPoint& pt,
                                TYModelerFrame* pModeler, const QString& actionName);
    virtual ~TYRemovePointPolyLineAction();
 
    virtual void undo();
 
    virtual void redo();
 
protected:
    LPTYElement _pElt;
    TYTabPoint& _polyLine;
    int _ptId;
    TYPoint _pt;
};
 
#endif // __TY_ACTIONS__