LYN-7121 | Focus Mode - Make editing a prefab an undoable operation (#4582)

* Refactor the PrefabFocusInterface to differentiate between Public and Internal functions. Introduce PrefabFocusUndo nodes to allow undoing Prefab Edit operations. Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com> * Fix selection code to avoid warning message Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com> * Removed changed property from PrefabFocusUndo node Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com> * Switch from size == 0 to empty in EntityOutlinerWidget::OnSelectionChanged Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com> * condense if check on Prefab Edit context menu item setup Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com> * Correct interface usage in PrefabIntegrationManager (interface was renamed to public) Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com> * Remove rej file that was included by mistake Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com> * Fix missing interface initialization in PrefabFocusTests Signed-off-by: Danilo Aimini <82231674+AMZN-daimini@users.noreply.github.com>
2021-10-13 12:37:07 -07:00
parent 26d53690b9
commit da3a39a6a0
15 changed files with 268 additions and 98 deletions
@@ -8,12 +8,14 @@

 #include <AzToolsFramework/Prefab/PrefabFocusHandler.h>

+#include <AzToolsFramework/Commands/SelectionCommand.h>
 #include <AzToolsFramework/ContainerEntity/ContainerEntityInterface.h>
 #include <AzToolsFramework/Entity/EditorEntityHelpers.h>
 #include <AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h>
 #include <AzToolsFramework/Prefab/Instance/Instance.h>
 #include <AzToolsFramework/Prefab/Instance/InstanceEntityMapperInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusNotificationBus.h>
+#include <AzToolsFramework/Prefab/PrefabFocusUndo.h>

 namespace AzToolsFramework::Prefab
 {
@@ -28,10 +30,12 @@ namespace AzToolsFramework::Prefab

        EditorEntityContextNotificationBus::Handler::BusConnect();
        AZ::Interface<PrefabFocusInterface>::Register(this);
+        AZ::Interface<PrefabFocusPublicInterface>::Register(this);
    }

    PrefabFocusHandler::~PrefabFocusHandler()
    {
+        AZ::Interface<PrefabFocusPublicInterface>::Unregister(this);
        AZ::Interface<PrefabFocusInterface>::Unregister(this);
        EditorEntityContextNotificationBus::Handler::BusDisconnect();
    }
@@ -61,6 +65,44 @@ namespace AzToolsFramework::Prefab
    }

    PrefabFocusOperationResult PrefabFocusHandler::FocusOnOwningPrefab(AZ::EntityId entityId)
+    {
+        // Initialize Undo Batch object
+        ScopedUndoBatch undoBatch("Edit Prefab");
+
+        // Clear selection
+        {
+            const EntityIdList selectedEntities = EntityIdList{};
+            auto selectionUndo = aznew SelectionCommand(selectedEntities, "Clear Selection");
+            selectionUndo->SetParent(undoBatch.GetUndoBatch());
+            ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::SetSelectedEntities, selectedEntities);
+        }
+
+        // Edit Prefab
+        {
+            auto editUndo = aznew PrefabFocusUndo("Edit Prefab");
+            editUndo->Capture(entityId);
+            editUndo->SetParent(undoBatch.GetUndoBatch());
+            ToolsApplicationRequestBus::Broadcast(&ToolsApplicationRequestBus::Events::RunRedoSeparately, editUndo);
+        }
+
+        return AZ::Success();
+    }
+
+    PrefabFocusOperationResult PrefabFocusHandler::FocusOnPathIndex([[maybe_unused]] AzFramework::EntityContextId entityContextId, int index)
+    {
+        if (index < 0 || index >= m_instanceFocusVector.size())
+        {
+            return AZ::Failure(AZStd::string("Prefab Focus Handler: Invalid index on FocusOnPathIndex."));
+        }
+
+        InstanceOptionalReference focusedInstance = m_instanceFocusVector[index];
+
+        FocusOnOwningPrefab(focusedInstance->get().GetContainerEntityId());
+
+        return AZ::Success();
+    }
+
+    PrefabFocusOperationResult PrefabFocusHandler::FocusOnPrefabInstanceOwningEntityId(AZ::EntityId entityId)
    {
        InstanceOptionalReference focusedInstance;

@@ -85,18 +127,6 @@ namespace AzToolsFramework::Prefab
        return FocusOnPrefabInstance(focusedInstance);
    }

-    PrefabFocusOperationResult PrefabFocusHandler::FocusOnPathIndex([[maybe_unused]] AzFramework::EntityContextId entityContextId, int index)
-    {
-        if (index < 0 || index >= m_instanceFocusVector.size())
-        {
-            return AZ::Failure(AZStd::string("Prefab Focus Handler: Invalid index on FocusOnPathIndex."));
-        }
-
-        InstanceOptionalReference focusedInstance = m_instanceFocusVector[index];
-
-        return FocusOnPrefabInstance(focusedInstance);
-    }
-
    PrefabFocusOperationResult PrefabFocusHandler::FocusOnPrefabInstance(InstanceOptionalReference focusedInstance)
    {
        if (!focusedInstance.has_value())
@@ -122,17 +152,10 @@ namespace AzToolsFramework::Prefab
            if (focusedInstance->get().GetParentInstance() != AZStd::nullopt)
            {
                containerEntityId = focusedInstance->get().GetContainerEntityId();
-
-                // Select the container entity
-                AzToolsFramework::SelectEntity(containerEntityId);
            }
            else
            {
                containerEntityId = AZ::EntityId();
-
-                // Clear the selection
-                AzToolsFramework::SelectEntities({});
-                
            }
            
            // Focus on the descendants of the container entity
@@ -161,6 +184,17 @@ namespace AzToolsFramework::Prefab
        return m_focusedInstance;
    }

+    AZ::EntityId PrefabFocusHandler::GetFocusedPrefabContainerEntityId([[maybe_unused]] AzFramework::EntityContextId entityContextId) const
+    {
+        if (!m_focusedInstance.has_value())
+        {
+            // PrefabFocusHandler has not been initialized yet.
+            return AZ::EntityId();
+        }
+
+        return m_focusedInstance->get().GetContainerEntityId();
+    }
+
    bool PrefabFocusHandler::IsOwningPrefabBeingFocused(AZ::EntityId entityId) const
    {
        if (!m_focusedInstance.has_value())
@@ -200,7 +234,7 @@ namespace AzToolsFramework::Prefab
        m_instanceFocusVector.clear();

        // Focus on the root prefab (AZ::EntityId() will default to it)
-        FocusOnOwningPrefab(AZ::EntityId());
+        FocusOnPrefabInstanceOwningEntityId(AZ::EntityId());
    }

    void PrefabFocusHandler::RefreshInstanceFocusList()
@@ -13,6 +13,7 @@
 #include <AzToolsFramework/Entity/EditorEntityContextBus.h>
 #include <AzToolsFramework/FocusMode/FocusModeInterface.h>
 #include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
 #include <AzToolsFramework/Prefab/Template/Template.h>

 namespace AzToolsFramework
@@ -28,6 +29,7 @@ namespace AzToolsFramework::Prefab
    //! Handles Prefab Focus mode, determining which prefab file entity changes will target.
    class PrefabFocusHandler final
        : private PrefabFocusInterface
+        , private PrefabFocusPublicInterface
        , private EditorEntityContextNotificationBus::Handler
    {
    public:
@@ -39,10 +41,14 @@ namespace AzToolsFramework::Prefab
        void Initialize();

        // PrefabFocusInterface overrides ...
-        PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) override;
-        PrefabFocusOperationResult FocusOnPathIndex(AzFramework::EntityContextId entityContextId, int index) override;
+        PrefabFocusOperationResult FocusOnPrefabInstanceOwningEntityId(AZ::EntityId entityId) override;
        TemplateId GetFocusedPrefabTemplateId(AzFramework::EntityContextId entityContextId) const override;
        InstanceOptionalReference GetFocusedPrefabInstance(AzFramework::EntityContextId entityContextId) const override;
