GRIDEDIT-1310 Added handling of multiple domains with undo

libs/MeshKernel/CMakeLists.txt

@@ -76,6 +76,7 @@ set(
   ${UNDO_SRC_DIR}/DeleteNodeAction.cpp
   ${UNDO_SRC_DIR}/FullUnstructuredGridUndo.cpp
   ${UNDO_SRC_DIR}/MeshConversionAction.cpp
+  ${UNDO_SRC_DIR}/NoActionUndo.cpp
   ${UNDO_SRC_DIR}/NodeTranslationAction.cpp
   ${UNDO_SRC_DIR}/ResetEdgeAction.cpp
   ${UNDO_SRC_DIR}/ResetNodeAction.cpp
@@ -84,6 +85,11 @@ set(
   ${UNDO_SRC_DIR}/UndoActionStack.cpp
 )
 
+set(
+  UTILITIES_SRC_LIST
+  ${UTILITIES_SRC_DIR}/Utilities.cpp
+)
+
 set(
   AVERAGING_STRATEGIES_SRC_LIST
   ${AVERAGING_STRATEGIES_SRC_DIR}/AveragingStrategyFactory.cpp
@@ -195,6 +201,7 @@ set(
   ${UNDO_INC_DIR}/DeleteNodeAction.hpp
   ${UNDO_INC_DIR}/FullUnstructuredGridUndo.hpp
   ${UNDO_INC_DIR}/MeshConversionAction.hpp
+  ${UNDO_INC_DIR}/NoActionUndo.hpp
   ${UNDO_INC_DIR}/NodeTranslationAction.hpp
   ${UNDO_INC_DIR}/ResetEdgeAction.hpp
   ${UNDO_INC_DIR}/ResetNodeAction.hpp
@@ -265,6 +272,7 @@ set(
   ${UTILITIES_INC_DIR}/RTree.hpp
   ${UTILITIES_INC_DIR}/RTreeBase.hpp
   ${UTILITIES_INC_DIR}/RTreeFactory.hpp
+  ${UTILITIES_INC_DIR}/Utilities.hpp
 )
 
 # add sources to target
@@ -359,6 +367,7 @@ source_group("Source Files/AveragingStrategies" FILES ${AVERAGING_STRATEGIES_SRC
 source_group("Source Files/CurvilinearGrid" FILES ${CURVILINEAR_GRID_SRC_LIST})
 source_group("Source Files/CurvilinearGrid/UndoActions" FILES ${CURVILINEAR_GRID_UNDO_ACTION_SRC_LIST})
 source_group("Source Files/UndoActions" FILES ${UNDO_SRC_LIST})
+source_group("Source Files/Utilities" FILES ${UTILITIES_SRC_LIST})
 
 # group the headers in IDE tree
 source_group("Header Files" FILES ${INC_LIST})

libs/MeshKernel/include/MeshKernel/CurvilinearGrid/CurvilinearGrid.hpp

@@ -92,6 +92,12 @@ namespace meshkernel
         /// @param[in] projection The projection to use
         CurvilinearGrid(lin_alg::Matrix<Point>&& grid, Projection projection);
 
+        /// @brief Move assignment operator for CurvilinearGrid
+        CurvilinearGrid& operator=(CurvilinearGrid&& copy) noexcept;
+
+        /// @brief Ccopy assignment operator for CurvilinearGrid
+        CurvilinearGrid& operator=(const CurvilinearGrid& copy);
+
         /// @brief Set the grid nodes of a curvilinear grid instance
         /// @details The matrix row index corresponds to the CurvilinearGrid n index, the matrix column index corresponds to the CurvilinearGrid m index
         /// @param[in] gridNodes The input grid points

libs/MeshKernel/include/MeshKernel/CurvilinearGrid/UndoActions/CurvilinearGridBlockUndoAction.hpp

@@ -49,6 +49,11 @@ namespace meshkernel
                                                                       const CurvilinearGridNodeIndices& startOffset,
                                                                       const CurvilinearGridNodeIndices& endOffset);
 
+        /// @brief Return unique pointer to newly created CurvilinearGridBlockUndoAction object
+        ///
+        /// The entire grid is the block
+        static std::unique_ptr<CurvilinearGridBlockUndoAction> Create(CurvilinearGrid& grid);
+
         /// @brief Constructor, node values are copied from the grid for the block specified
         CurvilinearGridBlockUndoAction(CurvilinearGrid& grid,
                                        const CurvilinearGridNodeIndices& startOffset,

libs/MeshKernel/include/MeshKernel/Mesh.hpp

@@ -356,6 +356,12 @@ namespace meshkernel
         /// @returns The resulting mesh
         Mesh& operator+=(Mesh const& rhs);
 
+        /// @brief Add meshes: result is a mesh composed of the additions
+        /// firstMesh += secondmesh results in the second mesh being added to firstMesh
+        /// @param[in] rhs The mesh to add
+        /// @returns The undo action
+        std::unique_ptr<UndoAction> Join(const Mesh& rhs);
+
         /// @brief Get the mapping/indexing from the node array mapped to valid nodes
         std::vector<UInt> GetValidNodeMapping() const;
 

libs/MeshKernel/include/MeshKernel/Operations.hpp

@@ -619,11 +619,6 @@ namespace meshkernel
     /// @returns The computed matrix norm
     [[nodiscard]] double MatrixNorm(const std::vector<double>& x, const std::vector<double>& y, const std::vector<double>& matCoefficients);
 
-    /// @brief Print the (simplified) graph in a form that can be loaded into matlab/octave.
-    ///
-    /// Only nodes and node connectivity need be printed to visualise the graph.
-    void Print(const std::vector<Point>& nodes, const std::vector<Edge>& edges, std::ostream& out = std::cout);
-
     /// @brief Increment a valid value by an increment
     inline void IncrementValidValue(UInt& value, const UInt increment)
     {

libs/MeshKernel/include/MeshKernel/UndoActions/NoActionUndo.hpp

@@ -0,0 +1,55 @@
+//---- GPL ---------------------------------------------------------------------
+//
+// Copyright (C)  Stichting Deltares, 2011-2024.
+//
+// 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 version 3.
+//
+// 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, see <http://www.gnu.org/licenses/>.
+//
+// contact: delft3d.support@deltares.nl
+// Stichting Deltares
+// P.O. Box 177
+// 2600 MH Delft, The Netherlands
+//
+// All indications and logos of, and references to, "Delft3D" and "Deltares"
+// are registered trademarks of Stichting Deltares, and remain the property of
+// Stichting Deltares. All rights reserved.
+//
+//------------------------------------------------------------------------------
+
+#pragma once
+
+#include "MeshKernel/UndoActions/UndoAction.hpp"
+
+namespace meshkernel
+{
+
+    /// @brief A very simple undo action that makes no changes
+    ///
+    /// This is required because null undo action pointers will not be added to the undo stack.
+    class NoActionUndo : public UndoAction
+    {
+    public:
+        /// @brief Allocate a NoActionUndo and return a unique_ptr to the newly created object.
+        static std::unique_ptr<NoActionUndo> Create();
+
+        /// @brief Default constructor
+        NoActionUndo() = default;
+
+    private:
+        /// @brief Perform the undo action, does not change anything
+        void DoCommit() override;
+
+        /// @brief Perform the redo action, does not change anything
+        void DoRestore() override;
+    };
+
+} // namespace meshkernel

libs/MeshKernel/include/MeshKernel/UndoActions/UndoActionStack.hpp

@@ -29,7 +29,9 @@
 
 #include <cstdint>
 #include <list>
+#include <optional>
 
+#include "MeshKernel/Constants.hpp"
 #include "MeshKernel/Definitions.hpp"
 #include "MeshKernel/UndoActions/UndoAction.hpp"
 
@@ -49,31 +51,36 @@ namespace meshkernel
         // Perhaps Short for for menu items, long form for tooltips?
         // long form for any exceptions?
 
-        /// @brief Add an UndoAction.
+        /// @brief Add an UndoAction with an associated action-id.
         ///
         /// All added undo-actions must be in the committed state, if not then a ConstraintError
         /// will be raised.
         /// No null undo-actions will be added to the stack.
         /// All restored items will be removed, since after adding a new undo-action they are no
         /// longer restore-able.
-        void Add(UndoActionPtr&& transaction);
+        void Add(UndoActionPtr&& transaction, const int actionId = constants::missing::intValue);
 
         /// @brief Undo the action at the top of the committed stack
         ///
         /// The undo-action will be moved to the restored stack in case it should be re-done.
-        /// \returns true if an undo-action was performed, false otherwise
-        bool Undo();
+        /// \returns a non-empty std::optional if an undo-action was performed, the value
+        // stored is the id used when adding the action, otherwise its empty.
+        std::optional<int> Undo();
 
         // Another name
         /// @brief Redo the action at the top of the restored stack.
         ///
         /// The undo-action will be moved to the committed stack in case it needs to be undone.
-        /// \returns true if an redo-action was performed, false otherwise
-        bool Commit();
+        /// \returns a non-empty std::optional if an Commit-action was performed, the value
+        // stored is the id used when adding the action, otherwise its empty.
+        std::optional<int> Commit();
 
         /// @brief Clear all undo actions.
         void Clear();
 
+        /// @brief Remove all undo actions with the action-id
+        UInt Remove(const int actionId);
+
         /// @brief Get the number of undo action items
         ///
         /// The total includes both the number of committed and restored actions.
@@ -82,22 +89,32 @@ namespace meshkernel
         /// @brief Get the number of undo action items
         ///
         /// The number of committed actions.
-        UInt CommittedSize() const;
+        UInt CommittedSize(const int actionId = constants::missing::intValue) const;
 
         /// @brief Get the number of undo action items
         ///
         /// The number of restored actions.
-        UInt RestoredSize() const;
+        UInt RestoredSize(const int actionId = constants::missing::intValue) const;
 
         /// \brief Compute the approximate amount of memory being used, in bytes, for all undo actions.
         std::uint64_t MemorySize() const;
 
     private:
+        /// @brief Undo actions relating to a specific entity, e.g. mesh
+        struct UndoActionForMesh
+        {
+            /// @brief Undo action.
+            UndoActionPtr m_undoAction;
+
+            /// @brief Identifier for entity associated with the action, most cases this will be a meshKernelId.
+            int m_actionId = constants::missing::intValue;
+        };
+
         /// @brief Stack of committed undo actions
-        std::list<UndoActionPtr> m_committed;
+        std::list<UndoActionForMesh> m_committed;
 
         /// @brief Stack of restored undo actions
-        std::list<UndoActionPtr> m_restored;
+        std::list<UndoActionForMesh> m_restored;
     };
 
 } // namespace meshkernel

libs/MeshKernel/include/MeshKernel/Utilities/Utilities.hpp

@@ -0,0 +1,51 @@
+//---- GPL ---------------------------------------------------------------------
+//
+// Copyright (C)  Stichting Deltares, 2011-2024.
+//
+// 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 version 3.
+//
+// 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, see <http://www.gnu.org/licenses/>.
+//
+// contact: delft3d.support@deltares.nl
+// Stichting Deltares
+// P.O. Box 177
+// 2600 MH Delft, The Netherlands
+//
+// All indications and logos of, and references to, "Delft3D" and "Deltares"
+// are registered trademarks of Stichting Deltares, and remain the property of
+// Stichting Deltares. All rights reserved.
+//
+//------------------------------------------------------------------------------
+
+#pragma once
+
+#include <iostream>
+#include <vector>
+
+#include "MeshKernel/Entities.hpp"
+#include "MeshKernel/Point.hpp"
+
+namespace meshkernel
+{
+
+    /// @brief Print the (simplified) graph in a form that can be loaded into matlab/octave.
+    ///
+    /// Only nodes and node connectivity need be printed to visualise the graph.
+    void Print(const std::vector<Point>& nodes, const std::vector<Edge>& edges, std::ostream& out = std::cout);
+
+    /// @brief Print the (simplified) graph in a form that can be loaded into matlab/octave.
+    ///
+    /// Only nodes and node connectivity need be printed to visualise the graph.
+    void Print(const std::vector<double>& xNodes,
+               const std::vector<double>& yNodes,
+               const std::vector<int>& edges, std::ostream& out = std::cout);
+
+} // namespace meshkernel

libs/MeshKernel/src/CurvilinearGrid/CurvilinearGrid.cpp

@@ -80,6 +80,60 @@ CurvilinearGrid::CurvilinearGrid(lin_alg::Matrix<Point>&& grid, Projection proje
     SetGridNodes(std::move(grid));
 }
 
+CurvilinearGrid& CurvilinearGrid::operator=(CurvilinearGrid&& copy) noexcept
+{
+    if (this != &copy)
+    {
+        m_gridNodes = std::move(copy.m_gridNodes);
+        m_gridFacesMask = std::move(copy.m_gridFacesMask);
+        m_gridNodesTypes = std::move(copy.m_gridNodesTypes);
+        m_gridIndices = std::move(copy.m_gridIndices);
+        m_RTrees = std::move(copy.m_RTrees);
+        m_edges = std::move(copy.m_edges);
+
+        m_projection = std::exchange(copy.m_projection, Projection::cartesian);
+        m_nodesRTreeRequiresUpdate = std::exchange(copy.m_nodesRTreeRequiresUpdate, false);
+        m_edgesRTreeRequiresUpdate = std::exchange(copy.m_edgesRTreeRequiresUpdate, false);
+        m_facesRTreeRequiresUpdate = std::exchange(copy.m_facesRTreeRequiresUpdate, false);
+        m_boundingBoxCache = std::exchange(copy.m_boundingBoxCache, BoundingBox());
+        m_startOffset = std::exchange(copy.m_startOffset, CurvilinearGridNodeIndices(0, 0));
+        m_endOffset = std::exchange(copy.m_endOffset, CurvilinearGridNodeIndices(0, 0));
+    }
+
+    return *this;
+}
+
+CurvilinearGrid& CurvilinearGrid::operator=(const CurvilinearGrid& copy)
+{
+    if (this != &copy)
+    {
+        m_projection = copy.m_projection;
+        m_gridNodes = copy.m_gridNodes;
+        m_gridFacesMask = copy.m_gridFacesMask;
+        m_gridNodesTypes = copy.m_gridNodesTypes;
+        m_gridIndices = copy.m_gridIndices;
+
+        m_nodesRTreeRequiresUpdate = true;
+        m_edgesRTreeRequiresUpdate = true;
+        m_facesRTreeRequiresUpdate = true;
+
+        m_RTrees.emplace(Location::Nodes, RTreeFactory::Create(m_projection));
+        m_RTrees.emplace(Location::Edges, RTreeFactory::Create(m_projection));
+        m_RTrees.emplace(Location::Faces, RTreeFactory::Create(m_projection));
+
+        m_boundingBoxCache = copy.m_boundingBoxCache;
+
+        m_edges = copy.m_edges;
+
+        m_startOffset = copy.m_startOffset;
+        m_endOffset = copy.m_endOffset;
+
+        SetGridNodes(m_gridNodes);
+    }
+
+    return *this;
+}
+
 void CurvilinearGrid::SetGridNodes(const lin_alg::Matrix<Point>& gridNodes)
 {
     if (gridNodes.rows() <= 1 || gridNodes.cols() <= 1)

libs/MeshKernel/src/CurvilinearGrid/UndoActions/CurvilinearGridBlockUndoAction.cpp

@@ -8,6 +8,13 @@ std::unique_ptr<meshkernel::CurvilinearGridBlockUndoAction> meshkernel::Curvilin
     return std::make_unique<CurvilinearGridBlockUndoAction>(grid, startOffset, endOffset);
 }
 
+std::unique_ptr<meshkernel::CurvilinearGridBlockUndoAction> meshkernel::CurvilinearGridBlockUndoAction::Create(CurvilinearGrid& grid)
+{
+    return std::make_unique<CurvilinearGridBlockUndoAction>(grid,
+                                                            CurvilinearGridNodeIndices(0, 0),
+                                                            CurvilinearGridNodeIndices(grid.NumN() - 1, grid.NumM() - 1));
+}
+
 meshkernel::CurvilinearGridBlockUndoAction::CurvilinearGridBlockUndoAction(CurvilinearGrid& grid,
                                                                            const CurvilinearGridNodeIndices& startOffset,
                                                                            const CurvilinearGridNodeIndices& endOffset)

libs/MeshKernel/src/Mesh.cpp

@@ -1011,6 +1011,13 @@ Mesh& Mesh::operator+=(Mesh const& rhs)
     return *this;
 }
 
+std::unique_ptr<meshkernel::UndoAction> Mesh::Join(const Mesh& rhs)
+{
+    std::unique_ptr<FullUnstructuredGridUndo> joinAction = FullUnstructuredGridUndo::Create(*this);
+    *this += rhs;
+    return joinAction;
+}
+
 meshkernel::UInt Mesh::GetNumValidNodes() const
 {
     return static_cast<UInt>(std::ranges::count_if(m_nodes, [](const Point& p)