#3507 Undo and Redo Meshes

[creaVtk.git] / lib / creaVtk / MeshManagerModel.cpp

diff --git a/lib/creaVtk/MeshManagerModel.cpp b/lib/creaVtk/MeshManagerModel.cpp
index c03e9e8b2268567199c8b62237d72bd8fb469b35..41b97706d227b76b8a5c27aec1e8f406befcdcd4 100644 (file)
--- a/lib/creaVtk/MeshManagerModel.cpp
+++ b/lib/creaVtk/MeshManagerModel.cpp
@@ -27,6 +27,9 @@
 
 #include "MeshManagerModel.h"
 
+//
+//HISTORY HANDLER
+//
 template <class T>
 HistoryHandler<T>::HistoryHandler(int maxElements)
 {
@@ -52,27 +55,31 @@ void HistoryHandler<T>::CleanHistory()
 }
 
 template <class T>
-T* HistoryHandler<T>::Undo()
+T* HistoryHandler<T>::Undo(T* state)
 {
-       if(!undoStack.empty() && undoStack.size()>1)
+       if(!undoStack.empty())
        {
                auto lastElem = undoStack.back();
                undoStack.pop_back();
-               redoStack.push_back(lastElem);
-               return undoStack.back();
+               redoStack.push_back(state);
+               return lastElem;//undoStack.back();
+       }else{
+               delete state;
        }
        return NULL;
 }
 
 template <class T>
-T* HistoryHandler<T>::Redo()
+T* HistoryHandler<T>::Redo(T* state)
 {
        if(!redoStack.empty())
        {
                auto lastElem = redoStack.back();
                redoStack.pop_back();
-               undoStack.push_back(lastElem);
+               undoStack.push_back(state);
                return lastElem;
+       }else{
+               delete state;
        }
        return NULL;
 }
@@ -81,6 +88,11 @@ template <class T>
 void HistoryHandler<T>::Save(T* state)
 {
        undoStack.push_back(state);
+       if(undoStack.size() > maxElements)
+       {
+               delete undoStack.front();
+               undoStack.pop_front();
+       }
        if(!redoStack.empty())
        {
                for (T* element : redoStack)
@@ -91,6 +103,26 @@ void HistoryHandler<T>::Save(T* state)
        }
 }
 
+template <class T>
+T* HistoryHandler<T>::GetPrevious()
+{
+       if(!undoStack.empty())
+       {       
+               return undoStack.back();
+       }
+       return NULL;
+}
+
+template <class T>
+T* HistoryHandler<T>::GetNext()
+{
+       if(!redoStack.empty())
+       {       
+               return redoStack.back();
+       }
+       return NULL;
+}
+
 template <class T>
 int HistoryHandler<T>::UndoSize()
 {
@@ -117,8 +149,10 @@ MeshModel::MeshModel(int id)
 
 MeshModel::MeshModel(vtkPolyData* mesh, int id)
 {
-       if(mesh != NULL){       
-               _meshBase = mesh;
+       if(mesh != NULL)
+       {
+               _meshBase = vtkPolyData::New();//mesh;
+               _meshBase->DeepCopy(mesh);
                _meshTemp = vtkPolyData::New();
                _meshTemp->DeepCopy(_meshBase);
                _meshId = id;
@@ -140,11 +174,14 @@ MeshModel::MeshModel(MeshModel* meshModel)
        _name = "mesh-" + std::to_string(meshModel->GetId());
 }
 
-MeshModel::~MeshModel(){
-       if(_meshBase != NULL){
+MeshModel::~MeshModel()
+{
+       if(_meshBase != NULL)
+       {
                _meshBase->Delete();
        }
-       if(_meshTemp != NULL){
+       if(_meshTemp != NULL)
+       {
                _meshTemp->Delete();
        }
 }
@@ -172,27 +209,28 @@ void MeshModel::SetMeshBase(vtkPolyData* mesh)
 {
     if (mesh!=NULL)
     {
-       if(_meshBase != NULL){
+       if(_meshBase != NULL)
+       {
                _meshBase->Delete();
        }
-        _meshBase = mesh;
+        _meshBase = vtkPolyData::New();
+        _meshBase->DeepCopy(mesh);
         ResetMeshTemp_();
     } // if mesh
 }
 
 void MeshModel::SetMeshMemoryMode(vtkPolyData* mesh)
 {
-       //if(_meshBase != NULL)
-       //{
-       //      _meshBase->Delete();
-       //      _meshBase = NULL;
-       //}
-       //if (_meshTemp != NULL)
-    //{
-    //    _meshTemp->Delete();
-    //    _meshTemp = NULL;
-       //}
-       _meshBase = mesh;
+       if(_meshBase != NULL)
+       {
+               _meshBase->Delete();
+               _meshBase = NULL;
+       }
+       if(mesh != NULL)
+       {
+               _meshBase = vtkPolyData::New();
+               _meshBase->DeepCopy(mesh);
+       }
 }
 
 void MeshModel::ResetMeshTemp()
@@ -239,7 +277,8 @@ MeshManagerModel::MeshManagerModel()
 {
        currentMesh = 0;
        meshId = 0;
-       history = new HistoryHandler<ManagerState>(20);
+       history = new HistoryHandler<ManagerState>(15);
+       lastModified = 0;
 }
 
 MeshManagerModel::~MeshManagerModel()
@@ -254,13 +293,7 @@ void MeshManagerModel::RefreshOutputs(bool signalBox) // virtual
 void MeshManagerModel::ResetHistory()
 {
        history->CleanHistory();
-       Save();
-}
-
-void MeshManagerModel::UpdateMeshReference(vtkPolyData* mesh)
-{
-       _meshes.at(currentMesh)->SetMeshBase(mesh);
-       RefreshOutputs(true);
+       //Save();
 }
 
 int MeshManagerModel::GetNumberOfMeshes()
@@ -270,19 +303,20 @@ int MeshManagerModel::GetNumberOfMeshes()
 
 void MeshManagerModel::AddMesh_(vtkPolyData* mesh)
 {
-       if(mesh != NULL){
+       if(mesh != NULL)
+       {
                _meshes.push_back(std::make_shared<MeshModel>(mesh, meshId));
                meshId++;
-       }
-       else{
+       }else{
                printf("PG MeshManagerModel::AddMesh Mesh is null \n");
        }
 }
 
 void MeshManagerModel::AddMesh(vtkPolyData* mesh)
 {
-       AddMesh_(mesh);
        Save();
+       AddMesh_(mesh);
+       lastModified = currentMesh;
        RefreshOutputs(true);
 }
 
@@ -302,8 +336,9 @@ void MeshManagerModel::AddMeshes_(std::vector<vtkPolyData*> meshList)
 
 void MeshManagerModel::AddMeshes(std::vector<vtkPolyData*> meshList)
 {
-       AddMeshes_(meshList);
        Save();
+       AddMeshes_(meshList);
+       lastModified = currentMesh;
        RefreshOutputs(true);
 }
 
@@ -315,8 +350,9 @@ void MeshManagerModel::AddEmptyMesh_()
 
 void MeshManagerModel::AddEmptyMesh()
 {
-       AddEmptyMesh_();
        Save();
+       AddEmptyMesh_();
+       lastModified = currentMesh;
        RefreshOutputs(true);
 }
 
@@ -338,17 +374,20 @@ void MeshManagerModel::InsertMeshesAtCurrent_(std::vector<vtkPolyData*> meshList
 
 void MeshManagerModel::InsertMeshesAtCurrent(std::vector<vtkPolyData*> meshList)
 {
-       InsertMeshesAtCurrent_(meshList);
        Save();
+       InsertMeshesAtCurrent_(meshList);
+       lastModified = currentMesh;
        RefreshOutputs(true);
 }
 
 void MeshManagerModel::SelectMesh(int i) 
 {
-       if(i >= 0 && i < _meshes.size()){
+       if(i >= 0 && i < _meshes.size())
+       {
                int prevCurrent = currentMesh;
                currentMesh = i;
-               if(prevCurrent != i){
+               if(prevCurrent != i)
+               {
                        RefreshOutputs(true);           
                }
        }
@@ -359,10 +398,12 @@ void MeshManagerModel::SelectMesh(int i)
 
 void MeshManagerModel::SelectMeshByName(std::string meshName) 
 {
-       if(!_meshes.empty()){
+       if(!_meshes.empty())
+       {
                bool found = false;
                for(int i = 0; i < _meshes.size() && !found; i++){
-                       if(_meshes.at(i)->GetName() == meshName){
+                       if(_meshes.at(i)->GetName() == meshName)
+                       {
                                found = true;
                                SelectMesh(i);
                        }
@@ -372,10 +413,12 @@ void MeshManagerModel::SelectMeshByName(std::string meshName)
 
 void MeshManagerModel::DeleteMesh_(int position)
 {
-       if(position >= 0 && position < _meshes.size()){
+       if(position >= 0 && position < _meshes.size())
+       {
                _meshes.erase(_meshes.begin() + position);
                currentMesh = currentMesh + (position <= currentMesh?-1:0);
-               if(currentMesh < 0){
+               if(currentMesh < 0)
+               {
                        currentMesh = 0;
                }
        }
@@ -383,17 +426,20 @@ void MeshManagerModel::DeleteMesh_(int position)
 
 void MeshManagerModel::DeleteMesh(int position)
 {
-       DeleteMesh_(position);
        Save();
+       DeleteMesh_(position);
+       lastModified = currentMesh;
        RefreshOutputs(true);
 }
 
 void MeshManagerModel::DeleteMeshByName(std::string meshName)
 {
-       if(!_meshes.empty()){
+       if(!_meshes.empty())
+       {
                bool found = false;
                for(int i = 0; i < _meshes.size() && !found; i++){
-                       if(_meshes.at(i)->GetName() == meshName){
+                       if(_meshes.at(i)->GetName() == meshName)
+                       {
                                found = true;
                                DeleteMesh_(i);
                                RefreshOutputs(true);
@@ -404,21 +450,24 @@ void MeshManagerModel::DeleteMeshByName(std::string meshName)
 
 void MeshManagerModel::DeleteCurrentMesh()
 {
-       if(!_meshes.empty()){
-               DeleteMesh_(currentMesh);
+       if(!_meshes.empty())
+       {
                Save();
+               DeleteMesh_(currentMesh);
+               lastModified = currentMesh;
                RefreshOutputs(true);
        }
 }
 
 void MeshManagerModel::ReplaceMesh(std::vector<vtkPolyData*> meshList)
 {
+       Save();
        if(GetNumberOfMeshes() >= 1)
        {
                DeleteMesh_(currentMesh);
        }
        InsertMeshesAtCurrent_(meshList);
-       Save();
+       lastModified = currentMesh;
        RefreshOutputs(true);
 }
 
@@ -434,15 +483,17 @@ void MeshManagerModel::DeleteAll_()
 
 void MeshManagerModel::DeleteAll()
 {
-       DeleteAll_();
        Save();
+       DeleteAll_();
+       lastModified = currentMesh;
        RefreshOutputs(true);
 }
 
 void MeshManagerModel::NextMesh()
 {
        currentMesh++;
-       if(currentMesh >= _meshes.size()){
+       if(currentMesh >= _meshes.size())
+       {
                currentMesh = _meshes.size()-1;
        }
        RefreshOutputs(true);
@@ -451,7 +502,8 @@ void MeshManagerModel::NextMesh()
 void MeshManagerModel::PreviousMesh()
 {
        currentMesh--;
-       if(currentMesh < 0){
+       if(currentMesh < 0)
+       {
                currentMesh = 0;
        }
        RefreshOutputs(true);
@@ -464,7 +516,8 @@ std::shared_ptr<MeshModel> MeshManagerModel::GetMeshModel()
 
 vtkPolyData*  MeshManagerModel::GetMeshBase()
 {
-       if(!_meshes.empty()){
+       if(!_meshes.empty())
+       {
                return _meshes.at(currentMesh)->GetMeshBase();
        }
        else{
@@ -474,7 +527,8 @@ vtkPolyData*  MeshManagerModel::GetMeshBase()
 
 vtkPolyData*  MeshManagerModel::GetMeshTemp()
 {
-       if(!_meshes.empty()){
+       if(!_meshes.empty())
+       {
                return _meshes.at(currentMesh)->GetMeshTemp();
        }
        else{
@@ -484,10 +538,12 @@ vtkPolyData*  MeshManagerModel::GetMeshTemp()
 
 void MeshManagerModel::SetMeshBase(vtkPolyData* mesh)
 {
-    if(!_meshes.empty()){
+    if(!_meshes.empty())
+    {
+        Save();
         _meshes.at(currentMesh) = std::make_shared<MeshModel>(_meshes.at(currentMesh).get());
         _meshes.at(currentMesh)->SetMeshBase(mesh);
-        Save();
+        lastModified = currentMesh;
         RefreshOutputs(true);
     }else{
        printf("PG MeshManagerModel::SetMeshBase Mesh vector is empty \n");
@@ -523,9 +579,10 @@ void MeshManagerModel::CopySetMeshBase(vtkPolyData* mesh)
 {
        if(!_meshes.empty())
        {
+               Save();
                _meshes.at(currentMesh) = std::make_shared<MeshModel>(_meshes.at(currentMesh).get());
                _meshes.at(currentMesh)->CopySetMeshBase(mesh);
-               Save();
+               lastModified = currentMesh;
                RefreshOutputs(true);
        }
        else{
@@ -542,21 +599,42 @@ std::vector<std::string> MeshManagerModel::GetMeshNames()
        return names;
 }
 
+std::vector<vtkPolyData*> MeshManagerModel::GetAllPolyDatas()
+{
+       std::vector<vtkPolyData*> polydatas;
+       for(int i = 0; i < _meshes.size(); i++){
+               polydatas.push_back(_meshes.at(i)->GetMeshBase());
+       }
+       return polydatas;
+}
+
+int MeshManagerModel::GetCurrentMesh()
+{
+       return currentMesh;
+}
+
 void MeshManagerModel::Undo()
 {      
-       RestoreState(history->Undo());
-       RefreshOutputs(true);
+       if(history->UndoSize() > 0)
+       {       
+               RestoreState(history->Undo(new ManagerState(_meshes, meshId, lastModified)));
+               RefreshOutputs(true);
+       }
 }
 
 void MeshManagerModel::Redo()
 {
-       RestoreState(history->Redo());
-       RefreshOutputs(true);
+       if(history->RedoSize() > 0)
+       {       
+               RestoreState(history->Redo(new ManagerState(_meshes, meshId, lastModified)));
+               RefreshOutputs(true);
+       }
 }
 
 void MeshManagerModel::Save()
 {
        history->Save(new ManagerState(_meshes, meshId, currentMesh));
+       //lastModified = currentMesh;
 }
 
 void MeshManagerModel::RestoreState(ManagerState* state)
@@ -565,22 +643,24 @@ void MeshManagerModel::RestoreState(ManagerState* state)
        {       
                _meshes = state->GetMeshes();
                meshId = state->GetMeshId();
-               currentMesh = state->GetCurrentMesh();
+               currentMesh = state->GetModifiedPos();
+               lastModified = state->GetModifiedPos();
        }
 }
 
 //
 //Manager State
 //
-MeshManagerModel::ManagerState::ManagerState(std::vector<std::shared_ptr<MeshModel>> meshesToSave, int meshId, int currentMesh)
+MeshManagerModel::ManagerState::ManagerState(std::vector<std::shared_ptr<MeshModel>> meshesToSave, int meshId, int modifiedPos)
 {
        savedMeshes = meshesToSave;
        savedId = meshId;
-       savedCurrentMesh = currentMesh;
+       savedModifiedPos = modifiedPos;
 }
 
 MeshManagerModel::ManagerState::~ManagerState()
 {
+       savedMeshes.clear();
 }
 
 std::vector<std::shared_ptr<MeshModel>>& MeshManagerModel::ManagerState::GetMeshes()
@@ -592,8 +672,8 @@ int MeshManagerModel::ManagerState::GetMeshId()
 {
        return savedId;
 }
-int MeshManagerModel::ManagerState::GetCurrentMesh()
+int MeshManagerModel::ManagerState::GetModifiedPos()
 {
-       return savedCurrentMesh;
+       return savedModifiedPos;
 }