holding pen for refactor

Signed-off-by: Guthrie Adams <guthadam@amazon.com>
2021-08-11 14:55:28 -05:00
parent 2564e8f8dc
commit f1e8d37b86
23 changed files with 569 additions and 343 deletions
@@ -28,6 +28,7 @@ namespace ShaderManagementConsole
    {
        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentDestroyed, m_id);
        ShaderManagementConsoleDocumentRequestBus::Handler::BusDisconnect();
+        Clear();
    }

    const AZ::Uuid& ShaderManagementConsoleDocument::GetId() const
@@ -71,19 +72,21 @@ namespace ShaderManagementConsole
        return m_shaderVariantListSourceData.m_shaderVariants[index];
    }

-    ShaderManagementConsoleDocumentResult ShaderManagementConsoleDocument::Open(AZStd::string_view loadPath)
+    bool ShaderManagementConsoleDocument::Open(AZStd::string_view loadPath)
    {
        Clear();

        m_absolutePath = loadPath;
        if (!AzFramework::StringFunc::Path::Normalize(m_absolutePath))
        {
-            return AZ::Failure(AZStd::string::format("Document path could not be normalized: '%s'.", m_absolutePath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Document path could not be normalized: '%s'.", m_absolutePath.c_str());
+            return false;
        }

        if (AzFramework::StringFunc::Path::IsRelative(m_absolutePath.c_str()))
        {
-            return AZ::Failure(AZStd::string::format("Document path must be absolute: '%s'.", m_absolutePath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Document path must be absolute: '%s'.", m_absolutePath.c_str());
+            return false;
        }

        if (AzFramework::StringFunc::Path::IsExtension(m_absolutePath.c_str(), AZ::RPI::ShaderVariantListSourceData::Extension))
@@ -91,7 +94,8 @@ namespace ShaderManagementConsole
            // Load the shader config data and create a shader config asset from it
            if (!AZ::RPI::JsonUtils::LoadObjectFromFile(m_absolutePath, m_shaderVariantListSourceData))
            {
-                return AZ::Failure(AZStd::string::format("Failed loading shader variant list data: '%s.'", m_absolutePath.c_str()));
+                AZ_Error("ShaderManagementConsoleDocument", false, "Failed loading shader variant list data: '%s.'", m_absolutePath.c_str());
+                return false;
            }
        }

@@ -103,13 +107,15 @@ namespace ShaderManagementConsole
            watchFolder);
        if (!result)
        {
-            return AZ::Failure(AZStd::string::format("Could not find source data: '%s'.", m_absolutePath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Could not find source data: '%s'.", m_absolutePath.c_str());
+            return false;
        }

        m_relativePath = m_shaderVariantListSourceData.m_shaderFilePath;
        if (!AzFramework::StringFunc::Path::Normalize(m_relativePath))
        {
-            return AZ::Failure(AZStd::string::format("Shader path could not be normalized: '%s'.", m_relativePath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Shader path could not be normalized: '%s'.", m_relativePath.c_str());
+            return false;
        }

        AZStd::string shaderPath = m_relativePath;
@@ -118,27 +124,32 @@ namespace ShaderManagementConsole
        m_shaderAsset = AZ::RPI::AssetUtils::LoadAssetByProductPath<AZ::RPI::ShaderAsset>(shaderPath.c_str());
        if (!m_shaderAsset)
        {
-            return AZ::Failure(AZStd::string::format("Could not load shader asset: %s.", shaderPath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Could not load shader asset: %s.", shaderPath.c_str());
+            return false;
        }

        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentOpened, m_id);

-        return AZ::Success(AZStd::string::format("Document loaded: '%s'", m_absolutePath.c_str()));
+        AZ_TracePrintf("ShaderManagementConsoleDocument", "Document loaded: '%s'", m_absolutePath.c_str());
+        return true;
    }

-    ShaderManagementConsoleDocumentResult ShaderManagementConsoleDocument::Save()
+    bool ShaderManagementConsoleDocument::Save()
    {
        if (!IsOpen())
        {
-            return AZ::Failure(AZStd::string::format("Document is not open to be saved: '%s'.", m_absolutePath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Document is not open to be saved: '%s'.", m_absolutePath.c_str());
+            return false;
        }

        if (!IsSavable())
        {
-            return AZ::Failure(AZStd::string::format("Document can not be saved: '%s'.", m_absolutePath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Document can not be saved: '%s'.", m_absolutePath.c_str());
+            return false;
        }

-        return AZ::Failure(AZStd::string::format("%s is not implemented!", __FUNCTION__));
+        AZ_Error("ShaderManagementConsoleDocument", false, "%s is not implemented!", __FUNCTION__);
+        return false;

        // Auto add or checkout saved file
        //AzToolsFramework::SourceControlCommandBus::Broadcast(&AzToolsFramework::SourceControlCommandBus::Events::RequestEdit,
@@ -147,28 +158,33 @@ namespace ShaderManagementConsole

        //ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentSaved, m_id);

-        //return AZ::Success(AZStd::string::format("Document saved: %s", m_absolutePath.data()));
+        //AZ_TracePrintf("ShaderManagementConsoleDocument", "Document saved: %s", m_absolutePath.data());
+        //return true;
    }

-    ShaderManagementConsoleDocumentResult ShaderManagementConsoleDocument::SaveAsCopy(AZStd::string_view savePath)
+    bool ShaderManagementConsoleDocument::SaveAsCopy(AZStd::string_view savePath)
    {
        if (!IsOpen())
        {
-            return AZ::Failure(AZStd::string::format("Document is not open to be saved: '%s'.", m_absolutePath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Document is not open to be saved: '%s'.", m_absolutePath.c_str());
+            return false;
        }

        if (!IsSavable())
        {
-            return AZ::Failure(AZStd::string::format("Document can not be saved: '%s'.", m_absolutePath.c_str()));
+            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))
        {
-            return AZ::Failure(AZStd::string::format("Document save path could not be normalized: '%s'.", normalizedSavePath.c_str()));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Document save path could not be normalized: '%s'.", normalizedSavePath.c_str());
+            return false;
        }

-        return AZ::Failure(AZStd::string::format("%s is not implemented!", __FUNCTION__));
+        AZ_Error("ShaderManagementConsoleDocument", false, "%s is not implemented!", __FUNCTION__);
+        return false;

        // Auto add or checkout saved file
        //AzToolsFramework::SourceControlCommandBus::Broadcast(&AzToolsFramework::SourceControlCommandBus::Events::RequestEdit,
@@ -177,19 +193,22 @@ namespace ShaderManagementConsole

        //ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentSaved, m_id);

-        //return AZ::Success(AZStd::string::format("Document saved: %s", normalizedSavePath.c_str()));
+        //AZ_TracePrintf("ShaderManagementConsoleDocument", "Document saved: %s", normalizedSavePath.c_str());
+        //return true;
    }

-    ShaderManagementConsoleDocumentResult ShaderManagementConsoleDocument::Close()
+    bool ShaderManagementConsoleDocument::Close()
    {
        if (!IsOpen())
        {
-            return AZ::Failure(AZStd::string("Document is not open"));
+            AZ_Error("ShaderManagementConsoleDocument", false, "Document is not open");
+            return false;
        }

        Clear();
        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentClosed, m_id);
-        return AZ::Success(AZStd::string("Document was closed"));
+        AZ_TracePrintf("ShaderManagementConsoleDocument", "Document was closed");
+        return true;
    }

    bool ShaderManagementConsoleDocument::IsOpen() const
@@ -269,5 +288,9 @@ namespace ShaderManagementConsole
    {
        m_absolutePath.clear();
        m_relativePath.clear();
+        m_shaderVariantListSourceData = {};
+        m_shaderAsset = {};
+        m_undoHistory = {};
+        m_undoHistoryIndex = {};
    }
 } // namespace ShaderManagementConsole
@@ -41,10 +41,10 @@ namespace ShaderManagementConsole
        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;
-        ShaderManagementConsoleDocumentResult Open(AZStd::string_view loadPath) override;
-        ShaderManagementConsoleDocumentResult Save() override;
-        ShaderManagementConsoleDocumentResult SaveAsCopy(AZStd::string_view savePath) override;
-        ShaderManagementConsoleDocumentResult Close() 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;
@@ -8,9 +8,11 @@

 #include <Document/ShaderManagementConsoleDocumentSystemComponent.h>

-#include <AzCore/Serialization/SerializeContext.h>
-#include <AzCore/Serialization/EditContext.h>
+#include <AtomToolsFramework/Debug/TraceRecorder.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>
@@ -67,6 +69,7 @@ namespace ShaderManagementConsole
                ->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)
@@ -152,9 +155,9 @@ namespace ShaderManagementConsole
        return m_documentMap.erase(documentId) != 0;
    }

-    AZ::Uuid ShaderManagementConsoleDocumentSystemComponent::OpenDocument(AZStd::string_view path)
+    AZ::Uuid ShaderManagementConsoleDocumentSystemComponent::OpenDocument(AZStd::string_view sourcePath)
    {
-        return OpenDocumentImpl(path, true);
+        return OpenDocumentImpl(sourcePath, true);
    }

    bool ShaderManagementConsoleDocumentSystemComponent::CloseDocument(const AZ::Uuid& documentId)
@@ -163,26 +166,46 @@ namespace ShaderManagementConsole
        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)
        {
-            if (QMessageBox::question(QApplication::activeWindow(), "document has unsaved changes", "Would you like to close anyway?",
-                QMessageBox::Yes | QMessageBox::No) == QMessageBox::No)
+            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;
+                }
+            }
        }

-        ShaderManagementConsoleDocumentResult closeResult = AZ::Success(AZStd::string("There is no active document"));
+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+        bool closeResult = true;
        ShaderManagementConsoleDocumentRequestBus::EventResult(closeResult, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Close);
        if (!closeResult)
        {
-            QMessageBox::critical(QApplication::activeWindow(), "Failed to close document",
-                QString::fromUtf8(closeResult.GetError().data(), (int)closeResult.GetError().size()));
+            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;
        }

@@ -205,60 +228,83 @@ namespace ShaderManagementConsole
        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 documentPath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(documentPath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
+        AZStd::string saveDocumentPath;
+        ShaderManagementConsoleDocumentRequestBus::EventResult(saveDocumentPath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);

-        const QFileInfo saveInfo(documentPath.c_str());
-        if (saveInfo.absoluteFilePath().isEmpty())
+        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("Unable to save document. File can not be overwritten."));
+            QMessageBox::critical(QApplication::activeWindow(), "Error", QString("Document could not be overwritten:\n%1").arg(saveDocumentPath.c_str()));
            return false;
        }

-        ShaderManagementConsoleDocumentResult result = AZ::Failure(AZStd::string("There is no active document"));
+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+        bool result = false;
        ShaderManagementConsoleDocumentRequestBus::EventResult(result, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Save);
        if (!result)
        {
-            QMessageBox::critical(QApplication::activeWindow(), "document not saved",
-                QString::fromUtf8(result.GetError().data(), (int)result.GetError().size()));
+            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;
        }

-        AZ_TracePrintf("ShaderManagementConsole", "%s\n", result.GetValue().c_str());
        return true;
    }

-    bool ShaderManagementConsoleDocumentSystemComponent::SaveDocumentAsCopy(const AZ::Uuid& documentId)
+    bool ShaderManagementConsoleDocumentSystemComponent::SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath)
    {
-        AZStd::string documentPath;
-        ShaderManagementConsoleDocumentRequestBus::EventResult(documentPath, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::GetAbsolutePath);
-
-        const QFileInfo& saveInfo = AtomToolsFramework::GetSaveFileInfo(documentPath.c_str());
-        if (saveInfo.absoluteFilePath().isEmpty())
+        AZStd::string saveDocumentPath = targetPath;
+        if (saveDocumentPath.empty() || !AzFramework::StringFunc::Path::Normalize(saveDocumentPath))
        {
            return false;
        }

-        AZStd::string saveDocumentPath = saveInfo.absoluteFilePath().toUtf8().constData();
-        AzFramework::StringFunc::Path::Normalize(saveDocumentPath);
+        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;
+        }

-        ShaderManagementConsoleDocumentResult result = AZ::Failure(AZStd::string("There is no active document"));
+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
+        bool result = false;
        ShaderManagementConsoleDocumentRequestBus::EventResult(result, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::SaveAsCopy, saveDocumentPath);
        if (!result)
        {
-            QMessageBox::critical(QApplication::activeWindow(), "document copy not saved",
-                QString::fromUtf8(result.GetError().data(), (int)result.GetError().size()));
+            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;
        }

-        AZ_TracePrintf("ShaderManagementConsole", "%s\n", result.GetValue().c_str());
        return true;
    }

@@ -276,13 +322,17 @@ namespace ShaderManagementConsole
        return result;
    }

-    AZ::Uuid ShaderManagementConsoleDocumentSystemComponent::OpenDocumentImpl(AZStd::string_view path, bool checkIfAlreadyOpen)
+    AZ::Uuid ShaderManagementConsoleDocumentSystemComponent::OpenDocumentImpl(AZStd::string_view sourcePath, bool checkIfAlreadyOpen)
    {
-        AZStd::string requestedPath = path;
-        if (requestedPath.empty() || !AzFramework::StringFunc::Path::Normalize(requestedPath))
+        AZStd::string requestedPath = sourcePath;
+        if (requestedPath.empty())
        {
-            QMessageBox::critical(QApplication::activeWindow(), "document path is invalid",
-                QString::fromUtf8(requestedPath.data(), (int)requestedPath.size()));
+            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();
        }

@@ -301,21 +351,27 @@ namespace ShaderManagementConsole
            }
        }

+        AtomToolsFramework::TraceRecorder traceRecorder(m_maxMessageBoxLineCount);
+
        AZ::Uuid documentId = AZ::Uuid::CreateNull();
        ShaderManagementConsoleDocumentSystemRequestBus::BroadcastResult(documentId, &ShaderManagementConsoleDocumentSystemRequestBus::Events::CreateDocument);
        if (documentId.IsNull())
        {
-            QMessageBox::critical(QApplication::activeWindow(), "Failed to create document",
-                QString::fromUtf8(requestedPath.data(), (int)requestedPath.size()));
+            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();
        }

-        ShaderManagementConsoleDocumentResult openResult = AZ::Failure(AZStd::string("Failed to open document"));
+        traceRecorder.GetDump().clear();
+
+        bool openResult = false;
        ShaderManagementConsoleDocumentRequestBus::EventResult(openResult, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Open, requestedPath);
        if (!openResult)
        {
-            QMessageBox::critical(QApplication::activeWindow(), "Failed to open document",
-                QString::fromUtf8(openResult.GetError().data(), (int)openResult.GetError().size()));
+            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();
        }
@@ -53,16 +53,18 @@ namespace ShaderManagementConsole
        // ShaderManagementConsoleDocumentSystemRequestBus::Handler overrides...
        AZ::Uuid CreateDocument() override;
        bool DestroyDocument(const AZ::Uuid& documentId) override;
-        AZ::Uuid OpenDocument(AZStd::string_view path) 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) override;
+        bool SaveDocumentAsCopy(const AZ::Uuid& documentId, AZStd::string_view targetPath) override;
        bool SaveAllDocuments() override;
        ////////////////////////////////////////////////////////////////////////

-        AZ::Uuid OpenDocumentImpl(AZStd::string_view path, bool checkIfAlreadyOpen);
+        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;
    };
 }
@@ -8,6 +8,8 @@
 
 #include <AzCore/Name/Name.h>
 #include <AzFramework/StringFunc/StringFunc.h>
+#include <AzQtComponents/Components/StyleManager.h>
+#include <AzQtComponents/Components/WindowDecorationWrapper.h>
 #include <AzToolsFramework/API/EditorPythonRunnerRequestsBus.h>
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
 #include <AzToolsFramework/PythonTerminal/ScriptTermDialog.h>
@@ -23,11 +25,8 @@ AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnin
 #include <QCloseEvent>
 #include <QFileDialog>
 #include <QHeaderView>
-#include <QPushButton>
 #include <QStandardItemModel>
 #include <QTableView>
-#include <QVBoxLayout>
-#include <QVariant>
 #include <QWindow>
 AZ_POP_DISABLE_WARNING

@@ -36,6 +35,14 @@ namespace ShaderManagementConsole
    ShaderManagementConsoleWindow::ShaderManagementConsoleWindow(QWidget* parent /* = 0 */)
        : AtomToolsFramework::AtomToolsMainWindow(parent)
    {
+        resize(1280, 1024);
+
+        // Among other things, we need the window wrapper to save the main window size, position, and state
+        auto mainWindowWrapper =
+            new AzQtComponents::WindowDecorationWrapper(AzQtComponents::WindowDecorationWrapper::OptionAutoTitleBarButtons);
+        mainWindowWrapper->setGuest(this);
+        mainWindowWrapper->enableSaveRestoreGeometry("O3DE", "ShaderManagementConsole", "mainWindowGeometry");
+
        setWindowTitle("Shader Management Console");

        setObjectName("ShaderManagementConsoleWindow");
@@ -47,16 +54,14 @@ namespace ShaderManagementConsole
        CreateMenu();
        CreateTabBar();

-        QVBoxLayout* vl = new QVBoxLayout(m_centralWidget);
-        vl->setMargin(0);
-        vl->setContentsMargins(0, 0, 0, 0);
-        vl->addWidget(m_tabWidget);
-        m_centralWidget->setLayout(vl);
-        setCentralWidget(m_centralWidget);
-
        AddDockWidget("Asset Browser", new ShaderManagementConsoleBrowserWidget, Qt::BottomDockWidgetArea, Qt::Vertical);
        AddDockWidget("Python Terminal", new AzToolsFramework::CScriptTermDialog, Qt::BottomDockWidgetArea, Qt::Horizontal);

+        SetDockWidgetVisible("Python Terminal", false);
+
+        // Restore geometry and show the window
+        mainWindowWrapper->showFromSettings();
+
        ShaderManagementConsoleDocumentNotificationBus::Handler::BusConnect();
        OnDocumentOpened(AZ::Uuid::CreateNull());
    }
@@ -103,8 +108,7 @@ namespace ShaderManagementConsole
            // Create a new tab for the document ID and assign it's label to the file name of the document.
            AddTabForDocumentId(documentId, filename, absolutePath, [this, documentId]{
                // The document tab contains a table view.
-                auto contentWidget = new QTableView(m_centralWidget);
-                contentWidget->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
+                auto contentWidget = new QTableView(centralWidget());
                contentWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
                contentWidget->setModel(CreateDocumentContent(documentId));
                return contentWidget;
@@ -142,11 +146,22 @@ namespace ShaderManagementConsole

        activateWindow();
        raise();
+
+        const QString documentPath = GetDocumentPath(documentId);
+        if (!documentPath.isEmpty())
+        {
+            const QString status = QString("Document closed: %1").arg(documentPath);
+            m_statusMessage->setText(QString("<font color=\"White\">%1</font>").arg(status));
+        }
    }

    void ShaderManagementConsoleWindow::OnDocumentClosed(const AZ::Uuid& documentId)
    {
        RemoveTabForDocumentId(documentId);
+
+        const QString documentPath = GetDocumentPath(documentId);
+        const QString status = QString("Document closed: %1").arg(documentPath);
+        m_statusMessage->setText(QString("<font color=\"White\">%1</font>").arg(status));
    }

    void ShaderManagementConsoleWindow::OnDocumentModified(const AZ::Uuid& documentId)
@@ -182,6 +197,10 @@ namespace ShaderManagementConsole
        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);
