Merge pull request FreeCAD#21978 from theo-vt/document_transaction

GSOC Multi file editing

Author: kadet1090

src/App/Application.cpp

@@ -587,6 +587,15 @@ Document* Application::getDocument(const char *Name) const
 
     return pos->second;
 }
+Document* Application::getDocumentOrActive(const char *Name) const
+{
+    if (!Base::Tools::isNullOrEmpty(Name)) {
+        return getDocument(Name);
+    }
+    else {
+        return getActiveDocument();
+    }
+}
 
 const char * Application::getDocumentName(const Document* doc) const
 {

src/App/Application.h

@@ -35,10 +35,12 @@
 #include <set>
 #include <map>
 #include <string>
+#include <optional>
 
 #include <Base/Observer.h>
 #include <Base/Parameter.h>
 #include <Base/ProgressIndicator.h>
+#include "TransactionDefs.h"
 
 // forward declarations
 using PyObject = struct _object;
@@ -203,6 +205,8 @@ class AppExport Application
      */
     App::Document* getDocument(const char *Name) const;
 
+    App::Document* getDocumentOrActive(const char *Name) const;
+
     /// %Path matching modes for getDocumentByPath()
     enum class PathMatchMode
     {
@@ -289,9 +293,11 @@ class AppExport Application
     /**
      * @brief Setup a pending application-wide active transaction.
      *
-     * Call this function to setup an application-wide transaction. All current
-     * pending transactions of opening documents will be committed first.
-     * However, no new transaction is created by this call. Any subsequent
+     * Call this function to setup a transaction in the currently active document
+     * if no document is active, a global transaction is created. If the current 
+     * active document already has a transaction setup it will either commit the
+     * current transaction or rename it, depending on the tmpName flag of the 
+     * currently setup transaction. No new transaction is created by this call. Any subsequent
      * changes in any current opening document will auto create a transaction
      * with the given name and ID. If more than one document is changed, the
      * transactions will share the same ID, and will be undo/redo together.
@@ -303,32 +309,45 @@ class AppExport Application
      *
      * @return The new transaction ID.
      */
-    int setActiveTransaction(const char* name, bool persist = false);
 
-    /**
-     * @brief Get the current active transaction name and ID.
+     int setActiveTransaction(TransactionName name);
+
+    /// Return the current global transaction name and ID if such a global transaction is
+    /// setup (uncommon)
+    std::string getActiveTransaction(int *tid=nullptr) const;
+
+    int openGlobalTransaction(TransactionName name);
+    int getGlobalTransaction() const;
+
+    bool transactionIsActive(int tid) const;
+    std::string getTransactionName(int tid) const;
+    bool transactionTmpName(int tid) const;
+    Document* transactionInitiator(int tid) const;
+    std::optional<TransactionDescription> transactionDescription(int tid) const;
+    void setTransactionDescription(int tid, const TransactionDescription& desc);
+    void setTransactionName(int tid, const TransactionName& name);
+
+    /** Commit/abort current active transactions
      *
      * If there is no active transaction, an empty string is returned.
      *
-     * @param[out] tid If not `nullptr`, the current active transaction ID is
-     * returned through this pointer.
-     * @return The current active transaction name.
-     */
-    const char* getActiveTransaction(int* tid = nullptr) const;
-
-    /**
-     * @brief Commit/abort current active transactions.
-     *
      * @param[in] abort: whether to abort or commit the transactions
-     * @param[in] id: by default 0 meaning that the current active transaction ID is used.
-     *
-     * Besides calling this function directly, it will be called by
-     * automatically if 1) any new transaction is created with a different ID,
-     * or 2) any transaction with the current active transaction ID is either
-     * committed or aborted.
+     * @param[in] id: by default 0 meaning that the current global transaction ID is used.
+     * 
+     * Bsides calling this function directly, it will be called by automatically
+     * if 1) any new transaction is created with a different ID, or 2) any
+     * transaction with the current active transaction ID is either committed or
+     * aborted
+     * returns true if it succeeded in closing the transaction
      */
-    void closeActiveTransaction(bool abort=false, int id=0);
-    /// @}
+    bool closeActiveTransaction(TransactionCloseMode mode = TransactionCloseMode::Commit, int id=0);
+
+    /// Internally call closeActiveTransaction(), but it makes the call site clearer
+    bool commitTransaction(int tid);
+    bool abortTransaction(int tid);
+
+
+    //@}
 
     // NOLINTBEGIN
     // clang-format off
@@ -1040,10 +1059,16 @@ class AppExport Application
 
     friend class AutoTransaction;
 
-    std::string _activeTransactionName;
-    int _activeTransactionID{0};
-    int _activeTransactionGuard{0};
-    bool _activeTransactionTmpName{false};
+    std::map<int, TransactionDescription> _activeTransactionDescriptions; // Maps transaction ID to transaction name
+    
+    int currentlyClosingID {0};
+
+    // This is the transaction ID for a global transaction
+    // Documents will take this ID if it is non-zero
+    // and generate their own otherwise
+    int _globalTransactionID { 0 };
+    bool _globalTransactionTmpName {false};
+    std::string _globalTransactionName;
 
     Base::ProgressIndicator _progressIndicator;
 

src/App/ApplicationPy.cpp

@@ -242,9 +242,7 @@ PyMethodDef ApplicationPy::Methods[] = {
      METH_VARARGS,
      "setActiveTransaction(name, persist=False) -- setup active transaction with the given name\n\n"
      "name: the transaction name\n"
-     "persist(False): by default, if the calling code is inside any invocation of a command, it\n"
-     "                will be auto closed once all commands within the current stack exists. To\n"
-     "                disable auto closing, set persist=True\n"
+     "persist(False): This parameter has no effect and is kept for compatibility reasonss"
      "Returns the transaction ID for the active transaction. An application-wide\n"
      "active transaction causes any document changes to open a transaction with\n"
      "the given name and ID."},
@@ -1201,14 +1199,14 @@ PyObject* ApplicationPy::sGetDependentObjects(PyObject* /*self*/, PyObject* args
 PyObject* ApplicationPy::sSetActiveTransaction(PyObject* /*self*/, PyObject* args)
 {
     char* name {};
-    PyObject* persist = Py_False;
+    PyObject* persist = Py_False; // Not used
     if (!PyArg_ParseTuple(args, "s|O!", &name, &PyBool_Type, &persist)) {
         return nullptr;
     }
 
     PY_TRY
     {
-        Py::Long ret(GetApplication().setActiveTransaction(name, Base::asBoolean(persist)));
+        Py::Long ret(GetApplication().setActiveTransaction(TransactionName {.name=name, .temporary=false}));
         return Py::new_reference_to(ret);
     }
     PY_CATCH;
@@ -1223,8 +1221,8 @@ PyObject* ApplicationPy::sGetActiveTransaction(PyObject* /*self*/, PyObject* arg
     PY_TRY
     {
         int id = 0;
-        const char* name = GetApplication().getActiveTransaction(&id);
-        if (!name || id <= 0) {
+        std::string name = GetApplication().getActiveTransaction(&id);
+        if (name.empty() || id <= 0) {
             Py_Return;
         }
         Py::Tuple ret(2);
@@ -1245,7 +1243,10 @@ PyObject* ApplicationPy::sCloseActiveTransaction(PyObject* /*self*/, PyObject* a
 
     PY_TRY
     {
-        GetApplication().closeActiveTransaction(Base::asBoolean(abort), id);
+        TransactionCloseMode mode = Base::asBoolean(abort)
+            ? TransactionCloseMode::Abort
+            : TransactionCloseMode::Commit;
+        GetApplication().closeActiveTransaction(mode, id);
         Py_Return;
     }
     PY_CATCH;