+
+        // PrefabFocusPublicInterface overrides ...
+        PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) override;
+        PrefabFocusOperationResult FocusOnPathIndex(AzFramework::EntityContextId entityContextId, int index) override;
+        AZ::EntityId GetFocusedPrefabContainerEntityId(AzFramework::EntityContextId entityContextId) const override;
        bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) const override;
        const AZ::IO::Path& GetPrefabFocusPath(AzFramework::EntityContextId entityContextId) const override;
        const int GetPrefabFocusPathLength(AzFramework::EntityContextId entityContextId) const override;
@@ -20,7 +20,7 @@ namespace AzToolsFramework::Prefab
 {
    using PrefabFocusOperationResult = AZ::Outcome<void, AZStd::string>;

-    //! Interface to handle operations related to the Prefab Focus system.
+    //! Interface to handle internal operations related to the Prefab Focus system.
    class PrefabFocusInterface
    {
    public:
@@ -28,29 +28,13 @@ namespace AzToolsFramework::Prefab

        //! Set the focused prefab instance to the owning instance of the entityId provided.
        //! @param entityId The entityId of the entity whose owning instance we want the prefab system to focus on.
-        virtual PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) = 0;
-
-        //! Set the focused prefab instance to the instance at position index of the current path.
-        //! @param index The index of the instance in the current path that we want the prefab system to focus on.
-        virtual PrefabFocusOperationResult FocusOnPathIndex(AzFramework::EntityContextId entityContextId, int index) = 0;
+        virtual PrefabFocusOperationResult FocusOnPrefabInstanceOwningEntityId(AZ::EntityId entityId) = 0;

        //! Returns the template id of the instance the prefab system is focusing on.
        virtual TemplateId GetFocusedPrefabTemplateId(AzFramework::EntityContextId entityContextId) const = 0;

        //! Returns a reference to the instance the prefab system is focusing on.
        virtual InstanceOptionalReference GetFocusedPrefabInstance(AzFramework::EntityContextId entityContextId) const = 0;
-
-        //! Returns whether the entity belongs to the instance that is being focused on, or one of its descendants.
-        //! @param entityId The entityId of the queried entity.
-        //! @return true if the entity belongs to the focused instance or one of its descendants, false otherwise.
-        virtual bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) const = 0;
-
-        //! Returns the path from the root instance to the currently focused instance.
-        //! @return A path composed from the names of the container entities for the instance path.
-        virtual const AZ::IO::Path& GetPrefabFocusPath(AzFramework::EntityContextId entityContextId) const = 0;
-
-        //! Returns the size of the path to the currently focused instance.
-        virtual const int GetPrefabFocusPathLength(AzFramework::EntityContextId entityContextId) const = 0;
    };

 } // namespace AzToolsFramework::Prefab
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Interface/Interface.h>
+#include <AzCore/Serialization/SerializeContext.h>
+
+#include <AzFramework/Entity/EntityContext.h>
+
+#include <AzToolsFramework/Prefab/Instance/Instance.h>
+#include <AzToolsFramework/Prefab/Template/Template.h>
+
+namespace AzToolsFramework::Prefab
+{
+    using PrefabFocusOperationResult = AZ::Outcome<void, AZStd::string>;
+
+    //! Public Interface for external systems to utilize the Prefab Focus system.
+    class PrefabFocusPublicInterface
+    {
+    public:
+        AZ_RTTI(PrefabFocusPublicInterface, "{53EE1D18-A41F-4DB1-9B73-9448F425722E}");
+
+        //! Set the focused prefab instance to the owning instance of the entityId provided. Supports undo/redo.
+        //! @param entityId The entityId of the entity whose owning instance we want the prefab system to focus on.
+        virtual PrefabFocusOperationResult FocusOnOwningPrefab(AZ::EntityId entityId) = 0;
+
+        //! Set the focused prefab instance to the instance at position index of the current path. Supports undo/redo.
+        //! @param index The index of the instance in the current path that we want the prefab system to focus on.
+        virtual PrefabFocusOperationResult FocusOnPathIndex(AzFramework::EntityContextId entityContextId, int index) = 0;
+
+        //! Returns the entity id of the container entity for the instance the prefab system is focusing on.
+        virtual AZ::EntityId GetFocusedPrefabContainerEntityId(AzFramework::EntityContextId entityContextId) const = 0;
+
+        //! Returns whether the entity belongs to the instance that is being focused on, or one of its descendants.
+        //! @param entityId The entityId of the queried entity.
+        //! @return true if the entity belongs to the focused instance or one of its descendants, false otherwise.
+        virtual bool IsOwningPrefabBeingFocused(AZ::EntityId entityId) const = 0;
+
+        //! Returns the path from the root instance to the currently focused instance.
+        //! @return A path composed from the names of the container entities for the instance path.
+        virtual const AZ::IO::Path& GetPrefabFocusPath(AzFramework::EntityContextId entityContextId) const = 0;
+
+        //! Returns the size of the path to the currently focused instance.
+        virtual const int GetPrefabFocusPathLength(AzFramework::EntityContextId entityContextId) const = 0;
+    };
+
+} // namespace AzToolsFramework::Prefab
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include <AzToolsFramework/Prefab/PrefabFocusUndo.h>
+
+#include <AzCore/Interface/Interface.h>
+#include <AzToolsFramework/Entity/EditorEntityContextBus.h>
+#include <AzToolsFramework/Prefab/PrefabFocusInterface.h>
+#include <AzToolsFramework/Prefab/PrefabFocusPublicInterface.h>
+
+namespace AzToolsFramework::Prefab
+{
+    PrefabFocusUndo::PrefabFocusUndo(const AZStd::string& undoOperationName)
+        : UndoSystem::URSequencePoint(undoOperationName)
+    {
+        m_prefabFocusInterface = AZ::Interface<PrefabFocusInterface>::Get();
+        AZ_Assert(m_prefabFocusInterface, "PrefabFocusUndo - Failed to grab prefab focus interface");
+
+        m_prefabFocusPublicInterface = AZ::Interface<PrefabFocusPublicInterface>::Get();
+        AZ_Assert(m_prefabFocusPublicInterface, "PrefabFocusUndo - Failed to grab prefab focus public interface");
+    }
+
+    bool PrefabFocusUndo::Changed() const
+    {
+        return true;
+    }
+
+    void PrefabFocusUndo::Capture(AZ::EntityId entityId)
+    {
+        auto entityContextId = AzFramework::EntityContextId::CreateNull();
+        EditorEntityContextRequestBus::BroadcastResult(entityContextId, &EditorEntityContextRequests::GetEditorEntityContextId);
+
+        m_beforeEntityId = m_prefabFocusPublicInterface->GetFocusedPrefabContainerEntityId(entityContextId);
+        m_afterEntityId = entityId;
+    }
+
+    void PrefabFocusUndo::Undo()
+    {
+        m_prefabFocusInterface->FocusOnPrefabInstanceOwningEntityId(m_beforeEntityId);
+    }
+
+    void PrefabFocusUndo::Redo()
+    {
+        m_prefabFocusInterface->FocusOnPrefabInstanceOwningEntityId(m_afterEntityId);
+    }
+
+} // namespace AzToolsFramework::Prefab
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Component/EntityId.h>
+#include <AzToolsFramework/Undo/UndoSystem.h>
+
+namespace AzToolsFramework::Prefab
+{
+    class PrefabFocusInterface;
+    class PrefabFocusPublicInterface;
+
+    //! Undo node for prefab focus change operations.
+    class PrefabFocusUndo
+        : public UndoSystem::URSequencePoint
+    {
+    public:
+        explicit PrefabFocusUndo(const AZStd::string& undoOperationName);
+
+        bool Changed() const override;
+        void Capture(AZ::EntityId entityId);
+
+        void Undo() override;
+        void Redo() override;
+
+    protected:
+        PrefabFocusInterface* m_prefabFocusInterface = nullptr;
+        PrefabFocusPublicInterface* m_prefabFocusPublicInterface = nullptr;
+
+        AZ::EntityId m_beforeEntityId;
+        AZ::EntityId m_afterEntityId;
+    };
+} // namespace AzToolsFramework::Prefab