+        m_statusMessage->setText(QString("<font color=\"White\">%1</font>").arg(status));
    }

    void ShaderManagementConsoleWindow::CreateMenu()
@@ -206,8 +225,47 @@ namespace ShaderManagementConsole

        m_menuFile->addSeparator();

+        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);
+            if (!result)
+            {
+                const QString documentPath = GetDocumentPath(documentId);
+                const QString status = QString("Failed to save document: %1").arg(documentPath);
+                m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
+            }
+        }, QKeySequence::Save);
+
+        m_actionSaveAsCopy = m_menuFile->addAction("Save &As...", [this]() {
+            const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
+            const QString documentPath = GetDocumentPath(documentId);
+
+            bool result = false;
+            ShaderManagementConsoleDocumentSystemRequestBus::BroadcastResult(result, &ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveDocumentAsCopy,
+                documentId, AtomToolsFramework::GetSaveFileInfo(documentPath).absoluteFilePath().toUtf8().constData());
+            if (!result)
+            {
+                const QString status = QString("Failed to save document: %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);
+            if (!result)
+            {
+                const QString status = QString("Failed to save documents.");
+                m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
+            }
+        });
+
+        m_menuFile->addSeparator();
+
        m_actionClose = m_menuFile->addAction("&Close", [this]() {
-            CloseDocumentForTab(m_tabWidget->currentIndex());
+            const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
+            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument, documentId);
        }, QKeySequence::Close);

        m_actionCloseAll = m_menuFile->addAction("Close All", [this]() {
@@ -215,23 +273,8 @@ namespace ShaderManagementConsole
        });

        m_actionCloseOthers = m_menuFile->addAction("Close Others", [this]() {
-            CloseAllExceptDocumentForTab(m_tabWidget->currentIndex());
-        });
-
-        m_menuFile->addSeparator();
-
-        m_actionSave = m_menuFile->addAction("&Save", [this]() {
            const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveDocument, documentId);
-        }, QKeySequence::Save);
-
-        m_actionSaveAsCopy = m_menuFile->addAction("Save &As...", [this]() {
-            const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveDocumentAsCopy, documentId);
-        }, QKeySequence::SaveAs);
-
-        m_actionSaveAll = m_menuFile->addAction("Save A&ll", [this]() {
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::SaveAllDocuments);
+            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
        });

        m_menuFile->addSeparator();
@@ -254,37 +297,46 @@ namespace ShaderManagementConsole

        m_actionUndo = m_menuEdit->addAction("&Undo", [this]() {
            const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
-            ShaderManagementConsoleDocumentRequestBus::Event(documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Undo);
+            bool result = false;
+            ShaderManagementConsoleDocumentRequestBus::EventResult(result, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Undo);
+            if (!result)
+            {
+                const QString documentPath = GetDocumentPath(documentId);
+                const QString status = QString("Failed to perform Undo on document: %1").arg(documentPath);
+                m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
+            }
        }, QKeySequence::Undo);

        m_actionRedo = m_menuEdit->addAction("&Redo", [this]() {
            const AZ::Uuid documentId = GetDocumentIdFromTab(m_tabWidget->currentIndex());
-            ShaderManagementConsoleDocumentRequestBus::Event(documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Redo);
+            bool result = false;
+            ShaderManagementConsoleDocumentRequestBus::EventResult(result, documentId, &ShaderManagementConsoleDocumentRequestBus::Events::Redo);
+            if (!result)
+            {
+                const QString documentPath = GetDocumentPath(documentId);
+                const QString status = QString("Failed to perform Redo on document: %1").arg(documentPath);
+                m_statusMessage->setText(QString("<font color=\"Red\">%1</font>").arg(status));
+            }
        }, QKeySequence::Redo);

        m_menuEdit->addSeparator();

-        m_actionSettings = m_menuEdit->addAction("&Preferences...", [this]() {
+        m_actionSettings = m_menuEdit->addAction("&Settings...", [this]() {
        }, QKeySequence::Preferences);
        m_actionSettings->setEnabled(false);

        m_menuView = m_menuBar->addMenu("&View");

-        m_actionAssetBrowser = m_menuView->addAction(
-            "&Asset Browser",
-            [this]()
-            {
-                const AZStd::string label = "Asset Browser";
-                SetDockWidgetVisible(label, !IsDockWidgetVisible(label));
-            });
+        m_actionAssetBrowser = m_menuView->addAction("&Asset Browser", [this]() {
+            const AZStd::string label = "Asset Browser";
+            SetDockWidgetVisible(label, !IsDockWidgetVisible(label));
+        });
+
+        m_actionPythonTerminal = m_menuView->addAction("Python &Terminal", [this]() {
+            const AZStd::string label = "Python Terminal";
+            SetDockWidgetVisible(label, !IsDockWidgetVisible(label));
+        });

-        m_actionPythonTerminal = m_menuView->addAction(
-            "Python &Terminal",
-            [this]()
-            {
-                const AZStd::string label = "Python Terminal";
-                SetDockWidgetVisible(label, !IsDockWidgetVisible(label));
-            });

        m_menuView->addSeparator();

@@ -313,14 +365,23 @@ namespace ShaderManagementConsole
        // When the last tab is removed tabIndex will be -1 and the document ID will be null
        // This should automatically clear the active document
        connect(m_tabWidget, &QTabWidget::currentChanged, this, [this](int tabIndex) {
-            SelectDocumentForTab(tabIndex);
+            const AZ::Uuid documentId = GetDocumentIdFromTab(tabIndex);
+            ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentOpened, documentId);
        });

        connect(m_tabWidget, &QTabWidget::tabCloseRequested, this, [this](int tabIndex) {
-            CloseDocumentForTab(tabIndex);
+            const AZ::Uuid documentId = GetDocumentIdFromTab(tabIndex);
+            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument, documentId);
        });
    }

+    QString ShaderManagementConsoleWindow::GetDocumentPath(const AZ::Uuid& documentId) const
+    {
+        AZStd::string absolutePath;
+        ShaderManagementConsoleDocumentRequestBus::EventResult(absolutePath, documentId, &ShaderManagementConsoleDocumentRequestBus::Handler::GetAbsolutePath);
+        return absolutePath.c_str();
+    }
+
    void ShaderManagementConsoleWindow::OpenTabContextMenu()
    {
        const QTabBar* tabBar = m_tabWidget->tabBar();
@@ -332,51 +393,22 @@ namespace ShaderManagementConsole
            QMenu tabMenu;
            const QString selectActionName = (currentTabIndex == clickedTabIndex) ? "Select in Browser" : "Select";
            tabMenu.addAction(selectActionName, [this, clickedTabIndex]() {
-                SelectDocumentForTab(clickedTabIndex);
+                const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
+                ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentOpened, documentId);
            });
            tabMenu.addAction("Close", [this, clickedTabIndex]() {
-                CloseDocumentForTab(clickedTabIndex);
+                const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
+                ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument, documentId);
            });
            auto closeOthersAction = tabMenu.addAction("Close Others", [this, clickedTabIndex]() {
-                CloseAllExceptDocumentForTab(clickedTabIndex);
+                const AZ::Uuid documentId = GetDocumentIdFromTab(clickedTabIndex);
+                ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseAllDocumentsExcept, documentId);
            });
            closeOthersAction->setEnabled(tabBar->count() > 1);
            tabMenu.exec(QCursor::pos());
        }
    }

-    void ShaderManagementConsoleWindow::SelectDocumentForTab(const int tabIndex)
-    {
-        const AZ::Uuid documentId = GetDocumentIdFromTab(tabIndex);
-        ShaderManagementConsoleDocumentNotificationBus::Broadcast(&ShaderManagementConsoleDocumentNotificationBus::Events::OnDocumentOpened, documentId);
-    }
-
-    void ShaderManagementConsoleWindow::CloseDocumentForTab(const int tabIndex)
-    {
-        const AZ::Uuid documentId = GetDocumentIdFromTab(tabIndex);
-        ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument, documentId);
-    }
-
-    void ShaderManagementConsoleWindow::CloseAllExceptDocumentForTab(const int tabIndex)
-    {
-        AZStd::vector<AZ::Uuid> documentIdsToClose;
-        documentIdsToClose.reserve(m_tabWidget->count());
-        const AZ::Uuid documentIdToKeepOpen = GetDocumentIdFromTab(tabIndex);
-        for (int tabI = 0; tabI < m_tabWidget->count(); ++tabI)
-        {
-            const AZ::Uuid documentId = GetDocumentIdFromTab(tabI);
-            if (documentId != documentIdToKeepOpen)
-            {
-                documentIdsToClose.push_back(documentId);
-            }
-        }
-
-        for (const AZ::Uuid& documentId : documentIdsToClose)
-        {
-            ShaderManagementConsoleDocumentSystemRequestBus::Broadcast(&ShaderManagementConsoleDocumentSystemRequestBus::Events::CloseDocument, documentId);
-        }
-    }
-
    QStandardItemModel* ShaderManagementConsoleWindow::CreateDocumentContent(const AZ::Uuid& documentId)
    {
        AZStd::unordered_set<AZStd::string> optionNames;
@@ -52,11 +52,10 @@ namespace ShaderManagementConsole

        void CreateMenu() override;
        void CreateTabBar() override;
-        void OpenTabContextMenu() override;

-        void SelectDocumentForTab(const int tabIndex);
-        void CloseDocumentForTab(const int tabIndex);
-        void CloseAllExceptDocumentForTab(const int tabIndex);
+        QString GetDocumentPath(const AZ::Uuid& documentId) const;
+
+        void OpenTabContextMenu() override;

        void closeEvent(QCloseEvent* closeEvent) override;

@@ -44,14 +44,6 @@ namespace ShaderManagementConsole

        if (AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context))
        {
-            behaviorContext->EBus<AtomToolsFramework::AtomToolsMainWindowFactoryRequestBus>("ShaderManagementConsoleWindowRequestBus")
-                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Automation)
-                ->Attribute(AZ::Script::Attributes::Category, "Editor")
-                ->Attribute(AZ::Script::Attributes::Module, "shadermanagementconsole")
-                ->Event("CreateShaderManagementConsoleWindow", &AtomToolsFramework::AtomToolsMainWindowFactoryRequestBus::Events::CreateMainWindow)
-                ->Event("DestroyShaderManagementConsoleWindow", &AtomToolsFramework::AtomToolsMainWindowFactoryRequestBus::Events::DestroyMainWindow)
-                ;
-
            behaviorContext->EBus<ShaderManagementConsoleRequestBus>("ShaderManagementConsoleRequestBus")
                ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Automation)
                ->Attribute(AZ::Script::Attributes::Category, "Editor")
@@ -65,19 +57,20 @@ namespace ShaderManagementConsole

    void ShaderManagementConsoleWindowComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
    {
-        required.push_back(AZ_CRC("AssetBrowserService", 0x1e54fffb));
-        required.push_back(AZ_CRC("PropertyManagerService", 0x63a3d7ad));
-        required.push_back(AZ_CRC("SourceControlService", 0x67f338fd));
+        required.push_back(AZ_CRC_CE("AssetBrowserService"));
+        required.push_back(AZ_CRC_CE("PropertyManagerService"));
+        required.push_back(AZ_CRC_CE("SourceControlService"));
+        required.push_back(AZ_CRC_CE("AtomToolsMainWindowSystemService"));
    }

    void ShaderManagementConsoleWindowComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
    {
-        provided.push_back(AZ_CRC("ShaderManagementConsoleWindowService", 0xb6e7d922));
+        provided.push_back(AZ_CRC_CE("ShaderManagementConsoleWindowService"));
    }

    void ShaderManagementConsoleWindowComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
    {
-        incompatible.push_back(AZ_CRC("ShaderManagementConsoleWindowService", 0xb6e7d922));
+        incompatible.push_back(AZ_CRC_CE("ShaderManagementConsoleWindowService"));
    }

    void ShaderManagementConsoleWindowComponent::Init()