Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 184 insertions, 0 deletions

diff --git a/svx/source/svdraw/sdrundomanager.cxx b/svx/source/svdraw/sdrundomanager.cxx
new file mode 100644
index 0000000000..3d5fde475a
--- /dev/null
+++ b/svx/source/svdraw/sdrundomanager.cxx
@@ -0,0 +1,184 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <svx/sdrundomanager.hxx>
+#include <svx/svdundo.hxx>
+#include <sfx2/objsh.hxx>
+#include <svl/hint.hxx>
+
+SdrUndoManager::SdrUndoManager()
+    : EditUndoManager(20 /*nMaxUndoActionCount*/)
+    , mpLastUndoActionBeforeTextEdit(nullptr)
+    , mnRedoActionCountBeforeTextEdit(0)
+    , mbEndTextEditTriggeredFromUndo(false)
+    , m_pDocSh(nullptr)
+{
+}
+
+SdrUndoManager::~SdrUndoManager() {}
+
+bool SdrUndoManager::Undo()
+{
+    if (isTextEditActive())
+    {
+        bool bRetval(false);
+
+        // we are in text edit mode
+        if (GetUndoActionCount() && mpLastUndoActionBeforeTextEdit != GetUndoAction())
+        {
+            // there is an undo action for text edit, trigger it
+            bRetval = EditUndoManager::Undo();
+        }
+        else
+        {
+            // no more text edit undo, end text edit
+            mbEndTextEditTriggeredFromUndo = true;
+            maEndTextEditHdl.Call(this);
+            mbEndTextEditTriggeredFromUndo = false;
+        }
+
+        return bRetval;
+    }
+    else
+    {
+        // no undo triggered up to now, trigger local one
+        return SfxUndoManager::Undo();
+    }
+}
+
+bool SdrUndoManager::Redo()
+{
+    bool bRetval(false);
+    bool bClearRedoStack(false);
+
+    if (isTextEditActive())
+    {
+        // we are in text edit mode
+        bRetval = EditUndoManager::Redo();
+    }
+
+    if (!bRetval)
+    {
+        // Check if the current and thus to-be undone UndoAction is a SdrUndoDiagramModelData action
+        const bool bCurrentIsDiagramChange(
+            GetRedoActionCount()
+            && nullptr != dynamic_cast<SdrUndoDiagramModelData*>(GetRedoAction()));
+
+        // no redo triggered up to now, trigger local one
+        bRetval = SfxUndoManager::Redo();
+
+        // it was a SdrUndoDiagramModelData action and we have more Redo actions
+        if (bCurrentIsDiagramChange && GetRedoActionCount())
+        {
+            const bool bNextIsDiagramChange(
+                nullptr != dynamic_cast<SdrUndoDiagramModelData*>(GetRedoAction()));
+
+            // We have more Redo-actions and the 'next' one to be executed is *not* a
+            // SdrUndoDiagramModelData-action. This means that the already executed
+            // one had done a re-Layout/Re-create of the Diagram XShape/SdrObject
+            // representation based on the restored Diagram ModelData. When the next
+            // Redo action is something else (and thus will not itself re-create
+            // XShapes/SdrShapes) it may be that it is an UnGroup/Delete where a former
+            // as-content-of-Diagram created XShape/SdrShape is referenced, an action
+            // that references a XShape/SdrShape by pointer/reference. That
+            // pointer/reference *cannot* be valid anymore (now).
+
+            // The problem here is that Undo/Redo actions historically reference
+            // XShapes/SdrShapes by pointer/reference, e.g. deleting means: remove
+            // from an SdrObjList and add to an Undo action. I is *not*
+            // address/incarnation-invariant in the sense to remember e.g. to
+            // remove the Nth object in the list (that would work).
+
+            // It might be possible to solve/correct this better, but since it's
+            // a rare corner case just avoid the possible crash when continuing Redos
+            // by clearing the Redo-Stack here as a consequence
+            bClearRedoStack = !bNextIsDiagramChange;
+        }
+    }
+
+    if (bClearRedoStack)
+    {
+        // clear Redo-Stack (explanation see above)
+        ClearRedo();
+    }
+
+    return bRetval;
+}
+
+void SdrUndoManager::Clear()
+{
+    if (isTextEditActive())
+    {
+        while (GetUndoActionCount() && mpLastUndoActionBeforeTextEdit != GetUndoAction())
+        {
+            RemoveLastUndoAction();
+        }
+
+        // urgently needed: RemoveLastUndoAction does NOT correct the Redo stack by itself (!)
+        ClearRedo();
+    }
+    else
+    {
+        // call parent
+        EditUndoManager::Clear();
+    }
+}
+
+void SdrUndoManager::SetEndTextEditHdl(const Link<SdrUndoManager*, void>& rLink)
+{
+    maEndTextEditHdl = rLink;
+
+    if (isTextEditActive())
+    {
+        // text edit start, remember last non-textedit action for later cleanup
+        mpLastUndoActionBeforeTextEdit = GetUndoActionCount() ? GetUndoAction() : nullptr;
+        mnRedoActionCountBeforeTextEdit = GetRedoActionCount();
+    }
+    else
+    {
+        // text edit ends, pop all textedit actions up to the remembered non-textedit action from the start
+        // to set back the UndoManager to the state before text edit started. If that action is already gone
+        // (due to being removed from the undo stack in the meantime), all need to be removed anyways
+        while (GetUndoActionCount() && mpLastUndoActionBeforeTextEdit != GetUndoAction())
+        {
+            RemoveLastUndoAction();
+        }
+
+        // urgently needed: RemoveLastUndoAction does NOT correct the Redo stack by itself (!)
+        ClearRedo();
+
+        // forget marker again
+        mpLastUndoActionBeforeTextEdit = nullptr;
+        mnRedoActionCountBeforeTextEdit = 0;
+    }
+}
+
+bool SdrUndoManager::isTextEditActive() const { return maEndTextEditHdl.IsSet(); }
+
+void SdrUndoManager::SetDocShell(SfxObjectShell* pDocShell) { m_pDocSh = pDocShell; }
+
+void SdrUndoManager::EmptyActionsChanged()
+{
+    if (m_pDocSh)
+    {
+        m_pDocSh->Broadcast(SfxHint(SfxHintId::DocumentRepair));
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */