Moved material editor document system buses and system components to atom tools framework

Renamed document related buses and components to have generic names
Added a base document class with default implementation from which other application specific documents can be derived to work with the document system
Added document factory function registration to the document system request bus so that each application can specify the type of document it creates
Updated all comments and messaging to only refer to documents, not materials or material documents
Updated material editor and shader management console to conform to the new buses
This will provide a first pass of a common interface for a document management system that can be shared by multiple applications
Corrected status bar message copy and paste errors
Updated all test scripts to use the new buses

Signed-off-by: Guthrie Adams <guthadam@amazon.com>

AutomatedTesting/Gem/PythonTests/atom_renderer/atom_utils/material_editor_utils.py

@@ -47,28 +47,28 @@ def open_material(file_path):
     """
     :return: uuid of material document opened
     """
-    return materialeditor.MaterialDocumentSystemRequestBus(bus.Broadcast, "OpenDocument", file_path)
+    return azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(bus.Broadcast, "OpenDocument", file_path)
 
 
 def is_open(document_id):
     """
     :return: bool
     """
-    return materialeditor.MaterialDocumentRequestBus(bus.Event, "IsOpen", document_id)
+    return azlmbr.atomtools.AtomToolsDocumentRequestBus(bus.Event, "IsOpen", document_id)
 
 
 def save_document(document_id):
     """
     :return: bool success
     """
-    return materialeditor.MaterialDocumentSystemRequestBus(bus.Broadcast, "SaveDocument", document_id)
+    return azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(bus.Broadcast, "SaveDocument", document_id)
 
 
 def save_document_as_copy(document_id, target_path):
     """
     :return: bool success
     """
-    return materialeditor.MaterialDocumentSystemRequestBus(
+    return azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(
         bus.Broadcast, "SaveDocumentAsCopy", document_id, target_path
     )
 
@@ -77,7 +77,7 @@ def save_document_as_child(document_id, target_path):
     """
     :return: bool success
     """
-    return materialeditor.MaterialDocumentSystemRequestBus(
+    return azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(
         bus.Broadcast, "SaveDocumentAsChild", document_id, target_path
     )
 
@@ -86,39 +86,39 @@ def save_all():
     """
     :return: bool success
     """
-    return materialeditor.MaterialDocumentSystemRequestBus(bus.Broadcast, "SaveAllDocuments")
+    return azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(bus.Broadcast, "SaveAllDocuments")
 
 
 def close_document(document_id):
     """
     :return: bool success
     """
-    return materialeditor.MaterialDocumentSystemRequestBus(bus.Broadcast, "CloseDocument", document_id)
+    return azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(bus.Broadcast, "CloseDocument", document_id)
 
 
 def close_all_documents():
     """
     :return: bool success
     """
-    return materialeditor.MaterialDocumentSystemRequestBus(bus.Broadcast, "CloseAllDocuments")
+    return azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(bus.Broadcast, "CloseAllDocuments")
 
 
 def close_all_except_selected(document_id):
     """
     :return: bool success
     """
-    return materialeditor.MaterialDocumentSystemRequestBus(bus.Broadcast, "CloseAllDocumentsExcept", document_id)
+    return azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(bus.Broadcast, "CloseAllDocumentsExcept", document_id)
 
 
 def get_property(document_id, property_name):
     """
     :return: property value or invalid value if the document is not open or the property_name can't be found
     """
-    return materialeditor.MaterialDocumentRequestBus(bus.Event, "GetPropertyValue", document_id, property_name)
+    return azlmbr.atomtools.AtomToolsDocumentRequestBus(bus.Event, "GetPropertyValue", document_id, property_name)
 
 
 def set_property(document_id, property_name, value):
-    materialeditor.MaterialDocumentRequestBus(bus.Event, "SetPropertyValue", document_id, property_name, value)
+    azlmbr.atomtools.AtomToolsDocumentRequestBus(bus.Event, "SetPropertyValue", document_id, property_name, value)
 
 
 def is_pane_visible(pane_name):
@@ -175,7 +175,7 @@ def wait_for_condition(function, timeout_in_seconds=1.0):
     with Timeout(timeout_in_seconds) as t:
         while True:
             try:
-                atomtools.general.idle_wait_frames(1)
+                azlmbr.atomtools.general.idle_wait_frames(1)
             except Exception:
                 print("WARNING: Couldn't wait for frame")
 
@@ -269,6 +269,6 @@ class ScreenshotHelper:
 
 
 def capture_screenshot(file_path):
-    return ScreenshotHelper(atomtools.general.idle_wait_frames).capture_screenshot_blocking(
+    return ScreenshotHelper(azlmbr.atomtools.general.idle_wait_frames).capture_screenshot_blocking(
         os.path.join(file_path)
     )

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocument.h

@@ -0,0 +1,71 @@
+/*
+ * 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/RTTI/RTTI.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h>
+
+namespace AtomToolsFramework
+{
+    /**
+     * AtomToolsDocument provides an API for modifying and saving documents.
+     */
+    class AtomToolsDocument
+        : public AtomToolsDocumentRequestBus::Handler
+    {
+    public:
+        AZ_RTTI(AtomToolsDocument, "{8992DF74-88EC-438C-B280-6E71D4C0880B}");
+        AZ_CLASS_ALLOCATOR(AtomToolsDocument, AZ::SystemAllocator, 0);
+        AZ_DISABLE_COPY(AtomToolsDocument);
+
+        AtomToolsDocument();
+        virtual ~AtomToolsDocument();
+
+        const AZ::Uuid& GetId() const;
+
+        ////////////////////////////////////////////////////////////////////////
+        // AtomToolsDocumentRequestBus::Handler implementation
+        AZStd::string_view GetAbsolutePath() const override;
+        AZStd::string_view GetRelativePath() const override;
+        const AZStd::any& GetPropertyValue(const AZ::Name& propertyFullName) const override;
+        const AtomToolsFramework::DynamicProperty& GetProperty(const AZ::Name& propertyFullName) const override;
+        bool IsPropertyGroupVisible(const AZ::Name& propertyGroupFullName) const override;
+        void SetPropertyValue(const AZ::Name& propertyFullName, const AZStd::any& value) override;
+        bool Open(AZStd::string_view loadPath) override;
+        bool Rebuild() override;
+        bool Save() override;
+        bool SaveAsCopy(AZStd::string_view savePath) override;
+        bool SaveAsChild(AZStd::string_view savePath) override;
+        bool Close() override;
+        bool IsOpen() const override;
+        bool IsModified() const override;
+        bool IsSavable() const override;
+        bool CanUndo() const override;
+        bool CanRedo() const override;
+        bool Undo() override;
+        bool Redo() override;
+        bool BeginEdit() override;
+        bool EndEdit() override;
+        ////////////////////////////////////////////////////////////////////////
+
+    protected:
+
+        // Unique id of this document
+        AZ::Uuid m_id = AZ::Uuid::CreateRandom();
+
+        // Relative path to the material source file
+        AZStd::string m_relativePath;
+
+        // Absolute path to the material source file
+        AZStd::string m_absolutePath;
+
+        AZStd::any m_invalidValue;
+        
+        AtomToolsFramework::DynamicProperty m_invalidProperty;
+    };
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h

@@ -13,9 +13,9 @@
 #include <AtomToolsFramework/DynamicProperty/DynamicProperty.h>
 #include <AtomToolsFramework/DynamicProperty/DynamicPropertyGroup.h>
 
-namespace ShaderManagementConsole
+namespace AtomToolsFramework
 {
-    class ShaderManagementConsoleDocumentNotifications
+    class AtomToolsDocumentNotifications
         : public AZ::EBusTraits
     {
     public:
@@ -79,5 +79,5 @@ namespace ShaderManagementConsole
         virtual void OnDocumentPropertyGroupVisibilityChanged([[maybe_unused]] const AZ::Uuid& documentId, [[maybe_unused]] const AZ::Name& groupId, [[maybe_unused]] bool visible) {}
     };
 
-    using ShaderManagementConsoleDocumentNotificationBus = AZ::EBus<ShaderManagementConsoleDocumentNotifications>;
-} // namespace ShaderManagementConsole
+    using AtomToolsDocumentNotificationBus = AZ::EBus<AtomToolsDocumentNotifications>;
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h

@@ -0,0 +1,95 @@
+/*
+ * 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/std/any.h>
+#include <AtomToolsFramework/DynamicProperty/DynamicProperty.h>
+#include <AtomToolsFramework/DynamicProperty/DynamicPropertyGroup.h>
+
+namespace AtomToolsFramework
+{
+    class AtomToolsDocumentRequests
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
+        typedef AZ::Uuid BusIdType;
+
+        //! Get absolute path of document
+        virtual AZStd::string_view GetAbsolutePath() const = 0;
+
+        //! Get relative path of document
+        virtual AZStd::string_view GetRelativePath() const = 0;
+
+        //! Return property value
+        //! If the document is not open or the id can't be found, an invalid value is returned instead.
+        virtual const AZStd::any& GetPropertyValue(const AZ::Name& propertyFullName) const = 0;
+
+        //! Returns a property object
+        //! If the document is not open or the id can't be found, an invalid property is returned.
+        virtual const AtomToolsFramework::DynamicProperty& GetProperty(const AZ::Name& propertyFullName) const = 0;
+        
+        //! Returns whether a property group is visible
+        //! If the document is not open or the id can't be found, returns false.
+        virtual bool IsPropertyGroupVisible(const AZ::Name& propertyGroupFullName) const = 0;
+
+        //! Modify document property value
+        virtual void SetPropertyValue(const AZ::Name& propertyFullName, const AZStd::any& value) = 0;
+
+        //! Load document and related data
+        //! @param loadPath absolute path of document to load
+        virtual bool Open(AZStd::string_view loadPath) = 0;
+
+        //! Reload document preserving edits
+        virtual bool Rebuild() = 0;
+
+        //! Save document to file
+        virtual bool Save() = 0;
+
+        //! Save document copy
+        //! @param savePath absolute path where document is saved
+        virtual bool SaveAsCopy(AZStd::string_view savePath) = 0;
+
+        //! Save document to a new source file derived from of the open document
+        //! @param savePath absolute path where document is saved
+        virtual bool SaveAsChild(AZStd::string_view savePath) = 0;
+
+        //! Close document and reset its data
+        virtual bool Close() = 0;
+
+        //! Document is loaded
+        virtual bool IsOpen() const = 0;
+
+        //! Document has changes pending
+        virtual bool IsModified() const = 0;
+
+        //! Can the document be saved
+        virtual bool IsSavable() const = 0;
+
+        //! Returns true if there are reversible modifications to the document
+        virtual bool CanUndo() const = 0;
+
+        //! Returns true if there are changes that were reversed and can be re-applied to the document
+        virtual bool CanRedo() const = 0;
+
+        //! Restores the previous state of the document
+        virtual bool Undo() = 0;
+
+        //! Restores the next state of the document
+        virtual bool Redo() = 0;
+
+        //! Signal that editing is about to begin, like beginning to drag a slider control
+        virtual bool BeginEdit() = 0;
+
+        //! Signal that editing has completed, like after releasing the mouse button after continuously dragging a slider control
+        virtual bool EndEdit() = 0;
+    };
+
+    using AtomToolsDocumentRequestBus = AZ::EBus<AtomToolsDocumentRequests>;
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h

@@ -10,19 +10,21 @@
 
 #include <AzCore/EBus/EBus.h>
 
-namespace MaterialEditor
+namespace AtomToolsFramework
 {
-    static const char* MaterialExtension = "material";
-    static const char* MaterialTypeExtension = "materialtype";
+    class AtomToolsDocument;
 
-    //! MaterialDocumentSystemRequestBus provides high level file requests for menus, scripts, etc.
-    class MaterialDocumentSystemRequests
+    //! AtomToolsDocumentSystemRequestBus provides high level requests for menus, scripts, etc.
+    class AtomToolsDocumentSystemRequests
         : public AZ::EBusTraits
     {
     public:
         static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
 
+        //! Register a document factory function used to create specific document types
+        virtual void RegisterDocumentType(AZStd::function<AtomToolsDocument*()> documentCreator) = 0;
+
         //! Create a document object
         //! @return Uuid of new document, or null Uuid if failed
         virtual AZ::Uuid CreateDocument() = 0;
@@ -37,8 +39,6 @@ namespace MaterialEditor
         virtual AZ::Uuid OpenDocument(AZStd::string_view sourcePath) = 0;
 
         //! Create a new document by specifying a source and prompting the user for destination path.
-        //! If the source file is a material type then this results in creating a new material based on that type.
-        //! If the source file is a material this results in creating a child material with the source file as its parent.
         //! @param sourcePath document to open.
         //! @param targetPath location where document is saved.
         //! @return unique id of new document if successful, otherwise null Uuid
@@ -64,7 +64,7 @@ namespace MaterialEditor
         //! @param targetPath location where document is saved.
         virtual bool SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath) = 0;
 
-        //! Save the specified document to a different file, referencing the original material as its parent
+        //! Save the specified document to a different file, referencing the original document as its parent
         //! @param documentId unique id of document to save
         //! @param targetPath location where document is saved.
         virtual bool SaveDocumentAsChild(const AZ::Uuid& documentId, AZStd::string_view targetPath) = 0;
@@ -73,6 +73,6 @@ namespace MaterialEditor
         virtual bool SaveAllDocuments() = 0;
     };
 
-    using MaterialDocumentSystemRequestBus = AZ::EBus<MaterialDocumentSystemRequests>;
+    using AtomToolsDocumentSystemRequestBus = AZ::EBus<AtomToolsDocumentSystemRequests>;
 
-} // namespace MaterialEditor
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Document/AtomToolsDocumentSystemSettings.h

@@ -0,0 +1,30 @@
+/*
+ * 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
+
+#if !defined(Q_MOC_RUN)
+#include <AzCore/Memory/Memory.h>
+#include <AzCore/RTTI/RTTI.h>
+#include <AzCore/RTTI/ReflectContext.h>
+#include <AzCore/UserSettings/UserSettings.h>
+#endif
+
+namespace AtomToolsFramework
+{
+    struct AtomToolsDocumentSystemSettings
+        : public AZ::UserSettings
+    {
+        AZ_RTTI(AtomToolsDocumentSystemSettings, "{9E576D4F-A74A-4326-9135-C07284D0A3B9}", AZ::UserSettings);
+        AZ_CLASS_ALLOCATOR(AtomToolsDocumentSystemSettings, AZ::SystemAllocator, 0);
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        bool m_showReloadDocumentPrompt = true;
+    };
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/AtomToolsFrameworkModule.cpp

@@ -8,6 +8,7 @@
 
 #include <AtomToolsFrameworkModule.h>
 #include <AtomToolsFrameworkSystemComponent.h>
+#include <Document/AtomToolsDocumentSystemComponent.h>
 #include <Window/AtomToolsMainWindowSystemComponent.h>
 
 namespace AtomToolsFramework
@@ -16,6 +17,7 @@ namespace AtomToolsFramework
     {
         m_descriptors.insert(m_descriptors.end(), {
                 AtomToolsFrameworkSystemComponent::CreateDescriptor(),
+                AtomToolsDocumentSystemComponent::CreateDescriptor(),
                 AtomToolsMainWindowSystemComponent::CreateDescriptor(),
             });
     }
@@ -24,6 +26,7 @@ namespace AtomToolsFramework
     {
         return AZ::ComponentTypeList{
             azrtti_typeid<AtomToolsFrameworkSystemComponent>(),
+            azrtti_typeid<AtomToolsDocumentSystemComponent>(),
             azrtti_typeid<AtomToolsMainWindowSystemComponent>(),
         };
     }

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocument.cpp

@@ -0,0 +1,154 @@
+/*
+ * 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 <AtomToolsFramework/Document/AtomToolsDocument.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
+
+namespace AtomToolsFramework
+{
+    AtomToolsDocument::AtomToolsDocument()
+    {
+        AtomToolsDocumentRequestBus::Handler::BusConnect(m_id);
+        AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsDocumentNotificationBus::Events::OnDocumentCreated, m_id);
+    }
+
+    AtomToolsDocument::~AtomToolsDocument()
+    {
+        AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsDocumentNotificationBus::Events::OnDocumentDestroyed, m_id);
+        AtomToolsDocumentRequestBus::Handler::BusDisconnect();
+    }
+
+    const AZ::Uuid& AtomToolsDocument::GetId() const
+    {
+        return m_id;
+    }
+
+    AZStd::string_view AtomToolsDocument::GetAbsolutePath() const
+    {
+        return m_absolutePath;
+    }
+
+    AZStd::string_view AtomToolsDocument::GetRelativePath() const
+    {
+        return m_relativePath;
+    }
+
+    const AZStd::any& AtomToolsDocument::GetPropertyValue(const AZ::Name& propertyFullName) const
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return m_invalidValue;
+    }
+
+    const AtomToolsFramework::DynamicProperty& AtomToolsDocument::GetProperty(const AZ::Name& propertyFullName) const
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return m_invalidProperty;
+    }
+    
+    bool AtomToolsDocument::IsPropertyGroupVisible(const AZ::Name& propertyGroupFullName) const
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    void AtomToolsDocument::SetPropertyValue(const AZ::Name& propertyFullName, const AZStd::any& value)
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+    }
+
+    bool AtomToolsDocument::Open(AZStd::string_view loadPath)
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::Rebuild()
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::Save()
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::SaveAsCopy(AZStd::string_view savePath)
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+
+    bool AtomToolsDocument::SaveAsChild(AZStd::string_view savePath)
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::Close()
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::IsOpen() const
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::IsModified() const
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::IsSavable() const
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::CanUndo() const
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::CanRedo() const
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::Undo()
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::Redo()
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::BeginEdit()
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+
+    bool AtomToolsDocument::EndEdit()
+    {
+        AZ_Error("AtomToolsDocument", false, "%s not implemented.", __FUNCTION__);
+        return false;
+    }
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentSystemComponent.cpp

@@ -0,0 +1,511 @@
+/*
+ * 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 <AtomToolsFramework/Debug/TraceRecorder.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemSettings.h>
+#include <AtomToolsFramework/Util/Util.h>
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzFramework/Asset/AssetSystemBus.h>
+#include <AzFramework/StringFunc/StringFunc.h>
+#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
+#include <Document/AtomToolsDocumentSystemComponent.h>
+
+AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
+#include <QApplication>
+#include <QMessageBox>
+#include <QString>
+AZ_POP_DISABLE_WARNING
+
+namespace AtomToolsFramework
+{
+    AtomToolsDocumentSystemComponent::AtomToolsDocumentSystemComponent()
+    {
+    }
+
+    void AtomToolsDocumentSystemComponent::Reflect(AZ::ReflectContext* context)
+    {
+        AtomToolsDocumentSystemSettings::Reflect(context);
+
+        if (AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serialize->Class<AtomToolsDocumentSystemComponent, AZ::Component>()
+                ->Version(0);
+
+            if (AZ::EditContext* ec = serialize->GetEditContext())
+            {
+                ec->Class<AtomToolsDocumentSystemComponent>("AtomToolsDocumentSystemComponent", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC_CE("System"))
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ;
+            }
+        }
+
+        if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->EBus<AtomToolsDocumentSystemRequestBus>("AtomToolsDocumentSystemRequestBus")
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                ->Attribute(AZ::Script::Attributes::Category, "Editor")
+                ->Attribute(AZ::Script::Attributes::Module, "atomtools")
+                ->Event("CreateDocument", &AtomToolsDocumentSystemRequestBus::Events::CreateDocument)
+                ->Event("DestroyDocument", &AtomToolsDocumentSystemRequestBus::Events::DestroyDocument)
+                ->Event("OpenDocument", &AtomToolsDocumentSystemRequestBus::Events::OpenDocument)
+                ->Event("CreateDocumentFromFile", &AtomToolsDocumentSystemRequestBus::Events::CreateDocumentFromFile)
+                ->Event("CloseDocument", &AtomToolsDocumentSystemRequestBus::Events::CloseDocument)
+                ->Event("CloseAllDocuments", &AtomToolsDocumentSystemRequestBus::Events::CloseAllDocuments)
+                ->Event("CloseAllDocumentsExcept", &AtomToolsDocumentSystemRequestBus::Events::CloseAllDocumentsExcept)
+                ->Event("SaveDocument", &AtomToolsDocumentSystemRequestBus::Events::SaveDocument)
+                ->Event("SaveDocumentAsCopy", &AtomToolsDocumentSystemRequestBus::Events::SaveDocumentAsCopy)
+                ->Event("SaveDocumentAsChild", &AtomToolsDocumentSystemRequestBus::Events::SaveDocumentAsChild)
+                ->Event("SaveAllDocuments", &AtomToolsDocumentSystemRequestBus::Events::SaveAllDocuments)
+                ;
+
+            behaviorContext->EBus<AtomToolsDocumentRequestBus>("AtomToolsDocumentRequestBus")
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                ->Attribute(AZ::Script::Attributes::Category, "Editor")
+                ->Attribute(AZ::Script::Attributes::Module, "atomtools")
+                ->Event("GetAbsolutePath", &AtomToolsDocumentRequestBus::Events::GetAbsolutePath)
+                ->Event("GetRelativePath", &AtomToolsDocumentRequestBus::Events::GetRelativePath)
+                ->Event("GetPropertyValue", &AtomToolsDocumentRequestBus::Events::GetPropertyValue)
+                ->Event("SetPropertyValue", &AtomToolsDocumentRequestBus::Events::SetPropertyValue)
+                ->Event("Open", &AtomToolsDocumentRequestBus::Events::Open)
+                ->Event("Rebuild", &AtomToolsDocumentRequestBus::Events::Rebuild)
+                ->Event("Close", &AtomToolsDocumentRequestBus::Events::Close)
+                ->Event("Save", &AtomToolsDocumentRequestBus::Events::Save)
+                ->Event("SaveAsChild", &AtomToolsDocumentRequestBus::Events::SaveAsChild)
+                ->Event("SaveAsCopy", &AtomToolsDocumentRequestBus::Events::SaveAsCopy)
+                ->Event("IsOpen", &AtomToolsDocumentRequestBus::Events::IsOpen)
+                ->Event("IsModified", &AtomToolsDocumentRequestBus::Events::IsModified)
+                ->Event("IsSavable", &AtomToolsDocumentRequestBus::Events::IsSavable)
+                ->Event("CanUndo", &AtomToolsDocumentRequestBus::Events::CanUndo)
+                ->Event("CanRedo", &AtomToolsDocumentRequestBus::Events::CanRedo)
+                ->Event("Undo", &AtomToolsDocumentRequestBus::Events::Undo)
+                ->Event("Redo", &AtomToolsDocumentRequestBus::Events::Redo)
+                ->Event("BeginEdit", &AtomToolsDocumentRequestBus::Events::BeginEdit)
+                ->Event("EndEdit", &AtomToolsDocumentRequestBus::Events::EndEdit)
+                ;
+        }
+    }
+
+    void AtomToolsDocumentSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+    {
+        provided.push_back(AZ_CRC_CE("AtomToolsDocumentSystemService"));
+    }
+
+    void AtomToolsDocumentSystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+    {
+        incompatible.push_back(AZ_CRC_CE("AtomToolsDocumentSystemService"));
+    }
+
+    void AtomToolsDocumentSystemComponent::Init()
+    {
+    }
+
+    void AtomToolsDocumentSystemComponent::Activate()
+    {
+        m_documentMap.clear();
+        m_settings = AZ::UserSettings::CreateFind<AtomToolsDocumentSystemSettings>(AZ_CRC_CE("AtomToolsDocumentSystemSettings"), AZ::UserSettings::CT_GLOBAL);
+        AtomToolsDocumentSystemRequestBus::Handler::BusConnect();
+        AtomToolsDocumentNotificationBus::Handler::BusConnect();
+    }
+
+    void AtomToolsDocumentSystemComponent::Deactivate()
+    {
+        AZ::TickBus::Handler::BusDisconnect();
+        AtomToolsDocumentNotificationBus::Handler::BusDisconnect();
+        AtomToolsDocumentSystemRequestBus::Handler::BusDisconnect();
+        m_documentMap.clear();
+    }
+
+    void AtomToolsDocumentSystemComponent::RegisterDocumentType(AZStd::function<AtomToolsDocument*()> documentCreator)
+    {
+        m_documentCreator = documentCreator;
+    }
+
+    AZ::Uuid AtomToolsDocumentSystemComponent::CreateDocument()
+    {
+        if (!m_documentCreator)
+        {
+            AZ_Error("AtomToolsDocument", false, "Failed to create new document");
+            return AZ::Uuid::CreateNull();
+        }
+
+        AZStd::unique_ptr<AtomToolsDocument> document(m_documentCreator());
+        if (!document)
+        {
+            AZ_Error("AtomToolsDocument", false, "Failed to create new document");
+            return AZ::Uuid::CreateNull();
+        }
+
+        AZ::Uuid documentId = document->GetId();
+        m_documentMap.emplace(documentId, document.release());
+        return documentId;
+    }
+
+    bool AtomToolsDocumentSystemComponent::DestroyDocument(const AZ::Uuid& documentId)
+    {
+        return m_documentMap.erase(documentId) != 0;
+    }
+
+    void AtomToolsDocumentSystemComponent::OnDocumentExternallyModified(const AZ::Uuid& documentId)
+    {
+        m_documentIdsToReopen.insert(documentId);
+        if (!AZ::TickBus::Handler::BusIsConnected())
+        {
+            AZ::TickBus::Handler::BusConnect();
+        }
+    }
+
+    void AtomToolsDocumentSystemComponent::OnDocumentDependencyModified(const AZ::Uuid& documentId)
+    {
+        m_documentIdsToRebuild.insert(documentId);
+        if (!AZ::TickBus::Handler::BusIsConnected())
+        {
+            AZ::TickBus::Handler::BusConnect();
+        }
+    }
+
+    void AtomToolsDocumentSystemComponent::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
+    {
+        for (const AZ::Uuid& documentId : m_documentIdsToReopen)
+        {
+            AZStd::string documentPath;
+            AtomToolsDocumentRequestBus::EventResult(documentPath, documentId, &AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
+
+            if (m_settings->m_showReloadDocumentPrompt &&
+                (QMessageBox::question(QApplication::activeWindow(),
+                QString("Document was externally modified"),
+                QString("Would you like to reopen the document:\n%1?").arg(documentPath.c_str()),
+                QMessageBox::Yes | QMessageBox::No) != QMessageBox::Yes))
+            {
+                continue;
+            }
+
+            AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+            bool openResult = false;
+            AtomToolsDocumentRequestBus::EventResult(openResult, documentId, &AtomToolsDocumentRequestBus::Events::Open, documentPath);
+            if (!openResult)
+            {
+                QMessageBox::critical(
+                    QApplication::activeWindow(), QString("Document could not be opened"),
+                    QString("Failed to open: \n%1\n\n%2").arg(documentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
+                AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsDocumentSystemRequestBus::Events::CloseDocument, documentId);
+            }
+        }
+
+        for (const AZ::Uuid& documentId : m_documentIdsToRebuild)
+        {
+            AZStd::string documentPath;
+            AtomToolsDocumentRequestBus::EventResult(documentPath, documentId, &AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
+
+            if (m_settings->m_showReloadDocumentPrompt &&
+                (QMessageBox::question(QApplication::activeWindow(),
+                QString("Document dependencies have changed"),
+                QString("Would you like to update the document with these changes:\n%1?").arg(documentPath.c_str()),
+                QMessageBox::Yes | QMessageBox::No) != QMessageBox::Yes))
+            {
+                continue;
+            }
+
+            AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+            bool openResult = false;
+            AtomToolsDocumentRequestBus::EventResult(openResult, documentId, &AtomToolsDocumentRequestBus::Events::Rebuild);
+            if (!openResult)
+            {
+                QMessageBox::critical(
+                    QApplication::activeWindow(), QString("Document could not be opened"),
+                    QString("Failed to open: \n%1\n\n%2").arg(documentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
+                AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsDocumentSystemRequestBus::Events::CloseDocument, documentId);
+            }
+        }
+
+        m_documentIdsToRebuild.clear();
+        m_documentIdsToReopen.clear();
+        AZ::TickBus::Handler::BusDisconnect();
+    }
+
+    AZ::Uuid AtomToolsDocumentSystemComponent::OpenDocument(AZStd::string_view sourcePath)
+    {
+        return OpenDocumentImpl(sourcePath, true);
+    }
+
+    AZ::Uuid AtomToolsDocumentSystemComponent::CreateDocumentFromFile(AZStd::string_view sourcePath, AZStd::string_view targetPath)
+    {
+        const AZ::Uuid documentId = OpenDocumentImpl(sourcePath, false);
+        if (documentId.IsNull())
+        {
+            return AZ::Uuid::CreateNull();
+        }
+
+        if (!SaveDocumentAsChild(documentId, targetPath))
+        {
+            CloseDocument(documentId);
+            return AZ::Uuid::CreateNull();
+        }
+
+        // Send document open notification after creating new one
+        AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, documentId);
+        return documentId;
+    }
+
+    bool AtomToolsDocumentSystemComponent::CloseDocument(const AZ::Uuid& documentId)
+    {
+        bool isOpen = false;
+        AtomToolsDocumentRequestBus::EventResult(isOpen, documentId, &AtomToolsDocumentRequestBus::Events::IsOpen);
+        if (!isOpen)
+        {
+            // immediately destroy unopened documents
+            AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsDocumentSystemRequestBus::Events::DestroyDocument, documentId);
+            return true;
+        }
+
+        AZStd::string documentPath;
+        AtomToolsDocumentRequestBus::EventResult(documentPath, documentId, &AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
+
+        bool isModified = false;
+        AtomToolsDocumentRequestBus::EventResult(isModified, documentId, &AtomToolsDocumentRequestBus::Events::IsModified);
+        if (isModified)
+        {
+            auto selection = QMessageBox::question(QApplication::activeWindow(),
+                QString("Document has unsaved changes"),
+                QString("Do you want to save changes to\n%1?").arg(documentPath.c_str()),
+                QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
+            if (selection == QMessageBox::Cancel)
+            {
+                AZ_TracePrintf("AtomToolsDocument", "Close document canceled: %s", documentPath.c_str());
+                return false;
+            }
+            if (selection == QMessageBox::Yes)
+            {
+                if (!SaveDocument(documentId))
+                {
+                    AZ_Error("AtomToolsDocument", false, "Close document failed because document was not saved: %s", documentPath.c_str());
+                    return false;
+                }
+            }
+        }
+
+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+        bool closeResult = true;
+        AtomToolsDocumentRequestBus::EventResult(closeResult, documentId, &AtomToolsDocumentRequestBus::Events::Close);
+        if (!closeResult)
+        {
+            QMessageBox::critical(
+                QApplication::activeWindow(), QString("Document could not be closed"),
+                QString("Failed to close: \n%1\n\n%2").arg(documentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
+            return false;
+        }
+
+        AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsDocumentSystemRequestBus::Events::DestroyDocument, documentId);
+        return true;
+    }
+
+    bool AtomToolsDocumentSystemComponent::CloseAllDocuments()
+    {
+        bool result = true;
+        auto documentMap = m_documentMap;
+        for (const auto& documentPair : documentMap)
+        {
+            if (!CloseDocument(documentPair.first))
+            {
+                result = false;
+            }
+        }
+
+        return result;
+    }
+
+    bool AtomToolsDocumentSystemComponent::CloseAllDocumentsExcept(const AZ::Uuid& documentId)
+    {
+        bool result = true;
+        auto documentMap = m_documentMap;
+        for (const auto& documentPair : documentMap)
+        {
+            if (documentPair.first != documentId)
+            {
+                if (!CloseDocument(documentPair.first))
+                {
+                    result = false;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    bool AtomToolsDocumentSystemComponent::SaveDocument(const AZ::Uuid& documentId)
+    {
+        AZStd::string saveDocumentPath;
+        AtomToolsDocumentRequestBus::EventResult(saveDocumentPath, documentId, &AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
+
+        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
+        {
+            return false;
+        }
+
+        const QFileInfo saveInfo(saveDocumentPath.c_str());
+        if (saveInfo.exists() && !saveInfo.isWritable())
+        {
+            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
+            return false;
+        }
+
+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+        bool result = false;
+        AtomToolsDocumentRequestBus::EventResult(result, documentId, &AtomToolsDocumentRequestBus::Events::Save);
+        if (!result)
+        {
+            QMessageBox::critical(
+                QApplication::activeWindow(), QString("Document could not be saved"),
+                QString("Failed to save: \n%1\n\n%2").arg(saveDocumentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
+            return false;
+        }
+
+        return true;
+    }
+
+    bool AtomToolsDocumentSystemComponent::SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath)
+    {
+        AZStd::string saveDocumentPath = targetPath;
+        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
+        {
+            return false;
+        }
+
+        const QFileInfo saveInfo(saveDocumentPath.c_str());
+        if (saveInfo.exists() && !saveInfo.isWritable())
+        {
+            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
+            return false;
+        }
+
+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+        bool result = false;
+        AtomToolsDocumentRequestBus::EventResult(result, documentId, &AtomToolsDocumentRequestBus::Events::SaveAsCopy, saveDocumentPath);
+        if (!result)
+        {
+            QMessageBox::critical(
+                QApplication::activeWindow(), QString("Document could not be saved"),
+                QString("Failed to save: \n%1\n\n%2").arg(saveDocumentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
+            return false;
+        }
+
+        return true;
+    }
+
+    bool AtomToolsDocumentSystemComponent::SaveDocumentAsChild(const AZ::Uuid& documentId, AZStd::string_view targetPath)
+    {
+        AZStd::string saveDocumentPath = targetPath;
+        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
+        {
+            return false;
+        }
+
+        const QFileInfo saveInfo(saveDocumentPath.c_str());
+        if (saveInfo.exists() && !saveInfo.isWritable())
+        {
+            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
+            return false;
+        }
+
+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+        bool result = false;
+        AtomToolsDocumentRequestBus::EventResult(result, documentId, &AtomToolsDocumentRequestBus::Events::SaveAsChild, saveDocumentPath);
+        if (!result)
+        {
+            QMessageBox::critical(
+                QApplication::activeWindow(), QString("Document could not be saved"),
+                QString("Failed to save: \n%1\n\n%2").arg(saveDocumentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
+            return false;
+        }
+
+        return true;
+    }
+
+    bool AtomToolsDocumentSystemComponent::SaveAllDocuments()
+    {
+        bool result = true;
+        for (const auto& documentPair : m_documentMap)
+        {
+            if (!SaveDocument(documentPair.first))
+            {
+                result = false;
+            }
+        }
+
+        return result;
+    }
+
+    AZ::Uuid AtomToolsDocumentSystemComponent::OpenDocumentImpl(AZStd::string_view sourcePath, bool checkIfAlreadyOpen)
+    {
+        AZStd::string requestedPath = sourcePath;
+        if (requestedPath.empty())
+        {
+            return AZ::Uuid::CreateNull();
+        }
+
+        if (!AzFramework::StringFunc::Path::Normalize(requestedPath))
+        {
+            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document path is invalid:\n%1").arg(requestedPath.c_str()));
+            return AZ::Uuid::CreateNull();
+        }
+
+        // Determine if the file is already open and select it
+        if (checkIfAlreadyOpen)
+        {
+            for (const auto& documentPair : m_documentMap)
+            {
+                AZStd::string openDocumentPath;
+                AtomToolsDocumentRequestBus::EventResult(openDocumentPath, documentPair.first, &AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
+                if (openDocumentPath == requestedPath)
+                {
+                    AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, documentPair.first);
+                    return documentPair.first;
+                }
+            }
+        }
+
+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+        AZ::Uuid documentId = AZ::Uuid::CreateNull();
+        AtomToolsDocumentSystemRequestBus::BroadcastResult(documentId, &AtomToolsDocumentSystemRequestBus::Events::CreateDocument);
+        if (documentId.IsNull())
+        {
+            QMessageBox::critical(
+                QApplication::activeWindow(), QString("Document could not be created"),
+                QString("Failed to create: \n%1\n\n%2").arg(requestedPath.c_str()).arg(traceRecorder.GetDump().c_str()));
+            return AZ::Uuid::CreateNull();
+        }
+
+        traceRecorder.GetDump().clear();
+
+        bool openResult = false;
+        AtomToolsDocumentRequestBus::EventResult(openResult, documentId, &AtomToolsDocumentRequestBus::Events::Open, requestedPath);
+        if (!openResult)
+        {
+            QMessageBox::critical(
+                QApplication::activeWindow(), QString("Document could not be opened"),
+                QString("Failed to open: \n%1\n\n%2").arg(requestedPath.c_str()).arg(traceRecorder.GetDump().c_str()));
+            AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsDocumentSystemRequestBus::Events::DestroyDocument, documentId);
+            return AZ::Uuid::CreateNull();
+        }
+
+        return documentId;
+    }
+}

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentSystemComponent.h

@@ -0,0 +1,92 @@
+/*
+ * 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/Component.h>
+#include <AzCore/Component/TickBus.h>
+#include <AzCore/std/smart_ptr/shared_ptr.h>
+#include <AzCore/Asset/AssetCommon.h>
+
+#include <AtomToolsFramework/Document/AtomToolsDocument.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemSettings.h>
+
+AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
+#include <QFileInfo>
+#include <QString>
+AZ_POP_DISABLE_WARNING
+
+namespace AtomToolsFramework
+{
+    //! AtomToolsDocumentSystemComponent is the central component of the Material Editor Core gem
+    class AtomToolsDocumentSystemComponent
+        : public AZ::Component
+        , private AZ::TickBus::Handler
+        , private AtomToolsDocumentNotificationBus::Handler
+        , private AtomToolsDocumentSystemRequestBus::Handler
+    {
+    public:
+        AZ_COMPONENT(AtomToolsDocumentSystemComponent, "{343A3383-6A59-4343-851B-BF84FC6CB18E}");
+
+        AtomToolsDocumentSystemComponent();
+        ~AtomToolsDocumentSystemComponent() = default;
+        AtomToolsDocumentSystemComponent(const AtomToolsDocumentSystemComponent&) = delete;
+        AtomToolsDocumentSystemComponent& operator=(const AtomToolsDocumentSystemComponent&) = delete;
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+
+    private:
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::Component interface implementation
+        void Init() override;
+        void Activate() override;
+        void Deactivate() override;
+        ////////////////////////////////////////////////////////////////////////
+
+        //////////////////////////////////////////////////////////////////////////
+        // AtomToolsDocumentNotificationBus::Handler overrides...
+        void OnDocumentDependencyModified(const AZ::Uuid& documentId) override;
+        void OnDocumentExternallyModified(const AZ::Uuid& documentId) override;
+        //////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::TickBus::Handler overrides...
+        void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+        ////////////////////////////////////////////////////////////////////////
+
+        ////////////////////////////////////////////////////////////////////////
+        // AtomToolsDocumentSystemRequestBus::Handler overrides...
+        void RegisterDocumentType(AZStd::function<AtomToolsDocument*()> documentCreator) override;
+        AZ::Uuid CreateDocument() override;
+        bool DestroyDocument(const AZ::Uuid& documentId) override;
+        AZ::Uuid OpenDocument(AZStd::string_view sourcePath) override;
+        AZ::Uuid CreateDocumentFromFile(AZStd::string_view sourcePath, AZStd::string_view targetPath) override;
+        bool CloseDocument(const AZ::Uuid& documentId) override;
+        bool CloseAllDocuments() override;
+        bool CloseAllDocumentsExcept(const AZ::Uuid& documentId) override;
+        bool SaveDocument(const AZ::Uuid& documentId) override;
+        bool SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath) override;
+        bool SaveDocumentAsChild(const AZ::Uuid& documentId, AZStd::string_view targetPath) override;
+        bool SaveAllDocuments() override;
+        ////////////////////////////////////////////////////////////////////////
+
+        AZ::Uuid OpenDocumentImpl(AZStd::string_view sourcePath, bool checkIfAlreadyOpen);
+
+        AZStd::intrusive_ptr<AtomToolsDocumentSystemSettings> m_settings;
+        AZStd::function<AtomToolsDocument*()> m_documentCreator;
+        AZStd::unordered_map<AZ::Uuid, AZStd::shared_ptr<AtomToolsDocument>> m_documentMap;
+        AZStd::unordered_set<AZ::Uuid> m_documentIdsToRebuild;
+        AZStd::unordered_set<AZ::Uuid> m_documentIdsToReopen;
+        const size_t m_maxMessageBoxLineCount = 15;
+    };
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/Source/Document/AtomToolsDocumentSystemSettings.cpp

@@ -0,0 +1,47 @@
+/*
+ * 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 <AtomToolsFramework/Document/AtomToolsDocumentSystemSettings.h>
+#include <AzCore/RTTI/BehaviorContext.h>
+#include <AzCore/Serialization/EditContext.h>
+
+namespace AtomToolsFramework
+{
+    void AtomToolsDocumentSystemSettings::Reflect(AZ::ReflectContext* context)
+    {
+        if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serializeContext->Class<AtomToolsDocumentSystemSettings, AZ::UserSettings>()
+                ->Version(1)
+                ->Field("showReloadDocumentPrompt", &AtomToolsDocumentSystemSettings::m_showReloadDocumentPrompt)
+            ;
+
+            if (auto editContext = serializeContext->GetEditContext())
+            {
+                editContext->Class<AtomToolsDocumentSystemSettings>(
+                    "AtomToolsDocumentSystemSettings", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->DataElement(AZ::Edit::UIHandlers::Default, &AtomToolsDocumentSystemSettings::m_showReloadDocumentPrompt, "Show Reload Document Prompt", "")
+                    ;
+            }
+        }
+
+        if (auto behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
+        {
+            behaviorContext->Class<AtomToolsDocumentSystemSettings>("AtomToolsDocumentSystemSettings")
+                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
+                ->Attribute(AZ::Script::Attributes::Category, "Editor")
+                ->Attribute(AZ::Script::Attributes::Module, "atomtools")
+                ->Constructor()
+                ->Constructor<const AtomToolsDocumentSystemSettings&>()
+                ->Property("showReloadDocumentPrompt", BehaviorValueProperty(&AtomToolsDocumentSystemSettings::m_showReloadDocumentPrompt))
+                ;
+        }
+    }
+} // namespace AtomToolsFramework

Gems/Atom/Tools/AtomToolsFramework/Code/atomtoolsframework_files.cmake

@@ -11,6 +11,11 @@ set(FILES
     Include/AtomToolsFramework/Communication/LocalServer.h
     Include/AtomToolsFramework/Communication/LocalSocket.h
     Include/AtomToolsFramework/Debug/TraceRecorder.h
+    Include/AtomToolsFramework/Document/AtomToolsDocument.h
+    Include/AtomToolsFramework/Document/AtomToolsDocumentSystemSettings.h
+    Include/AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h
+    Include/AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h
+    Include/AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h
     Include/AtomToolsFramework/DynamicProperty/DynamicProperty.h
     Include/AtomToolsFramework/DynamicProperty/DynamicPropertyGroup.h
     Include/AtomToolsFramework/Inspector/InspectorWidget.h
@@ -32,6 +37,10 @@ set(FILES
     Source/Communication/LocalServer.cpp
     Source/Communication/LocalSocket.cpp
     Source/Debug/TraceRecorder.cpp
+    Source/Document/AtomToolsDocument.cpp
+    Source/Document/AtomToolsDocumentSystemSettings.cpp
+    Source/Document/AtomToolsDocumentSystemComponent.cpp
+    Source/Document/AtomToolsDocumentSystemComponent.h
     Source/DynamicProperty/DynamicProperty.cpp
     Source/DynamicProperty/DynamicPropertyGroup.cpp
     Source/Inspector/InspectorWidget.cpp

Gems/Atom/Tools/MaterialEditor/Code/Include/Atom/Core/MaterialDocumentFactoryRequestBus.h

@@ -1,36 +0,0 @@
-/*
- * 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/EBus/EBus.h>
-#include <AzCore/Asset/AssetCommon.h>
-#include <AtomCore/Instance/InstanceId.h>
-
-namespace MaterialEditor
-{
-    //! MaterialDocumentFactoryRequestBus provides a factory interface for creating and destroying material documents (in memory)
-    class MaterialDocumentFactoryRequests
-        : public AZ::EBusTraits
-    {
-    public:
-        // Only a single handler is allowed
-        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
-        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-
-        //! Create a material document object
-        //! @return Uuid of new material document, or null Uuid if failed
-        virtual AZ::Uuid CreateDocument() = 0;
-
-        //! Destroy a material document object with the specified id
-        //! @return true if Uuid was found and removed, otherwise false
-        virtual bool DestroyDocument(const AZ::Uuid& documentId) = 0;
-    };
-
-    using MaterialDocumentFactoryRequestBus = AZ::EBus<MaterialDocumentFactoryRequests>;
-
-} // namespace MaterialEditor

Gems/Atom/Tools/MaterialEditor/Code/Include/Atom/Document/MaterialDocumentNotificationBus.h

@@ -1,86 +0,0 @@
-/*
- * 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 <Atom/RPI.Reflect/Material/MaterialPropertyDescriptor.h>
-#include <Atom/RPI.Public/Material/Material.h>
-
-#include <AzCore/Asset/AssetCommon.h>
-#include <AzCore/std/any.h>
-
-#include <AtomToolsFramework/DynamicProperty/DynamicProperty.h>
-#include <AtomToolsFramework/DynamicProperty/DynamicPropertyGroup.h>
-
-namespace MaterialEditor
-{
-    class MaterialDocumentNotifications
-        : public AZ::EBusTraits
-    {
-    public:
-        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
-        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
-
-        //! Signal that a document was created
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentCreated([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document was destroyed
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentDestroyed([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document was opened
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentOpened([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document was closed
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentClosed([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document was saved
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentSaved([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document was selected
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentSelected([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document was modified
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentModified([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document dependency was modified
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentDependencyModified([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document was modified externally
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentExternallyModified([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a document undo state was updated
-        //! @param documentId unique id of document for which the notification is sent
-        virtual void OnDocumentUndoStateChanged([[maybe_unused]] const AZ::Uuid& documentId) {}
-
-        //! Signal that a property changed
-        //! @param documentId unique id of document for which the notification is sent
-        //! @param property object containing the property value and configuration that was modified
-        virtual void OnDocumentPropertyValueModified([[maybe_unused]] const AZ::Uuid& documentId, [[maybe_unused]] const AtomToolsFramework::DynamicProperty& property) {}
-
-        //! Signal that the property configuration has been changed.
-        //! @param documentId unique id of document for which the notification is sent
-        //! @param property object containing the property value and configuration that was modified
-        virtual void OnDocumentPropertyConfigModified([[maybe_unused]] const AZ::Uuid& documentId, [[maybe_unused]] const AtomToolsFramework::DynamicProperty& property) {}
-        
-        //! Signal that the property group visibility has been changed.
-        //! @param documentId unique id of document for which the notification is sent
-        //! @param groupId id of the group that changed
-        //! @param visible whether the property group is visible
-        virtual void OnDocumentPropertyGroupVisibilityChanged([[maybe_unused]] const AZ::Uuid& documentId, [[maybe_unused]] const AZ::Name& groupId, [[maybe_unused]] bool visible) {}
-    };
-
-    using MaterialDocumentNotificationBus = AZ::EBus<MaterialDocumentNotifications>;
-} // namespace MaterialEditor

Gems/Atom/Tools/MaterialEditor/Code/Include/Atom/Document/MaterialDocumentRequestBus.h

@@ -7,15 +7,10 @@
  */
 #pragma once
 
+#include <Atom/RPI.Public/Material/Material.h>
 #include <Atom/RPI.Reflect/Material/MaterialAsset.h>
 #include <Atom/RPI.Reflect/Material/MaterialPropertyDescriptor.h>
-#include <Atom/RPI.Public/Material/Material.h>
-
 #include <AzCore/Asset/AssetCommon.h>
-#include <AzCore/std/any.h>
-
-#include <AtomToolsFramework/DynamicProperty/DynamicProperty.h>
-#include <AtomToolsFramework/DynamicProperty/DynamicPropertyGroup.h>
 
 namespace AZ
 {
@@ -39,12 +34,6 @@ namespace MaterialEditor
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
         typedef AZ::Uuid BusIdType;
 
-        //! Get absolute path of document
-        virtual AZStd::string_view GetAbsolutePath() const = 0;
-
-        //! Get relative path of document
-        virtual AZStd::string_view GetRelativePath() const = 0;
-
         //! Get material asset created by MaterialDocument
         virtual AZ::Data::Asset<AZ::RPI::MaterialAsset> GetAsset() const = 0;
 
@@ -56,69 +45,6 @@ namespace MaterialEditor
 
         //! Get the internal material type source data
         virtual const AZ::RPI::MaterialTypeSourceData* GetMaterialTypeSourceData() const = 0;
-
-        //! Return property value
-        //! If the document is not open or the id can't be found, an invalid value is returned instead.
-        virtual const AZStd::any& GetPropertyValue(const AZ::Name& propertyFullName) const = 0;
-
-        //! Returns a property object
-        //! If the document is not open or the id can't be found, an invalid property is returned.
-        virtual const AtomToolsFramework::DynamicProperty& GetProperty(const AZ::Name& propertyFullName) const = 0;
-        
-        //! Returns whether a property group is visible
-        //! If the document is not open or the id can't be found, returns false.
-        virtual bool IsPropertyGroupVisible(const AZ::Name& propertyGroupFullName) const = 0;
-
-        //! Modify material property value
-        virtual void SetPropertyValue(const AZ::Name& propertyFullName, const AZStd::any& value) = 0;
-
-        //! Load document and related data
-        //! @param loadPath Absolute path of document to load
-        virtual bool Open(AZStd::string_view loadPath) = 0;
-
-        //! Reload document preserving edits
-        virtual bool Rebuild() = 0;
-
-        //! Save document to file
-        virtual bool Save() = 0;
-
-        //! Save document copy
-        //! @param savePath Absolute path where document is saved
-        virtual bool SaveAsCopy(AZStd::string_view savePath) = 0;
-
-        //! Save material to a new source file as a child of the open material
-        //! @param savePath Absolute path where material is saved
-        virtual bool SaveAsChild(AZStd::string_view savePath) = 0;
-
-        //! Close document and reset its data
-        virtual bool Close() = 0;
-
-        //! Document is loaded
-        virtual bool IsOpen() const = 0;
-
-        //! Document has changes pending
-        virtual bool IsModified() const = 0;
-
-        //! Can the document be saved
-        virtual bool IsSavable() const = 0;
-
-        //! Returns true if there are reversible modifications to the document
-        virtual bool CanUndo() const = 0;
-
-        //! Returns true if there are changes that were reversed and can be re-applied to the document
-        virtual bool CanRedo() const = 0;
-
-        //! Restores the previous state of the document
-        virtual bool Undo() = 0;
-
-        //! Restores the next state of the document
-        virtual bool Redo() = 0;
-
-        //! Signal that editing is about to begin, like beginning to drag a slider control
-        virtual bool BeginEdit() = 0;
-
-        //! Signal that editing has completed, like after releasing the mouse button after continuously dragging a slider control
-        virtual bool EndEdit() = 0;
     };
 
     using MaterialDocumentRequestBus = AZ::EBus<MaterialDocumentRequests>;

Gems/Atom/Tools/MaterialEditor/Code/Include/Atom/Document/MaterialDocumentSettings.h

@@ -20,12 +20,11 @@ namespace MaterialEditor
     struct MaterialDocumentSettings
         : public AZ::UserSettings
     {
-        AZ_RTTI(MaterialDocumentSettings, "{FA4F4BF3-BF39-4753-AAF7-AF383B868881}", AZ::UserSettings);
+        AZ_RTTI(MaterialDocumentSettings, "{12E8461F-65AD-4AD2-8A1D-82C3B1183522}", AZ::UserSettings);
         AZ_CLASS_ALLOCATOR(MaterialDocumentSettings, AZ::SystemAllocator, 0);
 
         static void Reflect(AZ::ReflectContext* context);
 
-        bool m_showReloadDocumentPrompt = true;
         AZStd::string m_defaultMaterialTypeName = "StandardPBR";
     };
 } // namespace MaterialEditor

Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocument.cpp

@@ -6,53 +6,39 @@
  *
  */
 
-#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
-#include <Atom/RPI.Reflect/Material/MaterialPropertiesLayout.h>
-#include <Atom/RPI.Reflect/Material/MaterialFunctor.h>
 #include <Atom/RPI.Edit/Common/AssetUtils.h>
 #include <Atom/RPI.Edit/Common/JsonUtils.h>
+#include <Atom/RPI.Edit/Material/MaterialFunctorSourceData.h>
 #include <Atom/RPI.Edit/Material/MaterialPropertyId.h>
 #include <Atom/RPI.Edit/Material/MaterialUtils.h>
-#include <Atom/RPI.Edit/Material/MaterialFunctorSourceData.h>
 #include <Atom/RPI.Public/Material/Material.h>
 #include <Atom/RPI.Reflect/Image/Image.h>
+#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
+#include <Atom/RPI.Reflect/Material/MaterialFunctor.h>
+#include <Atom/RPI.Reflect/Material/MaterialPropertiesLayout.h>
 #include <AtomCore/Instance/Instance.h>
-#include <Document/MaterialDocument.h>
-#include <Atom/Document/MaterialDocumentNotificationBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AtomToolsFramework/Util/MaterialPropertyUtil.h>
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/SourceControl/SourceControlAPI.h>
+#include <Document/MaterialDocument.h>
 
 namespace MaterialEditor
 {
     MaterialDocument::MaterialDocument()
+        : AtomToolsFramework::AtomToolsDocument()
     {
         MaterialDocumentRequestBus::Handler::BusConnect(m_id);
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentCreated, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentCreated, m_id);
     }
 
     MaterialDocument::~MaterialDocument()
     {
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentDestroyed, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentDestroyed, m_id);
         MaterialDocumentRequestBus::Handler::BusDisconnect();
         Clear();
     }
 
-    const AZ::Uuid& MaterialDocument::GetId() const
-    {
-        return m_id;
-    }
-
-    AZStd::string_view MaterialDocument::GetAbsolutePath() const
-    {
-        return m_absolutePath;
-    }
-
-    AZStd::string_view MaterialDocument::GetRelativePath() const
-    {
-        return m_relativePath;
-    }
-
     AZ::Data::Asset<AZ::RPI::MaterialAsset> MaterialDocument::GetAsset() const
     {
         return m_materialAsset;
@@ -170,17 +156,17 @@ namespace MaterialEditor
                 EditorMaterialFunctorResult result = RunEditorMaterialFunctors(dirtyFlags);
                 for (const Name& changedPropertyGroupName : result.m_updatedPropertyGroups)
                 {
-                    MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentPropertyGroupVisibilityChanged, m_id, changedPropertyGroupName, IsPropertyGroupVisible(changedPropertyGroupName));
+                    AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentPropertyGroupVisibilityChanged, m_id, changedPropertyGroupName, IsPropertyGroupVisible(changedPropertyGroupName));
                 }
                 for (const Name& changedPropertyName : result.m_updatedProperties)
                 {
-                    MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentPropertyConfigModified, m_id, GetProperty(changedPropertyName));
+                    AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentPropertyConfigModified, m_id, GetProperty(changedPropertyName));
                 }
             }
         }
 
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentPropertyValueModified, m_id, property);
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentModified, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentPropertyValueModified, m_id, property);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentModified, m_id);
     }
 
     bool MaterialDocument::Open(AZStd::string_view loadPath)
@@ -192,7 +178,7 @@ namespace MaterialEditor
             return false;
         }
 
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentOpened, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, m_id);
         return true;
     }
 
@@ -222,7 +208,7 @@ namespace MaterialEditor
         RestorePropertyValues(propertyValuesToRestore);
         AZStd::swap(undoHistoryToRestore, m_undoHistory);
         AZStd::swap(undoHistoryIndexToRestore, m_undoHistoryIndex);
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentOpened, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, m_id);
         return true;
     }
 
@@ -285,7 +271,7 @@ namespace MaterialEditor
 
         AZ_TracePrintf("MaterialDocument", "Material document saved: '%s'.\n", m_absolutePath.data());
 
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentSaved, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentSaved, m_id);
 
         m_saveTriggeredInternally = true;
         return true;
@@ -348,7 +334,7 @@ namespace MaterialEditor
 
         AZ_TracePrintf("MaterialDocument", "Material document saved: '%s'.\n", normalizedSavePath.c_str());
 
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentSaved, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentSaved, m_id);
 
         // If the document is saved to a new file we need to reopen the new document to update assets, paths, property deltas.
         if (!Open(normalizedSavePath))
@@ -424,7 +410,7 @@ namespace MaterialEditor
 
         AZ_TracePrintf("MaterialDocument", "Material document saved: '%s'.\n", normalizedSavePath.c_str());
 
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentSaved, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentSaved, m_id);
 
         // If the document is saved to a new file we need to reopen the new document to update assets, paths, property deltas.
         if (!Open(normalizedSavePath))
@@ -450,7 +436,7 @@ namespace MaterialEditor
 
         AZ_TracePrintf("MaterialDocument", "Material document closed: '%s'.\n", m_absolutePath.c_str());
 
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentClosed, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentClosed, m_id);
 
         // Clearing after notification so paths are still available
         Clear();
@@ -496,7 +482,7 @@ namespace MaterialEditor
             // The history index is one beyond the last executed command. Decrement the index then execute undo.
             m_undoHistory[--m_undoHistoryIndex].first();
             AZ_TracePrintf("MaterialDocument", "Material document undo: '%s'.\n", m_absolutePath.c_str());
-            MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
+            AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
             return true;
         }
         return false;
@@ -509,7 +495,7 @@ namespace MaterialEditor
             // Execute the current redo command then move the history index to the next position.
             m_undoHistory[m_undoHistoryIndex++].second();
             AZ_TracePrintf("MaterialDocument", "Material document redo: '%s'.\n", m_absolutePath.c_str());
-            MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
+            AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
             return true;
         }
         return false;
@@ -557,7 +543,7 @@ namespace MaterialEditor
 
             // Assign the index to the end of history
             m_undoHistoryIndex = aznumeric_cast<int>(m_undoHistory.size());
-            MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
+            AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
         }
 
         m_propertyValuesBeforeEdit.clear();
@@ -584,7 +570,7 @@ namespace MaterialEditor
             if (!m_saveTriggeredInternally)
             {
                 AZ_TracePrintf("MaterialDocument", "Material document changed externally: '%s'.\n", m_absolutePath.c_str());
-                MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentExternallyModified, m_id);
+                AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentExternallyModified, m_id);
             }
             m_saveTriggeredInternally = false;
         }
@@ -595,7 +581,7 @@ namespace MaterialEditor
         if (m_dependentAssetIds.find(asset->GetId()) != m_dependentAssetIds.end())
         {
             AZ_TracePrintf("MaterialDocument", "Material document dependency changed: '%s'.\n", m_absolutePath.c_str());
-            MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentDependencyModified, m_id);
+            AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentDependencyModified, m_id);
         }
     }
 

Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocument.h

@@ -18,8 +18,7 @@
 #include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
 #include <Atom/RPI.Public/Material/Material.h>
 #include <Atom/Document/MaterialDocumentRequestBus.h>
-
-#include <AtomToolsFramework/DynamicProperty/DynamicProperty.h>
+#include <AtomToolsFramework/Document/AtomToolsDocument.h>
 
 namespace MaterialEditor
 {
@@ -27,7 +26,8 @@ namespace MaterialEditor
      * MaterialDocument provides an API for modifying and saving material document properties.
      */
     class MaterialDocument
-        : public MaterialDocumentRequestBus::Handler
+        : public AtomToolsFramework::AtomToolsDocument
+        , public MaterialDocumentRequestBus::Handler
         , private AZ::TickBus::Handler
         , private AZ::Data::AssetBus::MultiHandler
         , private AzToolsFramework::AssetSystemBus::Handler
@@ -40,16 +40,9 @@ namespace MaterialEditor
         MaterialDocument();
         virtual ~MaterialDocument();
 
-        const AZ::Uuid& GetId() const;
-
         ////////////////////////////////////////////////////////////////////////
-        // MaterialDocumentRequestBus::Handler implementation
-        AZStd::string_view GetAbsolutePath() const override;
-        AZStd::string_view GetRelativePath() const override;
-        AZ::Data::Asset<AZ::RPI::MaterialAsset> GetAsset() const override;
-        AZ::Data::Instance<AZ::RPI::Material> GetInstance() const override;
-        const AZ::RPI::MaterialSourceData* GetMaterialSourceData() const override;
-        const AZ::RPI::MaterialTypeSourceData* GetMaterialTypeSourceData() const override;
+        // AtomToolsFramework::AtomToolsDocument
+        ////////////////////////////////////////////////////////////////////////
         const AZStd::any& GetPropertyValue(const AZ::Name& propertyFullName) const override;
         const AtomToolsFramework::DynamicProperty& GetProperty(const AZ::Name& propertyFullName) const override;
         bool IsPropertyGroupVisible(const AZ::Name& propertyGroupFullName) const override;
@@ -71,6 +64,14 @@ namespace MaterialEditor
         bool EndEdit() override;
         ////////////////////////////////////////////////////////////////////////
 
+        ////////////////////////////////////////////////////////////////////////
+        // MaterialDocumentRequestBus::Handler implementation
+        AZ::Data::Asset<AZ::RPI::MaterialAsset> GetAsset() const override;
+        AZ::Data::Instance<AZ::RPI::Material> GetInstance() const override;
+        const AZ::RPI::MaterialSourceData* GetMaterialSourceData() const override;
+        const AZ::RPI::MaterialTypeSourceData* GetMaterialTypeSourceData() const override;
+        ////////////////////////////////////////////////////////////////////////
+
     private:
 
         // Predicate for evaluating properties
@@ -130,21 +131,12 @@ namespace MaterialEditor
         // @return names for the set of properties and groups that have been changed or need update.
         EditorMaterialFunctorResult RunEditorMaterialFunctors(AZ::RPI::MaterialPropertyFlags dirtyFlags);
 
-        // Unique id of this material document
-        AZ::Uuid m_id = AZ::Uuid::CreateRandom();
-
         // Underlying material asset
         AZ::Data::Asset<AZ::RPI::MaterialAsset> m_materialAsset;
 
         // Material instance being edited
         AZ::Data::Instance<AZ::RPI::Material> m_materialInstance;
 
-        // Relative path to the material source file
-        AZStd::string m_relativePath;
-
-        // Absolute path to the material source file
-        AZStd::string m_absolutePath;
-
         // Asset used to open document
         AZ::Data::AssetId m_sourceAssetId;
 

Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocumentModule.cpp

@@ -7,10 +7,8 @@
  */
 
 #include <Atom/Document/MaterialDocumentModule.h>
-#include <Document/MaterialDocumentSystemComponent.h>
-
-#include <AzToolsFramework/UI/PropertyEditor/PropertyManagerComponent.h>
 #include <AzToolsFramework/Asset/AssetSystemComponent.h>
+#include <Document/MaterialDocumentSystemComponent.h>
 
 namespace MaterialEditor
 {

Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocumentSettings.cpp

@@ -18,7 +18,6 @@ namespace MaterialEditor
         {
             serializeContext->Class<MaterialDocumentSettings, AZ::UserSettings>()
                 ->Version(1)
-                ->Field("showReloadDocumentPrompt", &MaterialDocumentSettings::m_showReloadDocumentPrompt)
                 ->Field("defaultMaterialTypeName", &MaterialDocumentSettings::m_defaultMaterialTypeName)
             ;
 
@@ -28,7 +27,6 @@ namespace MaterialEditor
                     "MaterialDocumentSettings", "")
                     ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
                     ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
-                    ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialDocumentSettings::m_showReloadDocumentPrompt, "Show Reload Document Prompt", "")
                     ->DataElement(AZ::Edit::UIHandlers::Default, &MaterialDocumentSettings::m_defaultMaterialTypeName, "Default Material Type Name", "")
                     ;
             }
@@ -39,10 +37,9 @@ namespace MaterialEditor
             behaviorContext->Class<MaterialDocumentSettings>("MaterialDocumentSettings")
                 ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                 ->Attribute(AZ::Script::Attributes::Category, "Editor")
-                ->Attribute(AZ::Script::Attributes::Module, "render")
+                ->Attribute(AZ::Script::Attributes::Module, "materialeditor")
                 ->Constructor()
                 ->Constructor<const MaterialDocumentSettings&>()
-                ->Property("showReloadDocumentPrompt", BehaviorValueProperty(&MaterialDocumentSettings::m_showReloadDocumentPrompt))
                 ->Property("defaultMaterialTypeName", BehaviorValueProperty(&MaterialDocumentSettings::m_defaultMaterialTypeName))
                 ;
         }

Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocumentSystemComponent.cpp

@@ -6,40 +6,17 @@
  *
  */
 
-#include <Document/MaterialDocumentSystemComponent.h>
-
-#include <Atom/Document/MaterialDocumentNotificationBus.h>
 #include <Atom/Document/MaterialDocumentRequestBus.h>
 #include <Atom/Document/MaterialDocumentSettings.h>
-#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
-#include <Atom/RPI.Edit/Material/MaterialSourceData.h>
-#include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
-#include <AtomToolsFramework/Debug/TraceRecorder.h>
-#include <AtomToolsFramework/Util/Util.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 #include <AzCore/RTTI/BehaviorContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/SerializeContext.h>
-#include <AzFramework/Asset/AssetSystemBus.h>
-#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
-#include <AzToolsFramework/API/ViewPaneOptions.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
-#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
-
-AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
-#include <QApplication>
-#include <QFileDialog>
-#include <QMessageBox>
-#include <QString>
-#include <QStyle>
-AZ_POP_DISABLE_WARNING
+#include <Document/MaterialDocument.h>
+#include <Document/MaterialDocumentSystemComponent.h>
 
 namespace MaterialEditor
 {
-    MaterialDocumentSystemComponent::MaterialDocumentSystemComponent()
-    {
-    }
-
     void MaterialDocumentSystemComponent::Reflect(AZ::ReflectContext* context)
     {
         MaterialDocumentSettings::Reflect(context);
@@ -53,7 +30,7 @@ namespace MaterialEditor
             {
                 ec->Class<MaterialDocumentSystemComponent>("MaterialDocumentSystemComponent", "Tool for editing Atom material files")
                     ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
-                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System", 0xc94d118b))
+                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC_CE("System"))
                     ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
                     ;
             }
@@ -61,66 +38,31 @@ namespace MaterialEditor
 
         if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
         {
-            behaviorContext->EBus<MaterialDocumentSystemRequestBus>("MaterialDocumentSystemRequestBus")
-                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
-                ->Attribute(AZ::Script::Attributes::Category, "Editor")
-                ->Attribute(AZ::Script::Attributes::Module, "materialeditor")
-                ->Event("CreateDocument", &MaterialDocumentSystemRequestBus::Events::CreateDocument)
-                ->Event("DestroyDocument", &MaterialDocumentSystemRequestBus::Events::DestroyDocument)
-                ->Event("OpenDocument", &MaterialDocumentSystemRequestBus::Events::OpenDocument)
-                ->Event("CreateDocumentFromFile", &MaterialDocumentSystemRequestBus::Events::CreateDocumentFromFile)
-                ->Event("CloseDocument", &MaterialDocumentSystemRequestBus::Events::CloseDocument)
-                ->Event("CloseAllDocuments", &MaterialDocumentSystemRequestBus::Events::CloseAllDocuments)
-                ->Event("CloseAllDocumentsExcept", &MaterialDocumentSystemRequestBus::Events::CloseAllDocumentsExcept)
-                ->Event("SaveDocument", &MaterialDocumentSystemRequestBus::Events::SaveDocument)
-                ->Event("SaveDocumentAsCopy", &MaterialDocumentSystemRequestBus::Events::SaveDocumentAsCopy)
-                ->Event("SaveDocumentAsChild", &MaterialDocumentSystemRequestBus::Events::SaveDocumentAsChild)
-                ->Event("SaveAllDocuments", &MaterialDocumentSystemRequestBus::Events::SaveAllDocuments)
-                ;
-
             behaviorContext->EBus<MaterialDocumentRequestBus>("MaterialDocumentRequestBus")
                 ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                 ->Attribute(AZ::Script::Attributes::Category, "Editor")
                 ->Attribute(AZ::Script::Attributes::Module, "materialeditor")
-                ->Event("GetAbsolutePath", &MaterialDocumentRequestBus::Events::GetAbsolutePath)
-                ->Event("GetRelativePath", &MaterialDocumentRequestBus::Events::GetRelativePath)
-                ->Event("GetPropertyValue", &MaterialDocumentRequestBus::Events::GetPropertyValue)
-                ->Event("SetPropertyValue", &MaterialDocumentRequestBus::Events::SetPropertyValue)
-                ->Event("Open", &MaterialDocumentRequestBus::Events::Open)
-                ->Event("Rebuild", &MaterialDocumentRequestBus::Events::Rebuild)
-                ->Event("Close", &MaterialDocumentRequestBus::Events::Close)
-                ->Event("Save", &MaterialDocumentRequestBus::Events::Save)
-                ->Event("SaveAsChild", &MaterialDocumentRequestBus::Events::SaveAsChild)
-                ->Event("SaveAsCopy", &MaterialDocumentRequestBus::Events::SaveAsCopy)
-                ->Event("IsOpen", &MaterialDocumentRequestBus::Events::IsOpen)
-                ->Event("IsModified", &MaterialDocumentRequestBus::Events::IsModified)
-                ->Event("IsSavable", &MaterialDocumentRequestBus::Events::IsSavable)
-                ->Event("CanUndo", &MaterialDocumentRequestBus::Events::CanUndo)
-                ->Event("CanRedo", &MaterialDocumentRequestBus::Events::CanRedo)
-                ->Event("Undo", &MaterialDocumentRequestBus::Events::Undo)
-                ->Event("Redo", &MaterialDocumentRequestBus::Events::Redo)
-                ->Event("BeginEdit", &MaterialDocumentRequestBus::Events::BeginEdit)
-                ->Event("EndEdit", &MaterialDocumentRequestBus::Events::EndEdit)
                 ;
         }
     }
 
     void MaterialDocumentSystemComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
     {
-        required.push_back(AZ_CRC("AssetProcessorToolsConnection", 0x734669bc));
-        required.push_back(AZ_CRC("AssetDatabaseService", 0x3abf5601));
-        required.push_back(AZ_CRC("PropertyManagerService", 0x63a3d7ad));
-        required.push_back(AZ_CRC("RPISystem", 0xf2add773));
+        required.push_back(AZ_CRC_CE("AtomToolsDocumentSystemService"));
+        required.push_back(AZ_CRC_CE("AssetProcessorToolsConnection"));
+        required.push_back(AZ_CRC_CE("AssetDatabaseService"));
+        required.push_back(AZ_CRC_CE("PropertyManagerService"));
+        required.push_back(AZ_CRC_CE("RPISystem"));
     }
 
     void MaterialDocumentSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
     {
-        provided.push_back(AZ_CRC("MaterialDocumentSystemService"));
+        provided.push_back(AZ_CRC_CE("MaterialDocumentSystemService"));
     }
 
     void MaterialDocumentSystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
     {
-        incompatible.push_back(AZ_CRC("MaterialDocumentSystemService"));
+        incompatible.push_back(AZ_CRC_CE("MaterialDocumentSystemService"));
     }
 
     void MaterialDocumentSystemComponent::Init()
@@ -129,388 +71,15 @@ namespace MaterialEditor
 
     void MaterialDocumentSystemComponent::Activate()
     {
-        m_documentMap.clear();
-        m_settings = AZ::UserSettings::CreateFind<MaterialDocumentSettings>(AZ::Crc32("MaterialDocumentSettings"), AZ::UserSettings::CT_GLOBAL);
-        MaterialDocumentSystemRequestBus::Handler::BusConnect();
-        MaterialDocumentNotificationBus::Handler::BusConnect();
+        AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(
+            &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Handler::RegisterDocumentType,
+            []()
+            {
+                return aznew MaterialDocument();
+            });
     }
 
     void MaterialDocumentSystemComponent::Deactivate()
     {
-        AZ::TickBus::Handler::BusDisconnect();
-        MaterialDocumentNotificationBus::Handler::BusDisconnect();
-        MaterialDocumentSystemRequestBus::Handler::BusDisconnect();
-        m_documentMap.clear();
-    }
-
-    AZ::Uuid MaterialDocumentSystemComponent::CreateDocument()
-    {
-        auto document = AZStd::make_unique<MaterialDocument>();
-        if (!document)
-        {
-            AZ_Error("MaterialDocument", false, "Failed to create new document");
-            return AZ::Uuid::CreateNull();
-        }
-
-        AZ::Uuid documentId = document->GetId();
-        m_documentMap.emplace(documentId, document.release());
-        return documentId;
-    }
-
-    bool MaterialDocumentSystemComponent::DestroyDocument(const AZ::Uuid& documentId)
-    {
-        return m_documentMap.erase(documentId) != 0;
-    }
-
-    void MaterialDocumentSystemComponent::OnDocumentExternallyModified(const AZ::Uuid& documentId)
-    {
-        m_documentIdsToReopen.insert(documentId);
-        if (!AZ::TickBus::Handler::BusIsConnected())
-        {
-            AZ::TickBus::Handler::BusConnect();
-        }
-    }
-
-    void MaterialDocumentSystemComponent::OnDocumentDependencyModified(const AZ::Uuid& documentId)
-    {
-        m_documentIdsToRebuild.insert(documentId);
-        if (!AZ::TickBus::Handler::BusIsConnected())
-        {
-            AZ::TickBus::Handler::BusConnect();
-        }
-    }
-
-    void MaterialDocumentSystemComponent::OnTick([[maybe_unused]] float deltaTime, [[maybe_unused]] AZ::ScriptTimePoint time)
-    {
-        for (const AZ::Uuid& documentId : m_documentIdsToReopen)
-        {
-            AZStd::string documentPath;
-            MaterialDocumentRequestBus::EventResult(documentPath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
-
-            if (m_settings->m_showReloadDocumentPrompt &&
-                (QMessageBox::question(QApplication::activeWindow(),
-                QString("Document was externally modified"),
-                QString("Would you like to reopen the document:\n%1?").arg(documentPath.c_str()),
-                QMessageBox::Yes | QMessageBox::No) != QMessageBox::Yes))
-            {
-                continue;
-            }
-
-            AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-            bool openResult = false;
-            MaterialDocumentRequestBus::EventResult(openResult, documentId, &MaterialDocumentRequestBus::Events::Open, documentPath);
-            if (!openResult)
-            {
-                QMessageBox::critical(
-                    QApplication::activeWindow(), QString("Document could not be opened"),
-                    QString("Failed to open: \n%1\n\n%2").arg(documentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CloseDocument, documentId);
-            }
-        }
-
-        for (const AZ::Uuid& documentId : m_documentIdsToRebuild)
-        {
-            AZStd::string documentPath;
-            MaterialDocumentRequestBus::EventResult(documentPath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
-
-            if (m_settings->m_showReloadDocumentPrompt &&
-                (QMessageBox::question(QApplication::activeWindow(),
-                QString("Document dependencies have changed"),
-                QString("Would you like to update the document with these changes:\n%1?").arg(documentPath.c_str()),
-                QMessageBox::Yes | QMessageBox::No) != QMessageBox::Yes))
-            {
-                continue;
-            }
-
-            AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-            bool openResult = false;
-            MaterialDocumentRequestBus::EventResult(openResult, documentId, &MaterialDocumentRequestBus::Events::Rebuild);
-            if (!openResult)
-            {
-                QMessageBox::critical(
-                    QApplication::activeWindow(), QString("Document could not be opened"),
-                    QString("Failed to open: \n%1\n\n%2").arg(documentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CloseDocument, documentId);
-            }
-        }
-
-        m_documentIdsToRebuild.clear();
-        m_documentIdsToReopen.clear();
-        AZ::TickBus::Handler::BusDisconnect();
-    }
-
-    AZ::Uuid MaterialDocumentSystemComponent::OpenDocument(AZStd::string_view sourcePath)
-    {
-        return OpenDocumentImpl(sourcePath, true);
-    }
-
-    AZ::Uuid MaterialDocumentSystemComponent::CreateDocumentFromFile(AZStd::string_view sourcePath, AZStd::string_view targetPath)
-    {
-        const AZ::Uuid documentId = OpenDocumentImpl(sourcePath, false);
-        if (documentId.IsNull())
-        {
-            return AZ::Uuid::CreateNull();
-        }
-
-        if (!SaveDocumentAsChild(documentId, targetPath))
-        {
-            CloseDocument(documentId);
-            return AZ::Uuid::CreateNull();
-        }
-
-        // Send document open notification after creating new material
-        MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentOpened, documentId);
-        return documentId;
-    }
-
-    bool MaterialDocumentSystemComponent::CloseDocument(const AZ::Uuid& documentId)
-    {
-        bool isOpen = false;
-        MaterialDocumentRequestBus::EventResult(isOpen, documentId, &MaterialDocumentRequestBus::Events::IsOpen);
-        if (!isOpen)
-        {
-            // immediately destroy unopened documents
-            MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::DestroyDocument, documentId);
-            return true;
-        }
-
-        AZStd::string documentPath;
-        MaterialDocumentRequestBus::EventResult(documentPath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
-
-        bool isModified = false;
-        MaterialDocumentRequestBus::EventResult(isModified, documentId, &MaterialDocumentRequestBus::Events::IsModified);
-        if (isModified)
-        {
-            auto selection = QMessageBox::question(QApplication::activeWindow(),
-                QString("Document has unsaved changes"),
-                QString("Do you want to save changes to\n%1?").arg(documentPath.c_str()),
-                QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
-            if (selection == QMessageBox::Cancel)
-            {
-                AZ_TracePrintf("MaterialDocument", "Close document canceled: %s", documentPath.c_str());
-                return false;
-            }
-            if (selection == QMessageBox::Yes)
-            {
-                if (!SaveDocument(documentId))
-                {
-                    AZ_Error("MaterialDocument", false, "Close document failed because document was not saved: %s", documentPath.c_str());
-                    return false;
-                }
-            }
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        bool closeResult = true;
-        MaterialDocumentRequestBus::EventResult(closeResult, documentId, &MaterialDocumentRequestBus::Events::Close);
-        if (!closeResult)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be closed"),
-                QString("Failed to close: \n%1\n\n%2").arg(documentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return false;
-        }
-
-        MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::DestroyDocument, documentId);
-        return true;
-    }
-
-    bool MaterialDocumentSystemComponent::CloseAllDocuments()
-    {
-        bool result = true;
-        auto documentMap = m_documentMap;
-        for (const auto& documentPair : documentMap)
-        {
-            if (!CloseDocument(documentPair.first))
-            {
-                result = false;
-            }
-        }
-
-        return result;
-    }
-
-    bool MaterialDocumentSystemComponent::CloseAllDocumentsExcept(const AZ::Uuid& documentId)
-    {
-        bool result = true;
-        auto documentMap = m_documentMap;
-        for (const auto& documentPair : documentMap)
-        {
-            if (documentPair.first != documentId)
-            {
-                if (!CloseDocument(documentPair.first))
-                {
-                    result = false;
-                }
-            }
-        }
-
-        return result;
-    }
-
-    bool MaterialDocumentSystemComponent::SaveDocument(const AZ::Uuid& documentId)
-    {
-        AZStd::string saveDocumentPath;
-        MaterialDocumentRequestBus::EventResult(saveDocumentPath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
-
-        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
-        {
-            return false;
-        }
-
-        const QFileInfo saveInfo(saveDocumentPath.c_str());
-        if (saveInfo.exists() && !saveInfo.isWritable())
-        {
-            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
-            return false;
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        bool result = false;
-        MaterialDocumentRequestBus::EventResult(result, documentId, &MaterialDocumentRequestBus::Events::Save);
-        if (!result)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be saved"),
-                QString("Failed to save: \n%1\n\n%2").arg(saveDocumentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return false;
-        }
-
-        return true;
-    }
-
-    bool MaterialDocumentSystemComponent::SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath)
-    {
-        AZStd::string saveDocumentPath = targetPath;
-        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
-        {
-            return false;
-        }
-
-        const QFileInfo saveInfo(saveDocumentPath.c_str());
-        if (saveInfo.exists() && !saveInfo.isWritable())
-        {
-            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
-            return false;
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        bool result = false;
-        MaterialDocumentRequestBus::EventResult(result, documentId, &MaterialDocumentRequestBus::Events::SaveAsCopy, saveDocumentPath);
-        if (!result)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be saved"),
-                QString("Failed to save: \n%1\n\n%2").arg(saveDocumentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return false;
-        }
-
-        return true;
-    }
-
-    bool MaterialDocumentSystemComponent::SaveDocumentAsChild(const AZ::Uuid& documentId, AZStd::string_view targetPath)
-    {
-        AZStd::string saveDocumentPath = targetPath;
-        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
-        {
-            return false;
-        }
-
-        const QFileInfo saveInfo(saveDocumentPath.c_str());
-        if (saveInfo.exists() && !saveInfo.isWritable())
-        {
-            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
-            return false;
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        bool result = false;
-        MaterialDocumentRequestBus::EventResult(result, documentId, &MaterialDocumentRequestBus::Events::SaveAsChild, saveDocumentPath);
-        if (!result)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be saved"),
-                QString("Failed to save: \n%1\n\n%2").arg(saveDocumentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return false;
-        }
-
-        return true;
-    }
-
-    bool MaterialDocumentSystemComponent::SaveAllDocuments()
-    {
-        bool result = true;
-        for (const auto& documentPair : m_documentMap)
-        {
-            if (!SaveDocument(documentPair.first))
-            {
-                result = false;
-            }
-        }
-
-        return result;
-    }
-
-    AZ::Uuid MaterialDocumentSystemComponent::OpenDocumentImpl(AZStd::string_view sourcePath, bool checkIfAlreadyOpen)
-    {
-        AZStd::string requestedPath = sourcePath;
-        if (requestedPath.empty())
-        {
-            return AZ::Uuid::CreateNull();
-        }
-
-        if (!AzFramework::StringFunc::Path::Normalize(requestedPath))
-        {
-            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document path is invalid:\n%1").arg(requestedPath.c_str()));
-            return AZ::Uuid::CreateNull();
-        }
-
-        // Determine if the file is already open and select it
-        if (checkIfAlreadyOpen)
-        {
-            for (const auto& documentPair : m_documentMap)
-            {
-                AZStd::string openDocumentPath;
-                MaterialDocumentRequestBus::EventResult(openDocumentPath, documentPair.first, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
-                if (openDocumentPath == requestedPath)
-                {
-                    MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentOpened, documentPair.first);
-                    return documentPair.first;
-                }
-            }
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        AZ::Uuid documentId = AZ::Uuid::CreateNull();
-        MaterialDocumentSystemRequestBus::BroadcastResult(documentId, &MaterialDocumentSystemRequestBus::Events::CreateDocument);
-        if (documentId.IsNull())
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be created"),
-                QString("Failed to create: \n%1\n\n%2").arg(requestedPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return AZ::Uuid::CreateNull();
-        }
-
-        traceRecorder.GetDump().clear();
-
-        bool openResult = false;
-        MaterialDocumentRequestBus::EventResult(openResult, documentId, &MaterialDocumentRequestBus::Events::Open, requestedPath);
-        if (!openResult)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be opened"),
-                QString("Failed to open: \n%1\n\n%2").arg(requestedPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::DestroyDocument, documentId);
-            return AZ::Uuid::CreateNull();
-        }
-
-        return documentId;
     }
 }

Gems/Atom/Tools/MaterialEditor/Code/Source/Document/MaterialDocumentSystemComponent.h

@@ -9,34 +9,17 @@
 #pragma once
 
 #include <AzCore/Component/Component.h>
-#include <AzCore/Component/TickBus.h>
-#include <AzCore/std/smart_ptr/shared_ptr.h>
-#include <AzCore/Asset/AssetCommon.h>
-
-#include <Atom/Document/MaterialDocumentNotificationBus.h>
-#include <Atom/Document/MaterialDocumentSettings.h>
-#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
-#include <Atom/RPI.Public/WindowContext.h>
-#include <Document/MaterialDocument.h>
-
-AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
-#include <QFileInfo>
-#include <QString>
-AZ_POP_DISABLE_WARNING
 
 namespace MaterialEditor
 {
-    //! MaterialDocumentSystemComponent is the central component of the Material Editor Core gem
+    //! MaterialDocumentSystemComponent
     class MaterialDocumentSystemComponent
         : public AZ::Component
-        , private AZ::TickBus::Handler
-        , private MaterialDocumentNotificationBus::Handler
-        , private MaterialDocumentSystemRequestBus::Handler
     {
     public:
-        AZ_COMPONENT(MaterialDocumentSystemComponent, "{58ABE0AE-2710-41E2-ADFD-E2D67407427D}");
+        AZ_COMPONENT(MaterialDocumentSystemComponent, "{E011DA51-855D-45FA-87A3-1C1CD6379091}");
 
-        MaterialDocumentSystemComponent();
+        MaterialDocumentSystemComponent() = default;
         ~MaterialDocumentSystemComponent() = default;
         MaterialDocumentSystemComponent(const MaterialDocumentSystemComponent&) = delete;
         MaterialDocumentSystemComponent& operator=(const MaterialDocumentSystemComponent&) = delete;
@@ -54,39 +37,5 @@ namespace MaterialEditor
         void Activate() override;
         void Deactivate() override;
         ////////////////////////////////////////////////////////////////////////
-
-        //////////////////////////////////////////////////////////////////////////
-        // MaterialDocumentNotificationBus::Handler overrides...
-        void OnDocumentDependencyModified(const AZ::Uuid& documentId) override;
-        void OnDocumentExternallyModified(const AZ::Uuid& documentId) override;
-        //////////////////////////////////////////////////////////////////////////
-
-        ////////////////////////////////////////////////////////////////////////
-        // AZ::TickBus::Handler overrides...
-        void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
-        ////////////////////////////////////////////////////////////////////////
-
-        ////////////////////////////////////////////////////////////////////////
-        // MaterialDocumentSystemRequestBus::Handler overrides...
-        AZ::Uuid CreateDocument() override;
-        bool DestroyDocument(const AZ::Uuid& documentId) override;
-        AZ::Uuid OpenDocument(AZStd::string_view sourcePath) override;
-        AZ::Uuid CreateDocumentFromFile(AZStd::string_view sourcePath, AZStd::string_view targetPath) override;
-        bool CloseDocument(const AZ::Uuid& documentId) override;
-        bool CloseAllDocuments() override;
-        bool CloseAllDocumentsExcept(const AZ::Uuid& documentId) override;
-        bool SaveDocument(const AZ::Uuid& documentId) override;
-        bool SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath) override;
-        bool SaveDocumentAsChild(const AZ::Uuid& documentId, AZStd::string_view targetPath) override;
-        bool SaveAllDocuments() override;
-        ////////////////////////////////////////////////////////////////////////
-
-        AZ::Uuid OpenDocumentImpl(AZStd::string_view sourcePath, bool checkIfAlreadyOpen);
-
-        AZStd::intrusive_ptr<MaterialDocumentSettings> m_settings;
-        AZStd::unordered_map<AZ::Uuid, AZStd::shared_ptr<MaterialDocument>> m_documentMap;
-        AZStd::unordered_set<AZ::Uuid> m_documentIdsToRebuild;
-        AZStd::unordered_set<AZ::Uuid> m_documentIdsToReopen;
-        const size_t m_maxMessageBoxLineCount = 15;
     };
 } // namespace MaterialEditor

Gems/Atom/Tools/MaterialEditor/Code/Source/MaterialEditorApplication.cpp

@@ -7,9 +7,9 @@
  */
 
 #include <Atom/Document/MaterialDocumentModule.h>
-#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
 #include <Atom/Viewport/MaterialViewportModule.h>
 #include <Atom/Window/MaterialEditorWindowModule.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 #include <AzCore/Settings/SettingsRegistryMergeUtils.h>
 #include <MaterialEditorApplication.h>
 #include <MaterialEditor_Traits_Platform.h>
@@ -68,7 +68,7 @@ namespace MaterialEditor
             const AZStd::string openDocumentPath = commandLine.GetMiscValue(openDocumentIndex);
 
             AZ_Printf(GetBuildTargetName().c_str(), "Opening document: %s", openDocumentPath.c_str());
-            MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::OpenDocument, openDocumentPath);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::OpenDocument, openDocumentPath);
         }
 
         Base::ProcessCommandLine(commandLine);

Gems/Atom/Tools/MaterialEditor/Code/Source/MaterialEditorApplication.h

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
 #include <AtomToolsFramework/Application/AtomToolsApplication.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 
 namespace MaterialEditor
 {

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.cpp

@@ -243,7 +243,7 @@ namespace MaterialEditor
         OnFieldOfViewChanged(viewportSettings->m_fieldOfView);
         OnDisplayMapperOperationTypeChanged(viewportSettings->m_displayMapperOperationType);
 
-        MaterialDocumentNotificationBus::Handler::BusConnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusConnect();
         MaterialViewportNotificationBus::Handler::BusConnect();
         AZ::TickBus::Handler::BusConnect();
         AZ::TransformNotificationBus::MultiHandler::BusConnect(m_cameraEntity->GetId());
@@ -255,7 +255,7 @@ namespace MaterialEditor
         AzFramework::WindowSystemRequestBus::Handler::BusDisconnect();
         AZ::TransformNotificationBus::MultiHandler::BusDisconnect();
         AZ::TickBus::Handler::BusDisconnect();
-        MaterialDocumentNotificationBus::Handler::BusDisconnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusDisconnect();
         MaterialViewportNotificationBus::Handler::BusDisconnect();
         AZ::Data::AssetBus::Handler::BusDisconnect();
 

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportRenderer.h

@@ -8,16 +8,14 @@
 
 #pragma once
 
-#include <AzCore/Component/TickBus.h>
-#include <AzCore/Component/TransformBus.h>
-#include <AtomCore/Instance/Instance.h>
-
-#include <Atom/RPI.Public/Base.h>
-#include <Atom/Document/MaterialDocumentNotificationBus.h>
 #include <Atom/Feature/CoreLights/DirectionalLightFeatureProcessorInterface.h>
 #include <Atom/Feature/SkyBox/SkyBoxFeatureProcessorInterface.h>
+#include <Atom/RPI.Public/Base.h>
 #include <Atom/Viewport/MaterialViewportNotificationBus.h>
-
+#include <AtomCore/Instance/Instance.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
+#include <AzCore/Component/TickBus.h>
+#include <AzCore/Component/TransformBus.h>
 #include <AzFramework/Windowing/WindowBus.h>
 #include <Viewport/InputController/MaterialEditorViewportInputController.h>
 
@@ -45,7 +43,7 @@ namespace MaterialEditor
     class MaterialViewportRenderer
         : public AZ::Data::AssetBus::Handler
         , public AZ::TickBus::Handler
-        , public MaterialDocumentNotificationBus::Handler
+        , public AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler
         , public MaterialViewportNotificationBus::Handler
         , public AZ::TransformNotificationBus::MultiHandler
         , public AzFramework::WindowSystemRequestBus::Handler
@@ -60,7 +58,7 @@ namespace MaterialEditor
 
     private:
 
-        // MaterialDocumentNotificationBus::Handler interface overrides...
+        // AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler interface overrides...
         void OnDocumentOpened(const AZ::Uuid& documentId) override;
 
         // MaterialViewportNotificationBus::Handler interface overrides...

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportSettings.cpp

@@ -54,7 +54,7 @@ namespace MaterialEditor
             behaviorContext->Class<MaterialViewportSettings>("MaterialViewportSettings")
                 ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                 ->Attribute(AZ::Script::Attributes::Category, "Editor")
-                ->Attribute(AZ::Script::Attributes::Module, "render")
+                ->Attribute(AZ::Script::Attributes::Module, "materialeditor")
                 ->Constructor()
                 ->Constructor<const MaterialViewportSettings&>()
                 ->Property("enableGrid", BehaviorValueProperty(&MaterialViewportSettings::m_enableGrid))

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialBrowserWidget.cpp

@@ -7,9 +7,12 @@
  */
 
 #include <Atom/Document/MaterialDocumentRequestBus.h>
-#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
+#include <Atom/RPI.Edit/Material/MaterialSourceData.h>
+#include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
 #include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
 #include <Atom/RPI.Reflect/Material/MaterialAsset.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 #include <AzQtComponents/Utilities/DesktopUtilities.h>
 #include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
 #include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
@@ -18,9 +21,8 @@
 #include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
 #include <AzToolsFramework/AssetBrowser/Search/Filter.h>
 #include <AzToolsFramework/AssetBrowser/Views/AssetBrowserTreeView.h>
-
-#include <Source/Window/MaterialBrowserWidget.h>
-#include <Source/Window/ui_MaterialBrowserWidget.h>
+#include <Window/MaterialBrowserWidget.h>
+#include <Window/ui_MaterialBrowserWidget.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
 #include <QAction>
@@ -91,14 +93,14 @@ namespace MaterialEditor
             }
         });
 
-        MaterialDocumentNotificationBus::Handler::BusConnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusConnect();
     }
 
     MaterialBrowserWidget::~MaterialBrowserWidget()
     {
         // Maintains the tree expansion state between runs
         m_ui->m_assetBrowserTreeViewWidget->SaveState();
-        MaterialDocumentNotificationBus::Handler::BusDisconnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusDisconnect();
         AZ::TickBus::Handler::BusDisconnect();
     }
 
@@ -144,13 +146,13 @@ namespace MaterialEditor
         {
             if (entry)
             {
-                if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), MaterialExtension))
+                if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), AZ::RPI::MaterialSourceData::Extension))
                 {
-                    MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::OpenDocument, entry->GetFullPath());
+                    AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::OpenDocument, entry->GetFullPath());
                 }
-                else if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), MaterialTypeExtension))
+                else if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), AZ::RPI::MaterialTypeSourceData::Extension))
                 {
-                    //ignore MaterialTypeExtension
+                    //ignore AZ::RPI::MaterialTypeSourceData::Extension
                 }
                 else
                 {
@@ -163,7 +165,7 @@ namespace MaterialEditor
     void MaterialBrowserWidget::OnDocumentOpened(const AZ::Uuid& documentId)
     {
         AZStd::string absolutePath;
-        MaterialDocumentRequestBus::EventResult(absolutePath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
         if (!absolutePath.empty())
         {
             // Selecting a new asset in the browser is not guaranteed to happen immediately.
@@ -230,4 +232,4 @@ namespace MaterialEditor
 
 } // namespace MaterialEditor
 
-#include <Source/Window/moc_MaterialBrowserWidget.cpp>
+#include <Window/moc_MaterialBrowserWidget.cpp>

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialBrowserWidget.h

@@ -9,15 +9,15 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
-#include <Atom/Document/MaterialDocumentNotificationBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AzCore/Component/TickBus.h>
 #include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
 #include <AzToolsFramework/AssetBrowser/Entries/AssetBrowserEntry.h>
 #include <AzToolsFramework/AssetBrowser/Search/Filter.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
-#include <QWidget>
 #include <QByteArray>
+#include <QWidget>
 AZ_POP_DISABLE_WARNING
 
 #endif
@@ -45,7 +45,7 @@ namespace MaterialEditor
     class MaterialBrowserWidget
         : public QWidget
         , protected AZ::TickBus::Handler
-        , protected MaterialDocumentNotificationBus::Handler
+        , protected AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler
     {
         Q_OBJECT
     public:
@@ -56,7 +56,7 @@ namespace MaterialEditor
         AzToolsFramework::AssetBrowser::FilterConstType CreateFilter() const;
         void OpenSelectedEntries();
 
-        // MaterialDocumentNotificationBus::Handler implementation
+        // AtomToolsDocumentNotificationBus::Handler implementation
         void OnDocumentOpened(const AZ::Uuid& documentId) override;
 
         // AZ::TickBus::Handler

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorBrowserInteractions.cpp

@@ -6,32 +6,28 @@
  *
  */
 
-#include <QApplication>
-#include <QClipboard>
-#include <QMenu>
-#include <QInputDialog>
-#include <QMessageBox>
-#include <QFileDialog>
-#include <QDesktopServices>
-
-#include <AzCore/std/string/wildcard.h>
-#include <AzQtComponents/Utilities/DesktopUtilities.h>
-
-#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
-#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
-#include <AzToolsFramework/Thumbnails/SourceControlThumbnail.h>
-#include <AtomToolsFramework/Util/Util.h>
-
 #include <Atom/RPI.Edit/Common/AssetUtils.h>
-#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
-
-#include <Window/MaterialEditorBrowserInteractions.h>
-#include <Window/CreateMaterialDialog/CreateMaterialDialog.h>
-
-#include <Atom/RPI.Reflect/Material/MaterialAsset.h>
 #include <Atom/RPI.Edit/Material/MaterialSourceData.h>
 #include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
+#include <Atom/RPI.Reflect/Material/MaterialAsset.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
+#include <AtomToolsFramework/Util/Util.h>
+#include <AzCore/std/string/wildcard.h>
+#include <AzQtComponents/Utilities/DesktopUtilities.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
+#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
+#include <AzToolsFramework/Thumbnails/SourceControlThumbnail.h>
+#include <Window/CreateMaterialDialog/CreateMaterialDialog.h>
+#include <Window/MaterialEditorBrowserInteractions.h>
+
+#include <QApplication>
+#include <QClipboard>
+#include <QDesktopServices>
+#include <QFileDialog>
+#include <QInputDialog>
+#include <QMenu>
+#include <QMessageBox>
 
 namespace MaterialEditor
 {
@@ -66,11 +62,11 @@ namespace MaterialEditor
         if (entry->GetEntryType() == AssetBrowserEntry::AssetEntryType::Source)
         {
             const auto source = azalias_cast<const SourceAssetBrowserEntry*>(entry);
-            if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), MaterialExtension))
+            if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), AZ::RPI::MaterialSourceData::Extension))
             {
                 AddContextMenuActionsForMaterialSource(caller, menu, source);
             }
-            else if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), MaterialTypeExtension))
+            else if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), AZ::RPI::MaterialTypeSourceData::Extension))
             {
                 AddContextMenuActionsForMaterialTypeSource(caller, menu, source);
             }
@@ -115,7 +111,7 @@ namespace MaterialEditor
                     AZ_CORRECT_FILESYSTEM_SEPARATOR + "untitled." +
                     AZ::RPI::MaterialSourceData::Extension).absoluteFilePath();
 
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CreateDocumentFromFile,
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CreateDocumentFromFile,
                     entry->GetFullPath(), AtomToolsFramework::GetSaveFileInfo(defaultPath).absoluteFilePath().toUtf8().constData());
             });
 
@@ -157,7 +153,7 @@ namespace MaterialEditor
     {
         menu->addAction("Open", [entry]()
             {
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::OpenDocument, entry->GetFullPath());
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::OpenDocument, entry->GetFullPath());
             });
 
         menu->addAction("Duplicate...", [entry, caller]()
@@ -191,7 +187,7 @@ namespace MaterialEditor
                     AZ_CORRECT_FILESYSTEM_SEPARATOR + "untitled." +
                     AZ::RPI::MaterialSourceData::Extension).absoluteFilePath();
 
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CreateDocumentFromFile,
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CreateDocumentFromFile,
                     entry->GetFullPath(), AtomToolsFramework::GetSaveFileInfo(defaultPath).absoluteFilePath().toUtf8().constData());
             });
 
@@ -258,7 +254,7 @@ namespace MaterialEditor
                     !createDialog.m_materialFileInfo.absoluteFilePath().isEmpty() &&
                     !createDialog.m_materialTypeFileInfo.absoluteFilePath().isEmpty())
                 {
-                    MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CreateDocumentFromFile,
+                    AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CreateDocumentFromFile,
                         createDialog.m_materialTypeFileInfo.absoluteFilePath().toUtf8().constData(),
                         createDialog.m_materialFileInfo.absoluteFilePath().toUtf8().constData());
                 }

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.cpp

@@ -6,7 +6,11 @@
  *
  */
 
+#include <Atom/Document/MaterialDocumentRequestBus.h>
 #include <Atom/RHI/Factory.h>
+#include <Atom/Window/MaterialEditorWindowSettings.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 #include <AtomToolsFramework/Util/Util.h>
 #include <AtomToolsFramework/Window/AtomToolsMainWindowNotificationBus.h>
 #include <AzFramework/StringFunc/StringFunc.h>
@@ -15,11 +19,6 @@
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/API/EditorPythonRunnerRequestsBus.h>
 #include <AzToolsFramework/PythonTerminal/ScriptTermDialog.h>
-
-#include <Atom/Document/MaterialDocumentRequestBus.h>
-#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
-#include <Atom/Window/MaterialEditorWindowSettings.h>
-
 #include <Viewport/MaterialViewportWidget.h>
 #include <Window/CreateMaterialDialog/CreateMaterialDialog.h>
 #include <Window/HelpDialog/HelpDialog.h>
@@ -106,13 +105,13 @@ namespace MaterialEditor
             m_advancedDockManager->restoreState(windowState);
         }
 
-        MaterialDocumentNotificationBus::Handler::BusConnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusConnect();
         OnDocumentOpened(AZ::Uuid::CreateNull());
     }
 
     MaterialEditorWindow::~MaterialEditorWindow()
     {
-        MaterialDocumentNotificationBus::Handler::BusDisconnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusDisconnect();
     }
 
     
@@ -150,7 +149,7 @@ namespace MaterialEditor
     void MaterialEditorWindow::closeEvent(QCloseEvent* closeEvent)
     {
         bool didClose = true;
-        MaterialDocumentSystemRequestBus::BroadcastResult(didClose, &MaterialDocumentSystemRequestBus::Events::CloseAllDocuments);
+        AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(didClose, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseAllDocuments);
         if (!didClose)
         {
             closeEvent->ignore();
@@ -171,17 +170,17 @@ namespace MaterialEditor
     void MaterialEditorWindow::OnDocumentOpened(const AZ::Uuid& documentId)
     {
         bool isOpen = false;
-        MaterialDocumentRequestBus::EventResult(isOpen, documentId, &MaterialDocumentRequestBus::Events::IsOpen);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isOpen, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsOpen);
         bool isSavable = false;
-        MaterialDocumentRequestBus::EventResult(isSavable, documentId, &MaterialDocumentRequestBus::Events::IsSavable);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isSavable, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsSavable);
         bool isModified = false;
-        MaterialDocumentRequestBus::EventResult(isModified, documentId, &MaterialDocumentRequestBus::Events::IsModified);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isModified, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsModified);
         bool canUndo = false;
-        MaterialDocumentRequestBus::EventResult(canUndo, documentId, &MaterialDocumentRequestBus::Events::CanUndo);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(canUndo, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::CanUndo);
         bool canRedo = false;
-        MaterialDocumentRequestBus::EventResult(canRedo, documentId, &MaterialDocumentRequestBus::Events::CanRedo);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(canRedo, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::CanRedo);
         AZStd::string absolutePath;
-        MaterialDocumentRequestBus::EventResult(absolutePath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
         AZStd::string filename;
         AzFramework::StringFunc::Path::GetFullFileName(absolutePath.c_str(), filename);
 
@@ -238,7 +237,7 @@ namespace MaterialEditor
         const QString documentPath = GetDocumentPath(documentId);
         if (!documentPath.isEmpty())
         {
-            const QString status = QString("Document closed: %1").arg(documentPath);
+            const QString status = QString("Document opened: %1").arg(documentPath);
             m_statusMessage->setText(QString("<font color=\"White\">%1</font>").arg(status));
         }
     }
@@ -255,9 +254,9 @@ namespace MaterialEditor
     void MaterialEditorWindow::OnDocumentModified(const AZ::Uuid& documentId)
     {
         bool isModified = false;
-        MaterialDocumentRequestBus::EventResult(isModified, documentId, &MaterialDocumentRequestBus::Events::IsModified);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isModified, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsModified);
         AZStd::string absolutePath;
-        MaterialDocumentRequestBus::EventResult(absolutePath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
         AZStd::string filename;
         AzFramework::StringFunc::Path::GetFullFileName(absolutePath.c_str(), filename);
         UpdateTabForDocumentId(documentId, filename, absolutePath, isModified);
@@ -268,9 +267,9 @@ namespace MaterialEditor
         if (documentId == GetDocumentIdFromTab(m_tabWidget->currentIndex()))
         {
             bool canUndo = false;
-            MaterialDocumentRequestBus::EventResult(canUndo, documentId, &MaterialDocumentRequestBus::Events::CanUndo);
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(canUndo, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::CanUndo);
             bool canRedo = false;
-            MaterialDocumentRequestBus::EventResult(canRedo, documentId, &MaterialDocumentRequestBus::Events::CanRedo);
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(canRedo, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::CanRedo);
             m_actionUndo->setEnabled(canUndo);
             m_actionRedo->setEnabled(canRedo);
         }
@@ -279,15 +278,15 @@ namespace MaterialEditor
     void MaterialEditorWindow::OnDocumentSaved(const AZ::Uuid& documentId)
     {
         bool isModified = false;
-        MaterialDocumentRequestBus::EventResult(isModified, documentId, &MaterialDocumentRequestBus::Events::IsModified);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isModified, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsModified);
         AZStd::string absolutePath;
-        MaterialDocumentRequestBus::EventResult(absolutePath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
         AZStd::string filename;
         AzFramework::StringFunc::Path::GetFullFileName(absolutePath.c_str(), filename);
         UpdateTabForDocumentId(documentId, filename, absolutePath, isModified);
 
         const QString documentPath = GetDocumentPath(documentId);
-        const QString status = QString("Document closed: %1").arg(documentPath);
+        const QString status = QString("Document saved: %1").arg(documentPath);
         m_statusMessage->setText(QString("<font color=\"White\">%1</font>").arg(status));
     }
 
@@ -306,7 +305,7 @@ namespace MaterialEditor
                 !createDialog.m_materialFileInfo.absoluteFilePath().isEmpty() &&
                 !createDialog.m_materialTypeFileInfo.absoluteFilePath().isEmpty())
             {
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CreateDocumentFromFile,
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CreateDocumentFromFile,
                     createDialog.m_materialTypeFileInfo.absoluteFilePath().toUtf8().constData(),
                     createDialog.m_materialFileInfo.absoluteFilePath().toUtf8().constData());
             }
@@ -317,7 +316,7 @@ namespace MaterialEditor
             const AZStd::string filePath = AtomToolsFramework::GetOpenFileInfo(assetTypes).absoluteFilePath().toUtf8().constData();
             if (!filePath.empty())
             {
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::OpenDocument, filePath);
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::OpenDocument, filePath);
             }
         }, QKeySequence::Open);
 
@@ -328,11 +327,11 @@ namespace MaterialEditor
         m_actionSave = m_menuFile->addAction("&Save", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
             bool result = false;
-            MaterialDocumentSystemRequestBus::BroadcastResult(result, &MaterialDocumentSystemRequestBus::Events::SaveDocument, documentId);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(result, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::SaveDocument, documentId);
             if (!result)
             {
                 const QString documentPath = GetDocumentPath(documentId);
-                const QString status = QString("Failed to save document: %1").arg(documentPath);
+                const QString status = QString("Document save failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         }, QKeySequence::Save);
@@ -342,11 +341,11 @@ namespace MaterialEditor
             const QString documentPath = GetDocumentPath(documentId);
 
             bool result = false;
-            MaterialDocumentSystemRequestBus::BroadcastResult(result, &MaterialDocumentSystemRequestBus::Events::SaveDocumentAsCopy,
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(result, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::SaveDocumentAsCopy,
                 documentId, AtomToolsFramework::GetSaveFileInfo(documentPath).absoluteFilePath().toUtf8().constData());
             if (!result)
             {
-                const QString status = QString("Failed to save document: %1").arg(documentPath);
+                const QString status = QString("Document save failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         }, QKeySequence::SaveAs);
@@ -356,21 +355,21 @@ namespace MaterialEditor
             const QString documentPath = GetDocumentPath(documentId);
 
             bool result = false;
-            MaterialDocumentSystemRequestBus::BroadcastResult(result, &MaterialDocumentSystemRequestBus::Events::SaveDocumentAsChild,
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(result, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::SaveDocumentAsChild,
                 documentId, AtomToolsFramework::GetSaveFileInfo(documentPath).absoluteFilePath().toUtf8().constData());
             if (!result)
             {
-                const QString status = QString("Failed to save document: %1").arg(documentPath);
+                const QString status = QString("Document save failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         });
 
         m_actionSaveAll = m_menuFile->addAction("Save A&ll", [this]() {
             bool result = false;
-            MaterialDocumentSystemRequestBus::BroadcastResult(result, &MaterialDocumentSystemRequestBus::Events::SaveAllDocuments);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(result, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::SaveAllDocuments);
             if (!result)
             {
-                const QString status = QString("Failed to save documents.");
+                const QString status = QString("Document save all failed.");
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         });
@@ -379,16 +378,16 @@ namespace MaterialEditor
 
         m_actionClose = m_menuFile->addAction("&Close", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
-            MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CloseDocument, documentId);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseDocument, documentId);
         }, QKeySequence::Close);
 
         m_actionCloseAll = m_menuFile->addAction("Close All", [this]() {
-            MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CloseAllDocuments);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseAllDocuments);
         });
 
         m_actionCloseOthers = m_menuFile->addAction("Close Others", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
-            MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
         });
 
         m_menuFile->addSeparator();
@@ -412,11 +411,11 @@ namespace MaterialEditor
         m_actionUndo = m_menuEdit->addAction("&Undo", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
             bool result = false;
-            MaterialDocumentRequestBus::EventResult(result, documentId, &MaterialDocumentRequestBus::Events::Undo);
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(result, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::Undo);
             if (!result)
             {
                 const QString documentPath = GetDocumentPath(documentId);
-                const QString status = QString("Failed to perform undo on document: %1").arg(documentPath);
+                const QString status = QString("Document undo failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         }, QKeySequence::Undo);
@@ -424,11 +423,11 @@ namespace MaterialEditor
         m_actionRedo = m_menuEdit->addAction("&Redo", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
             bool result = false;
-            MaterialDocumentRequestBus::EventResult(result, documentId, &MaterialDocumentRequestBus::Events::Redo);
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(result, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::Redo);
             if (!result)
             {
                 const QString documentPath = GetDocumentPath(documentId);
-                const QString status = QString("Failed to perform redo on document: %1").arg(documentPath);
+                const QString status = QString("Document redo failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         }, QKeySequence::Redo);
@@ -501,19 +500,19 @@ namespace MaterialEditor
         // This should automatically clear the active document
         connect(m_tabWidget, &QTabWidget::currentChanged, this, [this](int tabIndex) {
             const AZ::Uuid documentId = GetDocumentIdFromTab(tabIndex);
-            MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentOpened, documentId);
+            AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, documentId);
         });
 
         connect(m_tabWidget, &QTabWidget::tabCloseRequested, this, [this](int tabIndex) {
             const AZ::Uuid documentId = GetDocumentIdFromTab(tabIndex);
-            MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CloseDocument, documentId);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseDocument, documentId);
         });
     }
 
     QString MaterialEditorWindow::GetDocumentPath(const AZ::Uuid& documentId) const
     {
         AZStd::string absolutePath;
-        MaterialDocumentRequestBus::EventResult(absolutePath, documentId, &MaterialDocumentRequestBus::Handler::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Handler::GetAbsolutePath);
         return absolutePath.c_str();
     }
 
@@ -529,15 +528,15 @@ namespace MaterialEditor
             const QString selectActionName = (currentTabIndex == clickedTabIndex) ? "Select in Browser" : "Select";
             tabMenu.addAction(selectActionName, [this, clickedTabIndex]() {
                 const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
-                MaterialDocumentNotificationBus::Broadcast(&MaterialDocumentNotificationBus::Events::OnDocumentOpened, documentId);
+                AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, documentId);
             });
             tabMenu.addAction("Close", [this, clickedTabIndex]() {
                 const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CloseDocument, documentId);
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseDocument, documentId);
             });
             auto closeOthersAction = tabMenu.addAction("Close Others", [this, clickedTabIndex]() {
                 const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
-                MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
             });
             closeOthersAction->setEnabled(tabBar->count() > 1);
             tabMenu.exec(QCursor::pos());

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindow.h

@@ -9,7 +9,7 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
-#include <Atom/Document/MaterialDocumentNotificationBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AtomToolsFramework/Window/AtomToolsMainWindow.h>
 #include <AzCore/Memory/SystemAllocator.h>
 
@@ -30,7 +30,7 @@ namespace MaterialEditor
      */
     class MaterialEditorWindow
         : public AtomToolsFramework::AtomToolsMainWindow
-        , private MaterialDocumentNotificationBus::Handler
+        , private AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler
     {
         Q_OBJECT
     public:
@@ -46,7 +46,7 @@ namespace MaterialEditor
         void LockViewportRenderTargetSize(uint32_t width, uint32_t height) override;
         void UnlockViewportRenderTargetSize() override;
 
-        // MaterialDocumentNotificationBus::Handler overrides...
+        // AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler overrides...
         void OnDocumentOpened(const AZ::Uuid& documentId) override;
         void OnDocumentClosed(const AZ::Uuid& documentId) override;
         void OnDocumentModified(const AZ::Uuid& documentId) override;

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialEditorWindowSettings.cpp

@@ -37,7 +37,7 @@ namespace MaterialEditor
             behaviorContext->Class<MaterialEditorWindowSettings>("MaterialEditorWindowSettings")
                 ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                 ->Attribute(AZ::Script::Attributes::Category, "Editor")
-                ->Attribute(AZ::Script::Attributes::Module, "render")
+                ->Attribute(AZ::Script::Attributes::Module, "materialeditor")
                 ->Constructor()
                 ->Constructor<const MaterialEditorWindowSettings&>()
                 ;

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.cpp

@@ -6,17 +6,15 @@
  *
  */
 
+#include <Atom/Document/MaterialDocumentRequestBus.h>
 #include <Atom/RPI.Edit/Common/AssetUtils.h>
 #include <Atom/RPI.Edit/Material/MaterialPropertyId.h>
 #include <Atom/RPI.Edit/Material/MaterialTypeSourceData.h>
 #include <Atom/RPI.Edit/Material/MaterialUtils.h>
-
-#include <Atom/Document/MaterialDocumentRequestBus.h>
-
+#include <AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h>
 #include <AtomToolsFramework/DynamicProperty/DynamicPropertyGroup.h>
 #include <AtomToolsFramework/Inspector/InspectorPropertyGroupWidget.h>
 #include <AtomToolsFramework/Util/MaterialPropertyUtil.h>
-
 #include <Window/MaterialInspector/MaterialInspector.h>
 
 namespace MaterialEditor
@@ -27,12 +25,12 @@ namespace MaterialEditor
         m_windowSettings = AZ::UserSettings::CreateFind<MaterialEditorWindowSettings>(
             AZ::Crc32("MaterialEditorWindowSettings"), AZ::UserSettings::CT_GLOBAL);
 
-        MaterialDocumentNotificationBus::Handler::BusConnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusConnect();
     }
 
     MaterialInspector::~MaterialInspector()
     {
-        MaterialDocumentNotificationBus::Handler::BusDisconnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusDisconnect();
         AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect();
     }
 
@@ -69,9 +67,9 @@ namespace MaterialEditor
         m_documentId = documentId;
 
         bool isOpen = false;
-        MaterialDocumentRequestBus::EventResult(isOpen, m_documentId, &MaterialDocumentRequestBus::Events::IsOpen);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isOpen, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsOpen);
 
-        MaterialDocumentRequestBus::EventResult(m_documentPath, m_documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(m_documentPath, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
 
         if (!m_documentId.IsNull() && isOpen)
         {
@@ -113,13 +111,13 @@ namespace MaterialEditor
         auto& group = m_groups[groupNameId];
 
         AtomToolsFramework::DynamicProperty property;
-        MaterialDocumentRequestBus::EventResult(
-            property, m_documentId, &MaterialDocumentRequestBus::Events::GetProperty, AZ::Name("overview.materialType"));
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(
+            property, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetProperty, AZ::Name("overview.materialType"));
         group.m_properties.push_back(property);
 
         property = {};
-        MaterialDocumentRequestBus::EventResult(
-            property, m_documentId, &MaterialDocumentRequestBus::Events::GetProperty, AZ::Name("overview.parentMaterial"));
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(
+            property, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetProperty, AZ::Name("overview.parentMaterial"));
         group.m_properties.push_back(property);
 
         // Passing in same group as main and comparison instance to enable custom value comparison for highlighting modified properties
@@ -145,8 +143,8 @@ namespace MaterialEditor
         for (const auto& uvNamePair : uvNameMap)
         {
             AtomToolsFramework::DynamicProperty property;
-            MaterialDocumentRequestBus::EventResult(
-                property, m_documentId, &MaterialDocumentRequestBus::Events::GetProperty,
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(
+                property, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetProperty,
                 AZ::RPI::MaterialPropertyId(groupNameId, uvNamePair.m_shaderInput.ToString()).GetFullName());
             group.m_properties.push_back(property);
 
@@ -182,8 +180,8 @@ namespace MaterialEditor
                 for (const auto& propertyDefinition : propertyListItr->second)
                 {
                     AtomToolsFramework::DynamicProperty property;
-                    MaterialDocumentRequestBus::EventResult(
-                        property, m_documentId, &MaterialDocumentRequestBus::Events::GetProperty,
+                    AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(
+                        property, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetProperty,
                         AZ::RPI::MaterialPropertyId(groupNameId, propertyDefinition.m_nameId).GetFullName());
                     group.m_properties.push_back(property);
                 }
@@ -196,8 +194,8 @@ namespace MaterialEditor
             AddGroup(groupNameId, groupDisplayName, groupDescription, propertyGroupWidget);
             
             bool isGroupVisible = false;
-            MaterialDocumentRequestBus::EventResult(
-                isGroupVisible, m_documentId, &MaterialDocumentRequestBus::Events::IsPropertyGroupVisible, AZ::Name{groupNameId});
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(
+                isGroupVisible, m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsPropertyGroupVisible, AZ::Name{groupNameId});
             SetGroupVisible(groupNameId, isGroupVisible);
         }
     }
@@ -264,7 +262,7 @@ namespace MaterialEditor
             if (m_activeProperty != property)
             {
                 m_activeProperty = property;
-                MaterialDocumentRequestBus::Event(m_documentId, &MaterialDocumentRequestBus::Events::BeginEdit);
+                AtomToolsFramework::AtomToolsDocumentRequestBus::Event(m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::BeginEdit);
             }
         }
     }
@@ -276,8 +274,8 @@ namespace MaterialEditor
         {
             if (m_activeProperty == property)
             {
-                MaterialDocumentRequestBus::Event(
-                    m_documentId, &MaterialDocumentRequestBus::Events::SetPropertyValue, property->GetId(), property->GetValue());
+                AtomToolsFramework::AtomToolsDocumentRequestBus::Event(
+                    m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::SetPropertyValue, property->GetId(), property->GetValue());
             }
         }
     }
@@ -292,10 +290,10 @@ namespace MaterialEditor
         {
             if (m_activeProperty == property)
             {
-                MaterialDocumentRequestBus::Event(
-                    m_documentId, &MaterialDocumentRequestBus::Events::SetPropertyValue, property->GetId(), property->GetValue());
+                AtomToolsFramework::AtomToolsDocumentRequestBus::Event(
+                    m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::SetPropertyValue, property->GetId(), property->GetValue());
 
-                MaterialDocumentRequestBus::Event(m_documentId, &MaterialDocumentRequestBus::Events::EndEdit);
+                AtomToolsFramework::AtomToolsDocumentRequestBus::Event(m_documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::EndEdit);
                 m_activeProperty = nullptr;
             }
         }

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialInspector/MaterialInspector.h

@@ -9,14 +9,12 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
-#include <AzCore/std/containers/unordered_map.h>
-#include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals.h>
-
+#include <Atom/Window/MaterialEditorWindowSettings.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AtomToolsFramework/DynamicProperty/DynamicPropertyGroup.h>
 #include <AtomToolsFramework/Inspector/InspectorWidget.h>
-
-#include <Atom/Document/MaterialDocumentNotificationBus.h>
-#include <Atom/Window/MaterialEditorWindowSettings.h>
+#include <AzCore/std/containers/unordered_map.h>
+#include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals.h>
 #endif
 
 namespace MaterialEditor
@@ -25,7 +23,7 @@ namespace MaterialEditor
     //! The settings can be divided into cards, with each one showing a subset of properties.
     class MaterialInspector
         : public AtomToolsFramework::InspectorWidget
-        , public MaterialDocumentNotificationBus::Handler
+        , public AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler
         , public AzToolsFramework::IPropertyEditorNotify
     {
         Q_OBJECT
@@ -52,7 +50,7 @@ namespace MaterialEditor
         void AddUvNamesGroup();
         void AddPropertiesGroup();
 
-        // MaterialDocumentNotificationBus::Handler implementation
+        // AtomToolsDocumentNotificationBus::Handler implementation
         void OnDocumentOpened(const AZ::Uuid& documentId) override;
         void OnDocumentPropertyValueModified(const AZ::Uuid& documentId, const AtomToolsFramework::DynamicProperty& property) override;
         void OnDocumentPropertyConfigModified(const AZ::Uuid& documentId, const AtomToolsFramework::DynamicProperty& property) override;

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/SettingsDialog/SettingsWidget.cpp

@@ -15,7 +15,9 @@ namespace MaterialEditor
         : AtomToolsFramework::InspectorWidget(parent)
     {
         m_documentSettings =
-            AZ::UserSettings::CreateFind<MaterialDocumentSettings>(AZ::Crc32("MaterialDocumentSettings"), AZ::UserSettings::CT_GLOBAL);
+            AZ::UserSettings::CreateFind<MaterialDocumentSettings>(AZ_CRC_CE("MaterialDocumentSettings"), AZ::UserSettings::CT_GLOBAL);
+        m_documentSystemSettings = AZ::UserSettings::CreateFind<AtomToolsFramework::AtomToolsDocumentSystemSettings>(
+            AZ_CRC_CE("AtomToolsDocumentSystemSettings"), AZ::UserSettings::CT_GLOBAL);
     }
 
     SettingsWidget::~SettingsWidget()
@@ -26,23 +28,36 @@ namespace MaterialEditor
     void SettingsWidget::Populate()
     {
         AddGroupsBegin();
-        AddDocumentGroup();
+        AddDocumentSystemSettingsGroup();
+        AddDocumentSettingsGroup();
         AddGroupsEnd();
     }
 
-    void SettingsWidget::AddDocumentGroup()
+    void SettingsWidget::AddDocumentSettingsGroup()
     {
         const AZStd::string groupNameId = "documentSettings";
         const AZStd::string groupDisplayName = "Document Settings";
         const AZStd::string groupDescription = "Document Settings";
 
-        const AZ::Crc32 saveStateKey(AZStd::string::format("SettingsWidget::DocumentGroup"));
+        const AZ::Crc32 saveStateKey(AZStd::string::format("SettingsWidget::DocumentSettingsGroup"));
         AddGroup(
             groupNameId, groupDisplayName, groupDescription,
             new AtomToolsFramework::InspectorPropertyGroupWidget(
                 m_documentSettings.get(), nullptr, m_documentSettings->TYPEINFO_Uuid(), this, this, saveStateKey));
     }
 
+    void SettingsWidget::AddDocumentSystemSettingsGroup()
+    {
+        const AZStd::string groupNameId = "documentSystemSettings";
+        const AZStd::string groupDisplayName = "Document System Settings";
+        const AZStd::string groupDescription = "Document System Settings";
+
+        const AZ::Crc32 saveStateKey(AZStd::string::format("SettingsWidget::DocumentSystemSettingsGroup"));        AddGroup(
+            groupNameId, groupDisplayName, groupDescription,
+            new AtomToolsFramework::InspectorPropertyGroupWidget(
+                m_documentSystemSettings.get(), nullptr, m_documentSystemSettings->TYPEINFO_Uuid(), this, this, saveStateKey));
+    }
+
     void SettingsWidget::Reset()
     {
         AtomToolsFramework::InspectorRequestBus::Handler::BusDisconnect();

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/SettingsDialog/SettingsWidget.h

@@ -10,6 +10,7 @@
 
 #if !defined(Q_MOC_RUN)
 #include <Atom/Document/MaterialDocumentSettings.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemSettings.h>
 #include <AtomToolsFramework/Inspector/InspectorWidget.h>
 #include <AzToolsFramework/UI/PropertyEditor/PropertyEditorAPI_Internals.h>
 #endif
@@ -31,7 +32,8 @@ namespace MaterialEditor
         void Populate();
 
     private:
-        void AddDocumentGroup();
+        void AddDocumentSettingsGroup();
+        void AddDocumentSystemSettingsGroup();
 
         // AtomToolsFramework::InspectorRequestBus::Handler overrides...
         void Reset() override;
@@ -46,5 +48,6 @@ namespace MaterialEditor
         void PropertySelectionChanged(AzToolsFramework::InstanceDataNode*, bool) override {}
 
         AZStd::intrusive_ptr<MaterialDocumentSettings> m_documentSettings;
+        AZStd::intrusive_ptr<AtomToolsFramework::AtomToolsDocumentSystemSettings> m_documentSystemSettings;
     };
 } // namespace MaterialEditor

Gems/Atom/Tools/MaterialEditor/Code/materialeditordocument_files.cmake

@@ -8,8 +8,6 @@
 
 set(FILES
     Include/Atom/Document/MaterialDocumentModule.h
-    Include/Atom/Document/MaterialDocumentSystemRequestBus.h
-    Include/Atom/Document/MaterialDocumentNotificationBus.h
     Include/Atom/Document/MaterialDocumentRequestBus.h
     Include/Atom/Document/MaterialDocumentSettings.h
     Source/Document/MaterialDocumentModule.cpp

Gems/Atom/Tools/MaterialEditor/Scripts/GenerateAllMaterialScreenshots.py

@@ -93,11 +93,11 @@ def ToRadians(degrees):
     return 3.14159 * degrees / 180.0;
 
 def OpenMaterial(filename):
-    documentId = azlmbr.materialeditor.MaterialDocumentSystemRequestBus(azlmbr.bus.Broadcast, 'OpenDocument', os.path.join(g_materialTestFolder, filename))
+    documentId = azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(azlmbr.bus.Broadcast, 'OpenDocument', os.path.join(g_materialTestFolder, filename))
     return documentId
     
 def CloseMaterial(documentId):
-    azlmbr.materialeditor.MaterialDocumentSystemRequestBus(azlmbr.bus.Broadcast, 'CloseDocument', documentId)
+    azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(azlmbr.bus.Broadcast, 'CloseDocument', documentId)
 
 def SelectLightingPreset(presetName):
     azlmbr.materialeditor.MaterialViewportRequestBus(azlmbr.bus.Broadcast, 'SelectLightingPresetByName', presetName)

Gems/Atom/Tools/ShaderManagementConsole/Code/Include/Atom/Document/ShaderManagementConsoleDocumentRequestBus.h

@@ -7,14 +7,10 @@
  */
 #pragma once
 
-#include <AzCore/Asset/AssetCommon.h>
-#include <AzCore/Outcome/Outcome.h>
-#include <AzCore/std/any.h>
-#include <AzCore/std/string/string_view.h>
-
-#include <Atom/RPI.Reflect/Shader/ShaderOptionGroupLayout.h>
 #include <Atom/RPI.Edit/Shader/ShaderSourceData.h>
 #include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
+#include <Atom/RPI.Reflect/Shader/ShaderOptionGroupLayout.h>
+#include <AzCore/Asset/AssetCommon.h>
 
 namespace ShaderManagementConsole
 {
@@ -27,12 +23,6 @@ namespace ShaderManagementConsole
         static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
         typedef AZ::Uuid BusIdType;
 
-        //! Get absolute path of document
-        virtual AZStd::string_view GetAbsolutePath() const = 0;
-
-        //! Get relative path of document
-        virtual AZStd::string_view GetRelativePath() const = 0;
-
         //! Get the number of options
         virtual size_t GetShaderOptionCount() const = 0;
 
@@ -44,47 +34,6 @@ namespace ShaderManagementConsole
 
         //! Get the information for the shader variant at the specified index
         virtual const AZ::RPI::ShaderVariantListSourceData::VariantInfo& GetShaderVariantInfo(size_t index) const = 0;
-
-        //! Load document and related data
-        //! @param loadPath Absolute path of document to load
-        virtual bool Open(AZStd::string_view loadPath) = 0;
-
-        //! Save document to file
-        virtual bool Save() = 0;
-
-        //! Save document copy
-        //! @param savePath Absolute path where document is saved
-        virtual bool SaveAsCopy(AZStd::string_view savePath) = 0;
-
-        //! Close document and reset its data
-        virtual bool Close() = 0;
-
-        //! document is loaded
-        virtual bool IsOpen() const = 0;
-
-        //! document has changes pending
-        virtual bool IsModified() const = 0;
-
-        //! Can the document be saved
-        virtual bool IsSavable() const = 0;
-
-        //! Returns true if there are reversible modifications to the document
-        virtual bool CanUndo() const = 0;
-
-        //! Returns true if there are changes that were reversed and can be re-applied to the document
-        virtual bool CanRedo() const = 0;
-
-        //! Restores the previous state of the document
-        virtual bool Undo() = 0;
-
-        //! Restores the next state of the document
-        virtual bool Redo() = 0;
-
-        //! Signal that editing is about to begin, like beginning to drag a slider control
-        virtual bool BeginEdit() = 0;
-
-        //! Signal that editing has completed, like after releasing the mouse button after continuously dragging a slider control
-        virtual bool EndEdit() = 0;
     };
 
     using ShaderManagementConsoleDocumentRequestBus = AZ::EBus<ShaderManagementConsoleDocumentRequests>;

Gems/Atom/Tools/ShaderManagementConsole/Code/Include/Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h

@@ -1,62 +0,0 @@
-/*
- * 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/EBus/EBus.h>
-
-namespace ShaderManagementConsole
-{
-    //! ShaderManagementConsoleDocumentSystemRequestBus provides high level file requests for menus, scripts, etc.
-    class ShaderManagementConsoleDocumentSystemRequests
-        : public AZ::EBusTraits
-    {
-    public:
-        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
-        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
-
-        //! Create a document object
-        //! @return Uuid of new document, or null Uuid if failed
-        virtual AZ::Uuid CreateDocument() = 0;
-
-        //! Destroy a document object with the specified id
-        //! @return true if Uuid was found and removed, otherwise false
-        virtual bool DestroyDocument(const AZ::Uuid& documentId) = 0;
-
-        //! Open a document for editing
-        //! @param sourcePath document to open.
-        //! @return unique id of new document if successful, otherwise null Uuid
-        virtual AZ::Uuid OpenDocument(AZStd::string_view sourcePath) = 0;
-
-        //! Close the specified document
-        //! @param documentId unique id of document to close
-        virtual bool CloseDocument(const AZ::Uuid& documentId) = 0;
-
-        //! Close all documents
-        virtual bool CloseAllDocuments() = 0;
-
-        //! Close all documents except for documentId
-        //! @param documentId unique id of document to not close
-        virtual bool CloseAllDocumentsExcept(const AZ::Uuid& documentId) = 0;
-
-        //! Save the specified document
-        //! @param documentId unique id of document to save
-        virtual bool SaveDocument(const AZ::Uuid& documentId) = 0;
-
-        //! Save the specified document to a different file
-        //! @param documentId unique id of document to save
-        //! @param targetPath location where document is saved.
-        virtual bool SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath) = 0;
-
-        //! Save all documents
-        virtual bool SaveAllDocuments() = 0;
-    };
-
-    using ShaderManagementConsoleDocumentSystemRequestBus = AZ::EBus<ShaderManagementConsoleDocumentSystemRequests>;
-
-} // namespace ShaderManagementConsole

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Document/ShaderManagementConsoleDocument.cpp

@@ -8,49 +8,32 @@
 
 #include <Atom/RPI.Edit/Common/JsonUtils.h>
 #include <Atom/RPI.Reflect/Asset/AssetUtils.h>
-
-#include <Document/ShaderManagementConsoleDocument.h>
-#include <Atom/Document/ShaderManagementConsoleDocumentNotificationBus.h>
-
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/SourceControl/SourceControlAPI.h>
+#include <Document/ShaderManagementConsoleDocument.h>
 
 namespace ShaderManagementConsole
 {
     ShaderManagementConsoleDocument::ShaderManagementConsoleDocument()
+        : AtomToolsFramework::AtomToolsDocument()
     {
         ShaderManagementConsoleDocumentRequestBus::Handler::BusConnect(m_id);
-        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentCreated, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentCreated, m_id);
     }
 
     ShaderManagementConsoleDocument::~ShaderManagementConsoleDocument()
     {
-        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentDestroyed, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentDestroyed, m_id);
         ShaderManagementConsoleDocumentRequestBus::Handler::BusDisconnect();
         Clear();
     }
 
-    const AZ::Uuid& ShaderManagementConsoleDocument::GetId() const
-    {
-        return m_id;
-    }
-
-    AZStd::string_view ShaderManagementConsoleDocument::GetAbsolutePath() const
-    {
-        return m_absolutePath;
-    }
-
-    AZStd::string_view ShaderManagementConsoleDocument::GetRelativePath() const
-    {
-        return m_relativePath;
-    }
-
     size_t ShaderManagementConsoleDocument::GetShaderOptionCount() const
     {
         auto layout = m_shaderAsset->GetShaderOptionGroupLayout();
         auto& shaderOptionDescriptors = layout->GetShaderOptions();
-
         return shaderOptionDescriptors.size();
     }
 
@@ -58,7 +41,6 @@ namespace ShaderManagementConsole
     {
         auto layout = m_shaderAsset->GetShaderOptionGroupLayout();
         auto& shaderOptionDescriptors = layout->GetShaderOptions();
-
         return shaderOptionDescriptors[index];
     }
 
@@ -128,75 +110,12 @@ namespace ShaderManagementConsole
             return false;
         }
 
-        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentOpened, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, m_id);
 
         AZ_TracePrintf("ShaderManagementConsoleDocument", "Document loaded: '%s'", m_absolutePath.c_str());
         return true;
     }
 
-    bool ShaderManagementConsoleDocument::Save()
-    {
-        if (!IsOpen())
-        {
-            AZ_Error("ShaderManagementConsoleDocument", false, "Document is not open to be saved: '%s'.", m_absolutePath.c_str());
-            return false;
-        }
-
-        if (!IsSavable())
-        {
-            AZ_Error("ShaderManagementConsoleDocument", false, "Document can not be saved: '%s'.", m_absolutePath.c_str());
-            return false;
-        }
-
-        AZ_Error("ShaderManagementConsoleDocument", false, "%s is not implemented!", __FUNCTION__);
-        return false;
-
-        // Auto add or checkout saved file
-        //AzToolsFramework::SourceControlCommandBus::Broadcast(&AzToolsFramework::SourceControlCommandBus::Events::RequestEdit,
-        //    m_absolutePath.c_str(), true,
-        //    [](bool, const AzToolsFramework::SourceControlFileInfo&) {});
-
-        //ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentSaved, m_id);
-
-        //AZ_TracePrintf("ShaderManagementConsoleDocument", "Document saved: %s", m_absolutePath.data());
-        //return true;
-    }
-
-    bool ShaderManagementConsoleDocument::SaveAsCopy(AZStd::string_view savePath)
-    {
-        if (!IsOpen())
-        {
-            AZ_Error("ShaderManagementConsoleDocument", false, "Document is not open to be saved: '%s'.", m_absolutePath.c_str());
-            return false;
-        }
-
-        if (!IsSavable())
-        {
-            AZ_Error("ShaderManagementConsoleDocument", false, "Document can not be saved: '%s'.", m_absolutePath.c_str());
-            return false;
-        }
-
-        AZStd::string normalizedSavePath = savePath;
-        if (!AzFramework::StringFunc::Path::Normalize(normalizedSavePath))
-        {
-            AZ_Error("ShaderManagementConsoleDocument", false, "Document save path could not be normalized: '%s'.", normalizedSavePath.c_str());
-            return false;
-        }
-
-        AZ_Error("ShaderManagementConsoleDocument", false, "%s is not implemented!", __FUNCTION__);
-        return false;
-
-        // Auto add or checkout saved file
-        //AzToolsFramework::SourceControlCommandBus::Broadcast(&AzToolsFramework::SourceControlCommandBus::Events::RequestEdit,
-        //    normalizedSavePath.c_str(), true,
-        //    [](bool, const AzToolsFramework::SourceControlFileInfo&) {});
-
-        //ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentSaved, m_id);
-
-        //AZ_TracePrintf("ShaderManagementConsoleDocument", "Document saved: %s", normalizedSavePath.c_str());
-        //return true;
-    }
-
     bool ShaderManagementConsoleDocument::Close()
     {
         if (!IsOpen())
@@ -206,7 +125,7 @@ namespace ShaderManagementConsole
         }
 
         Clear();
-        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentClosed, m_id);
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentClosed, m_id);
         AZ_TracePrintf("ShaderManagementConsoleDocument", "Document was closed");
         return true;
     }
@@ -216,81 +135,11 @@ namespace ShaderManagementConsole
         return !m_absolutePath.empty() && !m_relativePath.empty();
     }
 
-    bool ShaderManagementConsoleDocument::IsModified() const
-    {
-        return false;
-    }
-
-    bool ShaderManagementConsoleDocument::IsSavable() const
-    {
-        return true;
-    }
-
-    bool ShaderManagementConsoleDocument::CanUndo() const
-    {
-        // Undo will only be allowed if something has been recorded and we're not at the beginning of history
-        return IsOpen() && !m_undoHistory.empty() && m_undoHistoryIndex > 0;
-    }
-
-    bool ShaderManagementConsoleDocument::CanRedo() const
-    {
-        // Redo will only be allowed if something has been recorded and we're not at the end of history
-        return IsOpen() && !m_undoHistory.empty() && m_undoHistoryIndex < m_undoHistory.size();
-    }
-
-    bool ShaderManagementConsoleDocument::Undo()
-    {
-        if (CanUndo())
-        {
-            // The history index is one beyond the last executed command. Decrement the index then execute undo.
-            m_undoHistory[--m_undoHistoryIndex].first();
-            ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
-            return true;
-        }
-        return false;
-    }
-
-    bool ShaderManagementConsoleDocument::Redo()
-    {
-        if (CanRedo())
-        {
-            // Execute the current redo command then move the history index to the next position.
-            m_undoHistory[m_undoHistoryIndex++].second();
-            ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
-            return true;
-        }
-        return false;
-    }
-
-    bool ShaderManagementConsoleDocument::BeginEdit()
-    {
-        return true;
-    }
-
-    bool ShaderManagementConsoleDocument::EndEdit()
-    {
-        // Wipe any state beyond the current history index
-        m_undoHistory.erase(m_undoHistory.begin() + m_undoHistoryIndex, m_undoHistory.end());
-
-        // Add undo and redo operations using lambdas that will capture property state and restore it when executed
-        m_undoHistory.emplace_back(
-            [this]() { /**/ },
-            [this]() { /**/ });
-
-        // Assign the index to the end of history
-        m_undoHistoryIndex = aznumeric_cast<int>(m_undoHistory.size());
-        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentUndoStateChanged, m_id);
-
-        return true;
-    }
-
     void ShaderManagementConsoleDocument::Clear()
     {
         m_absolutePath.clear();
         m_relativePath.clear();
         m_shaderVariantListSourceData = {};
         m_shaderAsset = {};
-        m_undoHistory = {};
-        m_undoHistoryIndex = {};
     }
 } // namespace ShaderManagementConsole

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Document/ShaderManagementConsoleDocument.h

@@ -7,13 +7,12 @@
  */
 #pragma once
 
-#include <AzCore/RTTI/RTTI.h>
-#include <AzCore/Asset/AssetCommon.h>
-
-#include <Atom/RPI.Reflect/Shader/ShaderAsset.h>
-#include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
-
 #include <Atom/Document/ShaderManagementConsoleDocumentRequestBus.h>
+#include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
+#include <Atom/RPI.Reflect/Shader/ShaderAsset.h>
+#include <AtomToolsFramework/Document/AtomToolsDocument.h>
+#include <AzCore/Asset/AssetCommon.h>
+#include <AzCore/RTTI/RTTI.h>
 
 namespace ShaderManagementConsole
 {
@@ -21,7 +20,8 @@ namespace ShaderManagementConsole
      * ShaderManagementConsoleDocument provides an API for modifying and saving document properties.
      */
     class ShaderManagementConsoleDocument
-        : public ShaderManagementConsoleDocumentRequestBus::Handler
+        : public AtomToolsFramework::AtomToolsDocument
+        , public ShaderManagementConsoleDocumentRequestBus::Handler
     {
     public:
         AZ_RTTI(ShaderManagementConsoleDocument, "{DBA269AE-892B-415C-8FA1-166B94B0E045}");
@@ -31,29 +31,20 @@ namespace ShaderManagementConsole
         ShaderManagementConsoleDocument();
         virtual ~ShaderManagementConsoleDocument();
 
-        const AZ::Uuid& GetId() const;
+        ////////////////////////////////////////////////////////////////////////
+        // AtomToolsFramework::AtomToolsDocument
+        ////////////////////////////////////////////////////////////////////////
+        bool Open(AZStd::string_view loadPath) override;
+        bool Close() override;
+        bool IsOpen() const override;
+        ////////////////////////////////////////////////////////////////////////
 
         ////////////////////////////////////////////////////////////////////////
         // ShaderManagementConsoleDocumentRequestBus::Handler implementation
-        AZStd::string_view GetAbsolutePath() const override;
-        AZStd::string_view GetRelativePath() const override;
         size_t GetShaderOptionCount() const override;
         const AZ::RPI::ShaderOptionDescriptor& GetShaderOptionDescriptor(size_t index) const override;
         size_t GetShaderVariantCount() const override;
         const AZ::RPI::ShaderVariantListSourceData::VariantInfo& GetShaderVariantInfo(size_t index) const override;
-        bool Open(AZStd::string_view loadPath) override;
-        bool Save() override;
-        bool SaveAsCopy(AZStd::string_view savePath) override;
-        bool Close() override;
-        bool IsOpen() const override;
-        bool IsModified() const override;
-        bool IsSavable() const override;
-        bool CanUndo() const override;
-        bool CanRedo() const override;
-        bool Undo() override;
-        bool Redo() override;
-        bool BeginEdit() override;
-        bool EndEdit() override;
         ////////////////////////////////////////////////////////////////////////
 
     private:
@@ -67,28 +58,11 @@ namespace ShaderManagementConsole
         using UndoRedoHistory = AZStd::vector<UndoRedoFunctionPair>;
 
         void Clear();
- 
-        // Unique id of this document
-        AZ::Uuid m_id = AZ::Uuid::CreateRandom();
-
-        // Relative path to the document
-        AZStd::string m_relativePath;
-
-        // Absolute path to the document
-        AZStd::string m_absolutePath;
 
         // Source data for shader variant list
         AZ::RPI::ShaderVariantListSourceData m_shaderVariantListSourceData;
 
         // Shader asset for the corresponding shader variant list
         AZ::Data::Asset<AZ::RPI::ShaderAsset> m_shaderAsset;
-
-        // Variables needed for tracking the undo and redo state of this document
-
-        // Container of undo commands
-        UndoRedoHistory m_undoHistory;
-
-        // The current position in the undo redo history
-        int m_undoHistoryIndex = 0;
     };
 } // namespace ShaderManagementConsole

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Document/ShaderManagementConsoleDocumentModule.cpp

@@ -7,10 +7,8 @@
  */
 
 #include <Atom/Document/ShaderManagementConsoleDocumentModule.h>
-#include <Document/ShaderManagementConsoleDocumentSystemComponent.h>
-
-#include <AzToolsFramework/UI/PropertyEditor/PropertyManagerComponent.h>
 #include <AzToolsFramework/Asset/AssetSystemComponent.h>
+#include <Document/ShaderManagementConsoleDocumentSystemComponent.h>
 
 namespace ShaderManagementConsole
 {

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Document/ShaderManagementConsoleDocumentSystemComponent.cpp

@@ -6,41 +6,16 @@
  *
  */
 
-#include <Document/ShaderManagementConsoleDocumentSystemComponent.h>
-
-#include <AtomToolsFramework/Debug/TraceRecorder.h>
-#include <AtomToolsFramework/Util/Util.h>
+#include <Atom/Document/ShaderManagementConsoleDocumentRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 #include <AzCore/RTTI/BehaviorContext.h>
 #include <AzCore/Serialization/EditContext.h>
 #include <AzCore/Serialization/SerializeContext.h>
-
-#include <AzFramework/Asset/AssetSystemBus.h>
-#include <AzFramework/StringFunc/StringFunc.h>
-
-#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
-#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
-#include <AzToolsFramework/API/ViewPaneOptions.h>
-#include <AzToolsFramework/API/EditorAssetSystemAPI.h>
-#include <AtomToolsFramework/Util/Util.h>
-
-#include <Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h>
-#include <Atom/Document/ShaderManagementConsoleDocumentRequestBus.h>
-#include <Atom/Document/ShaderManagementConsoleDocumentNotificationBus.h>
-
-AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
-#include <QApplication>
-#include <QStyle>
-#include <QMessageBox>
-#include <QFileDialog>
-AZ_POP_DISABLE_WARNING
+#include <Document/ShaderManagementConsoleDocument.h>
+#include <Document/ShaderManagementConsoleDocumentSystemComponent.h>
 
 namespace ShaderManagementConsole
 {
-    ShaderManagementConsoleDocumentSystemComponent::ShaderManagementConsoleDocumentSystemComponent()
-    {
-    }
-
     void ShaderManagementConsoleDocumentSystemComponent::Reflect(AZ::ReflectContext* context)
     {
         if (AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context))
@@ -52,7 +27,7 @@ namespace ShaderManagementConsole
             {
                 ec->Class<ShaderManagementConsoleDocumentSystemComponent>("ShaderManagementConsoleDocumentSystemComponent", "Manages documents")
                     ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
-                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System", 0xc94d118b))
+                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC_CE("System"))
                     ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
                     ;
             }
@@ -60,64 +35,35 @@ namespace ShaderManagementConsole
 
         if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
         {
-            behaviorContext->EBus<ShaderManagementConsoleDocumentSystemRequestBus>("ShaderManagementConsoleDocumentSystemRequestBus")
-                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
-                ->Attribute(AZ::Script::Attributes::Category, "Editor")
-                ->Attribute(AZ::Script::Attributes::Module, "shadermanagementconsole")
-                ->Event("CreateDocument", &ShaderManagementConsoleDocumentSystemRequestBus::Events::CreateDocument)
-                ->Event("DestroyDocument", &ShaderManagementConsoleDocumentSystemRequestBus::Events::DestroyDocument)
-                ->Event("OpenDocument", &ShaderManagementConsoleDocumentSystemRequestBus::Events::OpenDocument)
-                ->Event("CloseDocument", &ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument)
-                ->Event("CloseAllDocuments", &ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseAllDocuments)
-                ->Event("CloseAllDocumentsExcept", &ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseAllDocumentsExcept)
-                ->Event("SaveDocument", &ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveDocument)
-                ->Event("SaveDocumentAsCopy", &ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveDocumentAsCopy)
-                ->Event("SaveAllDocuments", &ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveAllDocuments)
-                ;
-
             behaviorContext->EBus<ShaderManagementConsoleDocumentRequestBus>("ShaderManagementConsoleDocumentRequestBus")
                 ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                 ->Attribute(AZ::Script::Attributes::Category, "Editor")
                 ->Attribute(AZ::Script::Attributes::Module, "shadermanagementconsole")
-                ->Event("GetAbsolutePath", &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath)
-                ->Event("GetRelativePath", &ShaderManagementConsoleDocumentRequestBus::Events::GetRelativePath)
                 ->Event("GetShaderOptionCount", &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderOptionCount)
                 ->Event("GetShaderOptionDescriptor", &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderOptionDescriptor)
                 ->Event("GetShaderVariantCount", &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderVariantCount)
                 ->Event("GetShaderVariantInfo", &ShaderManagementConsoleDocumentRequestBus::Events::GetShaderVariantInfo)
-                ->Event("Open", &ShaderManagementConsoleDocumentRequestBus::Events::Open)
-                ->Event("Close", &ShaderManagementConsoleDocumentRequestBus::Events::Close)
-                ->Event("Save", &ShaderManagementConsoleDocumentRequestBus::Events::Save)
-                ->Event("SaveAsCopy", &ShaderManagementConsoleDocumentRequestBus::Events::SaveAsCopy)
-                ->Event("IsOpen", &ShaderManagementConsoleDocumentRequestBus::Events::IsOpen)
-                ->Event("IsModified", &ShaderManagementConsoleDocumentRequestBus::Events::IsModified)
-                ->Event("IsSavable", &ShaderManagementConsoleDocumentRequestBus::Events::IsSavable)
-                ->Event("CanUndo", &ShaderManagementConsoleDocumentRequestBus::Events::CanUndo)
-                ->Event("CanRedo", &ShaderManagementConsoleDocumentRequestBus::Events::CanRedo)
-                ->Event("Undo", &ShaderManagementConsoleDocumentRequestBus::Events::Undo)
-                ->Event("Redo", &ShaderManagementConsoleDocumentRequestBus::Events::Redo)
-                ->Event("BeginEdit", &ShaderManagementConsoleDocumentRequestBus::Events::BeginEdit)
-                ->Event("EndEdit", &ShaderManagementConsoleDocumentRequestBus::Events::EndEdit)
                 ;
         }
     }
 
     void ShaderManagementConsoleDocumentSystemComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
     {
-        required.push_back(AZ_CRC("AssetProcessorToolsConnection", 0x734669bc));
-        required.push_back(AZ_CRC("AssetDatabaseService", 0x3abf5601));
-        required.push_back(AZ_CRC("PropertyManagerService", 0x63a3d7ad));
-        required.push_back(AZ_CRC("RPISystem", 0xf2add773));
+        required.push_back(AZ_CRC_CE("AtomToolsDocumentSystemService"));
+        required.push_back(AZ_CRC_CE("AssetProcessorToolsConnection"));
+        required.push_back(AZ_CRC_CE("AssetDatabaseService"));
+        required.push_back(AZ_CRC_CE("PropertyManagerService"));
+        required.push_back(AZ_CRC_CE("RPISystem"));
     }
 
     void ShaderManagementConsoleDocumentSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
     {
-        provided.push_back(AZ_CRC("ShaderManagementConsoleDocumentSystemService"));
+        provided.push_back(AZ_CRC_CE("ShaderManagementConsoleDocumentSystemService"));
     }
 
     void ShaderManagementConsoleDocumentSystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
     {
-        incompatible.push_back(AZ_CRC("ShaderManagementConsoleDocumentSystemService"));
+        incompatible.push_back(AZ_CRC_CE("ShaderManagementConsoleDocumentSystemService"));
     }
 
     void ShaderManagementConsoleDocumentSystemComponent::Init()
@@ -126,256 +72,15 @@ namespace ShaderManagementConsole
 
     void ShaderManagementConsoleDocumentSystemComponent::Activate()
     {
-        m_documentMap.clear();
-        ShaderManagementConsoleDocumentSystemRequestBus::Handler::BusConnect();
+        AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(
+            &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Handler::RegisterDocumentType,
+            []()
+            {
+                return aznew ShaderManagementConsoleDocument();
+            });
     }
 
     void ShaderManagementConsoleDocumentSystemComponent::Deactivate()
     {
-        ShaderManagementConsoleDocumentSystemRequestBus::Handler::BusDisconnect();
-        m_documentMap.clear();
-    }
-
-    AZ::Uuid ShaderManagementConsoleDocumentSystemComponent::CreateDocument()
-    {
-        auto document = AZStd::make_unique<ShaderManagementConsoleDocument>();
-        if (!document)
-        {
-            AZ_Error("ShaderManagementConsoleDocument", false, "Failed to create new document");
-            return AZ::Uuid::CreateNull();
-        }
-
-        AZ::Uuid documentId = document->GetId();
-        m_documentMap.emplace(documentId, document.release());
-        return documentId;
-    }
-
-    bool ShaderManagementConsoleDocumentSystemComponent::DestroyDocument(const AZ::Uuid& documentId)
-    {
-        return m_documentMap.erase(documentId) != 0;
-    }
-
-    AZ::Uuid ShaderManagementConsoleDocumentSystemComponent::OpenDocument(AZStd::string_view sourcePath)
-    {
-        return OpenDocumentImpl(sourcePath, true);
-    }
-
-    bool ShaderManagementConsoleDocumentSystemComponent::CloseDocument(const AZ::Uuid& documentId)
-    {
-        bool isOpen = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(isOpen, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::IsOpen);
-        if (!isOpen)
-        {
-            // immediately destroy unopened documents
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::DestroyDocument, documentId);
-            return true;
-        }
-
-        AZStd::string documentPath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(documentPath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
-
-        bool isModified = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(isModified, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::IsModified);
-        if (isModified)
-        {
-            auto selection = QMessageBox::question(QApplication::activeWindow(),
-                QString("Document has unsaved changes"),
-                QString("Do you want to save changes to\n%1?").arg(documentPath.c_str()),
-                QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
-            if (selection == QMessageBox::Cancel)
-            {
-                AZ_TracePrintf("ShaderManagementConsoleDocument", "Close document canceled: %s", documentPath.c_str());
-                return false;
-            }
-            if (selection == QMessageBox::Yes)
-            {
-                if (!SaveDocument(documentId))
-                {
-                    AZ_Error("ShaderManagementConsoleDocument", false, "Close document failed because document was not saved: %s", documentPath.c_str());
-                    return false;
-                }
-            }
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        bool closeResult = true;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(closeResult, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Close);
-        if (!closeResult)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be closed"),
-                QString("Failed to close: \n%1\n\n%2").arg(documentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return false;
-        }
-
-        ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::DestroyDocument, documentId);
-        return true;
-    }
-
-    bool ShaderManagementConsoleDocumentSystemComponent::CloseAllDocuments()
-    {
-        bool result = true;
-        auto documentMap = m_documentMap;
-        for (const auto& documentPair : documentMap)
-        {
-            if (!CloseDocument(documentPair.first))
-            {
-                result = false;
-            }
-        }
-
-        return result;
-    }
-
-    bool ShaderManagementConsoleDocumentSystemComponent::CloseAllDocumentsExcept(const AZ::Uuid& documentId)
-    {
-        bool result = true;
-        auto documentMap = m_documentMap;
-        for (const auto& documentPair : documentMap)
-        {
-            if (documentPair.first != documentId)
-            {
-                if (!CloseDocument(documentPair.first))
-                {
-                    result = false;
-                }
-            }
-        }
-
-        return result;
-    }
-
-    bool ShaderManagementConsoleDocumentSystemComponent::SaveDocument(const AZ::Uuid& documentId)
-    {
-        AZStd::string saveDocumentPath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(saveDocumentPath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
-
-        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
-        {
-            return false;
-        }
-
-        const QFileInfo saveInfo(saveDocumentPath.c_str());
-        if (saveInfo.exists() && !saveInfo.isWritable())
-        {
-            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
-            return false;
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        bool result = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(result, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Save);
-        if (!result)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be saved"),
-                QString("Failed to save: \n%1\n\n%2").arg(saveDocumentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return false;
-        }
-
-        return true;
-    }
-
-    bool ShaderManagementConsoleDocumentSystemComponent::SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath)
-    {
-        AZStd::string saveDocumentPath = targetPath;
-        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
-        {
-            return false;
-        }
-
-        const QFileInfo saveInfo(saveDocumentPath.c_str());
-        if (saveInfo.exists() && !saveInfo.isWritable())
-        {
-            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
-            return false;
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        bool result = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(result, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::SaveAsCopy, saveDocumentPath);
-        if (!result)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be saved"),
-                QString("Failed to save: \n%1\n\n%2").arg(saveDocumentPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return false;
-        }
-
-        return true;
-    }
-
-    bool ShaderManagementConsoleDocumentSystemComponent::SaveAllDocuments()
-    {
-        bool result = true;
-        for (const auto& documentPair : m_documentMap)
-        {
-            if (!SaveDocument(documentPair.first))
-            {
-                result = false;
-            }
-        }
-
-        return result;
-    }
-
-    AZ::Uuid ShaderManagementConsoleDocumentSystemComponent::OpenDocumentImpl(AZStd::string_view sourcePath, bool checkIfAlreadyOpen)
-    {
-        AZStd::string requestedPath = sourcePath;
-        if (requestedPath.empty())
-        {
-            return AZ::Uuid::CreateNull();
-        }
-
-        if (!AzFramework::StringFunc::Path::Normalize(requestedPath))
-        {
-            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document path is invalid:\n%1").arg(requestedPath.c_str()));
-            return AZ::Uuid::CreateNull();
-        }
-
-        // Determine if the file is already open and select it
-        if (checkIfAlreadyOpen)
-        {
-            for (const auto& documentPair : m_documentMap)
-            {
-                AZStd::string openDocumentPath;
-                ShaderManagementConsoleDocumentRequestBus::EventResult(openDocumentPath, documentPair.first, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
-                if (openDocumentPath == requestedPath)
-                {
-                    ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentOpened, documentPair.first);
-                    return documentPair.first;
-                }
-            }
-        }
-
-        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
-
-        AZ::Uuid documentId = AZ::Uuid::CreateNull();
-        ShaderManagementConsoleDocumentSystemRequestBus::BroadcastResult(documentId, &ShaderManagementConsoleDocumentSystemRequestBus::Events::CreateDocument);
-        if (documentId.IsNull())
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be created"),
-                QString("Failed to create: \n%1\n\n%2").arg(requestedPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            return AZ::Uuid::CreateNull();
-        }
-
-        traceRecorder.GetDump().clear();
-
-        bool openResult = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(openResult, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Open, requestedPath);
-        if (!openResult)
-        {
-            QMessageBox::critical(
-                QApplication::activeWindow(), QString("Document could not be opened"),
-                QString("Failed to open: \n%1\n\n%2").arg(requestedPath.c_str()).arg(traceRecorder.GetDump().c_str()));
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::DestroyDocument, documentId);
-            return AZ::Uuid::CreateNull();
-        }
-
-        return documentId;
     }
 }

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Document/ShaderManagementConsoleDocumentSystemComponent.h

@@ -9,28 +9,17 @@
 #pragma once
 
 #include <AzCore/Component/Component.h>
-#include <AzCore/std/smart_ptr/shared_ptr.h>
-
-#include <Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h>
-#include <Atom/RPI.Public/WindowContext.h>
-#include <Document/ShaderManagementConsoleDocument.h>
-
-AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
-#include <QFileInfo>
-#include <QString>
-AZ_POP_DISABLE_WARNING
 
 namespace ShaderManagementConsole
 {
-    //! ShaderManagementConsoleDocumentSystemComponent is the central component of the Shader Management Console Core gem
+    //! ShaderManagementConsoleDocumentSystemComponent
     class ShaderManagementConsoleDocumentSystemComponent
         : public AZ::Component
-        , private ShaderManagementConsoleDocumentSystemRequestBus::Handler
     {
     public:
-        AZ_COMPONENT(ShaderManagementConsoleDocumentSystemComponent, "{58ABE0AE-2710-41E2-ADFD-E2D67407427D}");
+        AZ_COMPONENT(ShaderManagementConsoleDocumentSystemComponent, "{1610159D-59DC-48B1-B2D1-FCE7AFD3B012}");
 
-        ShaderManagementConsoleDocumentSystemComponent();
+        ShaderManagementConsoleDocumentSystemComponent() = default;
         ~ShaderManagementConsoleDocumentSystemComponent() = default;
         ShaderManagementConsoleDocumentSystemComponent(const ShaderManagementConsoleDocumentSystemComponent&) = delete;
         ShaderManagementConsoleDocumentSystemComponent& operator =(const ShaderManagementConsoleDocumentSystemComponent&) = delete;
@@ -48,23 +37,5 @@ namespace ShaderManagementConsole
         void Activate() override;
         void Deactivate() override;
         ////////////////////////////////////////////////////////////////////////
-
-        ////////////////////////////////////////////////////////////////////////
-        // ShaderManagementConsoleDocumentSystemRequestBus::Handler overrides...
-        AZ::Uuid CreateDocument() override;
-        bool DestroyDocument(const AZ::Uuid& documentId) override;
-        AZ::Uuid OpenDocument(AZStd::string_view sourcePath) override;
-        bool CloseDocument(const AZ::Uuid& documentId) override;
-        bool CloseAllDocuments() override;
-        bool CloseAllDocumentsExcept(const AZ::Uuid& documentId) override;
-        bool SaveDocument(const AZ::Uuid& documentId) override;
-        bool SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath) override;
-        bool SaveAllDocuments() override;
-        ////////////////////////////////////////////////////////////////////////
-
-        AZ::Uuid OpenDocumentImpl(AZStd::string_view sourcePath, bool checkIfAlreadyOpen);
-
-        AZStd::unordered_map<AZ::Uuid, AZStd::shared_ptr<ShaderManagementConsoleDocument>> m_documentMap;
-        const size_t m_maxMessageBoxLineCount = 15;
     };
 }

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/ShaderManagementConsoleApplication.cpp

@@ -7,8 +7,8 @@
  */
 
 #include <Atom/Document/ShaderManagementConsoleDocumentModule.h>
-#include <Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h>
 #include <Atom/Window/ShaderManagementConsoleWindowModule.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 #include <AzCore/Settings/SettingsRegistryMergeUtils.h>
 #include <ShaderManagementConsoleApplication.h>
 #include <ShaderManagementConsole_Traits_Platform.h>
@@ -66,8 +66,8 @@ namespace ShaderManagementConsole
             const AZStd::string openDocumentPath = commandLine.GetMiscValue(openDocumentIndex);
 
             AZ_Printf(GetBuildTargetName().c_str(), "Opening document: %s", openDocumentPath.c_str());
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(
-                &ShaderManagementConsoleDocumentSystemRequestBus::Events::OpenDocument, openDocumentPath);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(
+                &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::OpenDocument, openDocumentPath);
         }
 
         Base::ProcessCommandLine(commandLine);

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/ShaderManagementConsoleApplication.h

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include <Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h>
 #include <AtomToolsFramework/Application/AtomToolsApplication.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 
 namespace ShaderManagementConsole
 {

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleBrowserInteractions.cpp

@@ -6,28 +6,24 @@
  *
  */
 
-#include <QApplication>
-#include <QMenu>
-#include <QInputDialog>
-#include <QMessageBox>
-#include <QFileDialog>
-#include <QDesktopServices>
-
-#include <AzQtComponents/Utilities/DesktopUtilities.h>
-
+#include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
+#include <AtomToolsFramework/Util/Util.h>
 #include <AzFramework/StringFunc/StringFunc.h>
-
+#include <AzQtComponents/Utilities/DesktopUtilities.h>
 #include <AzToolsFramework/API/EditorPythonRunnerRequestsBus.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
 #include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
 #include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
 #include <AzToolsFramework/Thumbnails/SourceControlThumbnail.h>
-#include <AtomToolsFramework/Util/Util.h>
+#include <Window/ShaderManagementConsoleBrowserInteractions.h>
 
-#include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
-#include <Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h>
-
-#include <Source/Window/ShaderManagementConsoleBrowserInteractions.h>
+#include <QApplication>
+#include <QDesktopServices>
+#include <QFileDialog>
+#include <QInputDialog>
+#include <QMenu>
+#include <QMessageBox>
 
 namespace ShaderManagementConsole
 {
@@ -80,7 +76,7 @@ namespace ShaderManagementConsole
         {
             if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), AZ::RPI::ShaderVariantListSourceData::Extension))
             {
-                ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::OpenDocument, entry->GetFullPath().c_str());
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::OpenDocument, entry->GetFullPath().c_str());
             }
             else
             {

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleBrowserWidget.cpp

@@ -6,26 +6,21 @@
  *
  */
 
-#include <AzQtComponents/Utilities/DesktopUtilities.h>
-
-#include <AzFramework/StringFunc/StringFunc.h>
-
-#include <AzToolsFramework/AssetBrowser/AssetBrowserModel.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserFilterModel.h>
-#include <AzToolsFramework/AssetBrowser/Views/AssetBrowserTreeView.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
-#include <AzToolsFramework/AssetBrowser/Search/Filter.h>
-#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
-
-#include <Atom/RPI.Reflect/Shader/ShaderAsset.h>
-
-#include <Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h>
 #include <Atom/Document/ShaderManagementConsoleDocumentRequestBus.h>
-
-#include <Source/Window/ShaderManagementConsoleBrowserWidget.h>
-
-#include <Source/Window/ui_ShaderManagementConsoleBrowserWidget.h>
+#include <Atom/RPI.Reflect/Shader/ShaderAsset.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
+#include <AzFramework/StringFunc/StringFunc.h>
+#include <AzQtComponents/Utilities/DesktopUtilities.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserFilterModel.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserModel.h>
+#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
+#include <AzToolsFramework/AssetBrowser/Search/Filter.h>
+#include <AzToolsFramework/AssetBrowser/Views/AssetBrowserTreeView.h>
+#include <Window/ShaderManagementConsoleBrowserWidget.h>
+#include <Window/ui_ShaderManagementConsoleBrowserWidget.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
 #include <QDesktopServices>
@@ -85,14 +80,14 @@ namespace ShaderManagementConsole
         });
 
         AssetBrowserModelNotificationBus::Handler::BusConnect();
-        ShaderManagementConsoleDocumentNotificationBus::Handler::BusConnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusConnect();
     }
 
     ShaderManagementConsoleBrowserWidget::~ShaderManagementConsoleBrowserWidget()
     {
         // Maintains the tree expansion state between runs
         m_ui->m_assetBrowserTreeViewWidget->SaveState();
-        ShaderManagementConsoleDocumentNotificationBus::Handler::BusDisconnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusDisconnect();
         AssetBrowserModelNotificationBus::Handler::BusDisconnect();
     }
 
@@ -150,7 +145,7 @@ namespace ShaderManagementConsole
             {
                 if (AzFramework::StringFunc::Path::IsExtension(sourceEntry->GetFullPath().c_str(), AZ::RPI::ShaderVariantListSourceData::Extension))
                 {
-                    ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::OpenDocument, sourceEntry->GetFullPath());
+                    AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::OpenDocument, sourceEntry->GetFullPath());
                 }
                 else
                 {
@@ -192,7 +187,7 @@ namespace ShaderManagementConsole
     void ShaderManagementConsoleBrowserWidget::OnDocumentOpened(const AZ::Uuid& documentId)
     {
         AZStd::string absolutePath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(absolutePath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
         if (!absolutePath.empty())
         {
             m_pathToSelect = absolutePath;
@@ -203,4 +198,4 @@ namespace ShaderManagementConsole
 
 } // namespace ShaderManagementConsole
 
-#include <Source/Window/moc_ShaderManagementConsoleBrowserWidget.cpp>
+#include <Window/moc_ShaderManagementConsoleBrowserWidget.cpp>

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleBrowserWidget.h

@@ -9,11 +9,10 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
-#include <AzToolsFramework/AssetBrowser/Search/Filter.h>
 #include <AzToolsFramework/AssetBrowser/Entries/AssetBrowserEntry.h>
 #include <AzToolsFramework/AssetBrowser/Search/Filter.h>
-#include <Atom/Document/ShaderManagementConsoleDocumentNotificationBus.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
 #include <QWidget>
@@ -44,7 +43,7 @@ namespace ShaderManagementConsole
     class ShaderManagementConsoleBrowserWidget
         : public QWidget
         , public AzToolsFramework::AssetBrowser::AssetBrowserModelNotificationBus::Handler
-        , public ShaderManagementConsoleDocumentNotificationBus::Handler
+        , public AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler
     {
         Q_OBJECT
     public:
@@ -64,7 +63,7 @@ namespace ShaderManagementConsole
         // AssetBrowserModelNotificationBus::Handler implementation
         void EntryAdded(const AzToolsFramework::AssetBrowser::AssetBrowserEntry* entry) override;
 
-        // ShaderManagementConsoleDocumentNotificationBus::Handler implementation
+        // AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler implementation
         void OnDocumentOpened(const AZ::Uuid& documentId) override;
     };
 } // namespace ShaderManagementConsole

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleWindow.cpp

@@ -13,12 +13,11 @@
 #include <AzToolsFramework/API/EditorPythonRunnerRequestsBus.h>
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/PythonTerminal/ScriptTermDialog.h>
-
 #include <AtomToolsFramework/Util/Util.h>
 #include <AtomToolsFramework/Window/AtomToolsMainWindowNotificationBus.h>
-
 #include <Atom/Document/ShaderManagementConsoleDocumentRequestBus.h>
-#include <Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentRequestBus.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 #include <Window/ShaderManagementConsoleWindow.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
@@ -62,19 +61,19 @@ namespace ShaderManagementConsole
         // Restore geometry and show the window
         mainWindowWrapper->showFromSettings();
 
-        ShaderManagementConsoleDocumentNotificationBus::Handler::BusConnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusConnect();
         OnDocumentOpened(AZ::Uuid::CreateNull());
     }
 
     ShaderManagementConsoleWindow::~ShaderManagementConsoleWindow()
     {
-        ShaderManagementConsoleDocumentNotificationBus::Handler::BusDisconnect();
+        AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler::BusDisconnect();
     }
 
     void ShaderManagementConsoleWindow::closeEvent(QCloseEvent* closeEvent)
     {
         bool didClose = true;
-        ShaderManagementConsoleDocumentSystemRequestBus::BroadcastResult(didClose, &ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseAllDocuments);
+        AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(didClose, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseAllDocuments);
         if (!didClose)
         {
             closeEvent->ignore();
@@ -88,17 +87,17 @@ namespace ShaderManagementConsole
     void ShaderManagementConsoleWindow::OnDocumentOpened(const AZ::Uuid& documentId)
     {
         bool isOpen = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(isOpen, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::IsOpen);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isOpen, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsOpen);
         bool isSavable = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(isSavable, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::IsSavable);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isSavable, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsSavable);
         bool isModified = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(isModified, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::IsModified);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isModified, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsModified);
         bool canUndo = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(canUndo, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::CanUndo);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(canUndo, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::CanUndo);
         bool canRedo = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(canRedo, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::CanRedo);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(canRedo, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::CanRedo);
         AZStd::string absolutePath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(absolutePath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
         AZStd::string filename;
         AzFramework::StringFunc::Path::GetFullFileName(absolutePath.c_str(), filename);
 
@@ -150,7 +149,7 @@ namespace ShaderManagementConsole
         const QString documentPath = GetDocumentPath(documentId);
         if (!documentPath.isEmpty())
         {
-            const QString status = QString("Document closed: %1").arg(documentPath);
+            const QString status = QString("Document opened: %1").arg(documentPath);
             m_statusMessage->setText(QString("<font color=\"White\">%1</font>").arg(status));
         }
     }
@@ -167,9 +166,9 @@ namespace ShaderManagementConsole
     void ShaderManagementConsoleWindow::OnDocumentModified(const AZ::Uuid& documentId)
     {
         bool isModified = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(isModified, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::IsModified);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isModified, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsModified);
         AZStd::string absolutePath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(absolutePath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
         AZStd::string filename;
         AzFramework::StringFunc::Path::GetFullFileName(absolutePath.c_str(), filename);
         UpdateTabForDocumentId(documentId, filename, absolutePath, isModified);
@@ -180,9 +179,9 @@ namespace ShaderManagementConsole
         if (documentId == GetDocumentIdFromTab(m_tabWidget->currentIndex()))
         {
             bool canUndo = false;
-            ShaderManagementConsoleDocumentRequestBus::EventResult(canUndo, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::CanUndo);
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(canUndo, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::CanUndo);
             bool canRedo = false;
-            ShaderManagementConsoleDocumentRequestBus::EventResult(canRedo, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::CanRedo);
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(canRedo, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::CanRedo);
             m_actionUndo->setEnabled(canUndo);
             m_actionRedo->setEnabled(canRedo);
         }
@@ -191,15 +190,15 @@ namespace ShaderManagementConsole
     void ShaderManagementConsoleWindow::OnDocumentSaved(const AZ::Uuid& documentId)
     {
         bool isModified = false;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(isModified, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::IsModified);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(isModified, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::IsModified);
         AZStd::string absolutePath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(absolutePath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::GetAbsolutePath);
         AZStd::string filename;
         AzFramework::StringFunc::Path::GetFullFileName(absolutePath.c_str(), filename);
         UpdateTabForDocumentId(documentId, filename, absolutePath, isModified);
 
         const QString documentPath = GetDocumentPath(documentId);
-        const QString status = QString("Document closed: %1").arg(documentPath);
+        const QString status = QString("Document saved: %1").arg(documentPath);
         m_statusMessage->setText(QString("<font color=\"White\">%1</font>").arg(status));
     }
 
@@ -217,7 +216,7 @@ namespace ShaderManagementConsole
             const AZStd::string filePath = AtomToolsFramework::GetOpenFileInfo(assetTypes).absoluteFilePath().toUtf8().constData();
             if (!filePath.empty())
             {
-                ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::OpenDocument, filePath);
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::OpenDocument, filePath);
             }
         }, QKeySequence::Open);
 
@@ -228,11 +227,11 @@ namespace ShaderManagementConsole
         m_actionSave = m_menuFile->addAction("&Save", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
             bool result = false;
-            ShaderManagementConsoleDocumentSystemRequestBus::BroadcastResult(result, &ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveDocument, documentId);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(result, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::SaveDocument, documentId);
             if (!result)
             {
                 const QString documentPath = GetDocumentPath(documentId);
-                const QString status = QString("Failed to save document: %1").arg(documentPath);
+                const QString status = QString("Document save failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         }, QKeySequence::Save);
@@ -242,21 +241,21 @@ namespace ShaderManagementConsole
             const QString documentPath = GetDocumentPath(documentId);
 
             bool result = false;
-            ShaderManagementConsoleDocumentSystemRequestBus::BroadcastResult(result, &ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveDocumentAsCopy,
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(result, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::SaveDocumentAsCopy,
                 documentId, AtomToolsFramework::GetSaveFileInfo(documentPath).absoluteFilePath().toUtf8().constData());
             if (!result)
             {
-                const QString status = QString("Failed to save document: %1").arg(documentPath);
+                const QString status = QString("Document save failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         }, QKeySequence::SaveAs);
 
         m_actionSaveAll = m_menuFile->addAction("Save A&ll", [this]() {
             bool result = false;
-            ShaderManagementConsoleDocumentSystemRequestBus::BroadcastResult(result, &ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveAllDocuments);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::BroadcastResult(result, &AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::SaveAllDocuments);
             if (!result)
             {
-                const QString status = QString("Failed to save documents.");
+                const QString status = QString("Document save all failed.");
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         });
@@ -265,16 +264,16 @@ namespace ShaderManagementConsole
 
         m_actionClose = m_menuFile->addAction("&Close", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument, documentId);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseDocument, documentId);
         }, QKeySequence::Close);
 
         m_actionCloseAll = m_menuFile->addAction("Close All", [this]() {
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseAllDocuments);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseAllDocuments);
         });
 
         m_actionCloseOthers = m_menuFile->addAction("Close Others", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
         });
 
         m_menuFile->addSeparator();
@@ -298,11 +297,11 @@ namespace ShaderManagementConsole
         m_actionUndo = m_menuEdit->addAction("&Undo", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
             bool result = false;
-            ShaderManagementConsoleDocumentRequestBus::EventResult(result, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Undo);
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(result, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::Undo);
             if (!result)
             {
                 const QString documentPath = GetDocumentPath(documentId);
-                const QString status = QString("Failed to perform undo on document: %1").arg(documentPath);
+                const QString status = QString("Document undo failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         }, QKeySequence::Undo);
@@ -310,11 +309,11 @@ namespace ShaderManagementConsole
         m_actionRedo = m_menuEdit->addAction("&Redo", [this]() {
             const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
             bool result = false;
-            ShaderManagementConsoleDocumentRequestBus::EventResult(result, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Redo);
+            AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(result, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Events::Redo);
             if (!result)
             {
                 const QString documentPath = GetDocumentPath(documentId);
-                const QString status = QString("Failed to perform redo on document: %1").arg(documentPath);
+                const QString status = QString("Document redo failed: %1").arg(documentPath);
                 m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
             }
         }, QKeySequence::Redo);
@@ -366,19 +365,19 @@ namespace ShaderManagementConsole
         // This should automatically clear the active document
         connect(m_tabWidget, &QTabWidget::currentChanged, this, [this](int tabIndex) {
             const AZ::Uuid documentId = GetDocumentIdFromTab(tabIndex);
-            ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentOpened, documentId);
+            AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, documentId);
         });
 
         connect(m_tabWidget, &QTabWidget::tabCloseRequested, this, [this](int tabIndex) {
             const AZ::Uuid documentId = GetDocumentIdFromTab(tabIndex);
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument, documentId);
+            AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseDocument, documentId);
         });
     }
 
     QString ShaderManagementConsoleWindow::GetDocumentPath(const AZ::Uuid& documentId) const
     {
         AZStd::string absolutePath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(absolutePath, documentId, &ShaderManagementConsoleDocumentRequestBus::Handler::GetAbsolutePath);
+        AtomToolsFramework::AtomToolsDocumentRequestBus::EventResult(absolutePath, documentId, &AtomToolsFramework::AtomToolsDocumentRequestBus::Handler::GetAbsolutePath);
         return absolutePath.c_str();
     }
 
@@ -394,15 +393,15 @@ namespace ShaderManagementConsole
             const QString selectActionName = (currentTabIndex == clickedTabIndex) ? "Select in Browser" : "Select";
             tabMenu.addAction(selectActionName, [this, clickedTabIndex]() {
                 const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
-                ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentOpened, documentId);
+                AtomToolsFramework::AtomToolsDocumentNotificationBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentNotificationBus::Events::OnDocumentOpened, documentId);
             });
             tabMenu.addAction("Close", [this, clickedTabIndex]() {
                 const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
-                ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument, documentId);
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseDocument, documentId);
             });
             auto closeOthersAction = tabMenu.addAction("Close Others", [this, clickedTabIndex]() {
                 const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
-                ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
+                AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Broadcast(&AtomToolsFramework::AtomToolsDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
             });
             closeOthersAction->setEnabled(tabBar->count() > 1);
             tabMenu.exec(QCursor::pos());

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleWindow.h

@@ -9,9 +9,9 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
-#include <Atom/Document/ShaderManagementConsoleDocumentNotificationBus.h>
 #include <Atom/RPI.Edit/Shader/ShaderVariantListSourceData.h>
 #include <Atom/RPI.Public/Shader/Shader.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentNotificationBus.h>
 #include <AtomToolsFramework/Window/AtomToolsMainWindow.h>
 #include <AzCore/Memory/SystemAllocator.h>
 
@@ -31,7 +31,7 @@ namespace ShaderManagementConsole
      */
     class ShaderManagementConsoleWindow
         : public AtomToolsFramework::AtomToolsMainWindow
-        , private ShaderManagementConsoleDocumentNotificationBus::Handler
+        , private AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler
     {
         Q_OBJECT
     public:
@@ -43,7 +43,7 @@ namespace ShaderManagementConsole
         ~ShaderManagementConsoleWindow();
 
     private:
-        // ShaderManagementConsoleDocumentNotificationBus::Handler overrides...
+        // AtomToolsFramework::AtomToolsDocumentNotificationBus::Handler overrides...
         void OnDocumentOpened(const AZ::Uuid& documentId) override;
         void OnDocumentClosed(const AZ::Uuid& documentId) override;
         void OnDocumentModified(const AZ::Uuid& documentId) override;

Gems/Atom/Tools/ShaderManagementConsole/Code/Source/Window/ShaderManagementConsoleWindowComponent.cpp

@@ -6,25 +6,20 @@
  *
  */
 
-#include <Atom/RPI.Edit/Common/JsonUtils.h>
-
-#include <Atom/RPI.Reflect/Asset/AssetUtils.h>
-#include <Atom/RPI.Edit/Common/AssetUtils.h>
-#include <Atom/RPI.Public/Material/Material.h>
-
 #include <AssetDatabase/AssetDatabaseConnection.h>
-
-#include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/Serialization/EditContext.h>
+#include <Atom/RPI.Edit/Common/AssetUtils.h>
+#include <Atom/RPI.Edit/Common/JsonUtils.h>
+#include <Atom/RPI.Public/Material/Material.h>
+#include <Atom/RPI.Reflect/Asset/AssetUtils.h>
+#include <AtomToolsFramework/Document/AtomToolsDocumentSystemRequestBus.h>
 #include <AzCore/RTTI/BehaviorContext.h>
-
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/Serialization/SerializeContext.h>
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
 #include <AzToolsFramework/UI/UICore/QWidgetSavedState.h>
-
-#include <Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h>
-#include <Source/Window/ShaderManagementConsoleWindowComponent.h>
-#include <Source/Window/ShaderManagementConsoleWindow.h>
+#include <Window/ShaderManagementConsoleWindow.h>
+#include <Window/ShaderManagementConsoleWindowComponent.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
 #include <QFile>

Gems/Atom/Tools/ShaderManagementConsole/Code/shadermanagementconsole_files.cmake

@@ -10,7 +10,5 @@ set(FILES
     Source/main.cpp
     Source/ShaderManagementConsoleApplication.cpp
     Source/ShaderManagementConsoleApplication.h
-    Include/Atom/Document/ShaderManagementConsoleDocumentModule.h
-    Source/Document/ShaderManagementConsoleDocumentModule.cpp
     ../Scripts/GenerateShaderVariantListForMaterials.py
 )

Gems/Atom/Tools/ShaderManagementConsole/Code/shadermanagementconsoledocument_files.cmake

@@ -7,11 +7,11 @@
 #
 
 set(FILES
-    Include/Atom/Document/ShaderManagementConsoleDocumentSystemRequestBus.h
-    Include/Atom/Document/ShaderManagementConsoleDocumentNotificationBus.h
+    Include/Atom/Document/ShaderManagementConsoleDocumentModule.h
     Include/Atom/Document/ShaderManagementConsoleDocumentRequestBus.h
-    Source/Document/ShaderManagementConsoleDocumentSystemComponent.cpp
-    Source/Document/ShaderManagementConsoleDocumentSystemComponent.h
     Source/Document/ShaderManagementConsoleDocument.cpp
     Source/Document/ShaderManagementConsoleDocument.h
+    Source/Document/ShaderManagementConsoleDocumentModule.cpp
+    Source/Document/ShaderManagementConsoleDocumentSystemComponent.cpp
+    Source/Document/ShaderManagementConsoleDocumentSystemComponent.h
 )

Gems/Atom/Tools/ShaderManagementConsole/Scripts/GenerateShaderVariantListForMaterials.py

@@ -153,7 +153,7 @@ def main():
     azlmbr.shader.SaveShaderVariantListSourceData(shaderVariantListFilePath, shaderVariantList)
     
     # Open the document in shader management console
-    result = azlmbr.shadermanagementconsole.ShaderManagementConsoleDocumentSystemRequestBus(
+    result = azlmbr.atomtools.AtomToolsDocumentSystemRequestBus(
         azlmbr.bus.Broadcast,
         'OpenDocument',
         shaderVariantListFilePath