EditorApp.moc.h

#pragma once
 
#include <EditorEngineProcessFramework/LongOps/LongOpControllerManager.h>
#include <EditorFramework/EditorApp/Configuration/Plugins.h>
#include <EditorFramework/EditorFrameworkDLL.h>
#include <EditorFramework/IPC/EngineProcessConnection.h>
#include <Foundation/Application/Config/FileSystemConfig.h>
#include <Foundation/Application/Config/PluginConfig.h>
#include <Foundation/Communication/Event.h>
#include <Foundation/Configuration/Singleton.h>
#include <Foundation/Containers/Set.h>
#include <Foundation/Logging/HTMLWriter.h>
#include <Foundation/Strings/String.h>
#include <Foundation/Types/Bitflags.h>
#include <Foundation/Types/UniquePtr.h>
#include <GuiFoundation/ContainerWindow/ContainerWindow.moc.h>
#include <QApplication>
#include <ToolsFoundation/Project/ToolsProject.h>
#include <ToolsFoundation/Utilities/RecentFilesList.h>
 
class QMainWindow;
class QWidget;
class plProgress;
class plQtProgressbar;
class plQtEditorApp;
template <typename T>
class QList;
using QStringList = QList<QString>;
class plTranslatorFromFiles;
class plDynamicStringEnum;
class QSplashScreen;
class plQtVersionChecker;
 
struct PL_EDITORFRAMEWORK_DLL plEditorAppEvent
{
  enum class Type
  {
    BeforeApplyDataDirectories, 
    ReloadResources,            
    EditorStarted,              
  };
 
  Type m_Type;
};
 
class PL_EDITORFRAMEWORK_DLL plQtEditorApp : public QObject
{
  Q_OBJECT
 
  PL_DECLARE_SINGLETON(plQtEditorApp);
 
public:
  struct StartupFlags
  {
    using StorageType = plUInt8;
    enum Enum
    {
      Headless = PL_BIT(0),   
      SafeMode = PL_BIT(1),   
      NoRecent = PL_BIT(2),   
      UnitTest = PL_BIT(3),   
      Background = PL_BIT(4), 
      Default = 0,
    };
 
    struct Bits
    {
      StorageType Headless : 1;
      StorageType SafeMode : 1;
      StorageType NoRecent : 1;
      StorageType UnitTest : 1;
      StorageType Background : 1;
    };
  };
 
public:
  plQtEditorApp();
  ~plQtEditorApp();
 
  static plEvent<const plEditorAppEvent&> m_Events;
 
  //
  // External Tools
  //
 
  plString FindToolApplication(const char* szToolName);
 
  plStatus ExecuteTool(const char* szTool, const QStringList& arguments, plUInt32 uiSecondsTillTimeout, plLogInterface* pLogOutput = nullptr, plLogMsgType::Enum logLevel = plLogMsgType::WarningMsg, const char* szCWD = nullptr);
 
  plString BuildFileserveCommandLine() const;
 
  void RunFileserve();
 
  void RunInspector();
 
  //
  //
  //
 
  bool IsInSafeMode() const { return m_StartupFlags.IsSet(StartupFlags::SafeMode); }
 
  bool IsInHeadlessMode() const { return m_StartupFlags.IsSet(StartupFlags::Headless); }
 
  bool IsInUnitTestMode() const { return m_StartupFlags.IsSet(StartupFlags::UnitTest); }
 
  bool IsBackgroundMode() const { return m_StartupFlags.IsSet(StartupFlags::Background); }
 
  const plPluginBundleSet& GetPluginBundles() const { return m_PluginBundles; }
  plPluginBundleSet& GetPluginBundles() { return m_PluginBundles; }
 
  void AddRestartRequiredReason(const char* szReason);
  const plSet<plString>& GetRestartRequiredReasons() { return m_RestartRequiredReasons; }
 
  void AddReloadProjectRequiredReason(const char* szReason);
  const plSet<plString>& GetReloadProjectRequiredReason() { return m_ReloadProjectRequiredReasons; }
 
  void SaveSettings();
 
  void SaveOpenDocumentsList();
 
  plRecentFilesList LoadOpenDocumentsList();
 
  void InitQt(int iArgc, char** pArgv);
  void StartupEditor();
  void StartupEditor(plBitflags<StartupFlags> startupFlags, const char* szUserDataFolder = nullptr);
  void ShutdownEditor();
  plInt32 RunEditor();
  void DeInitQt();
 
  void LoadEditorPlugins();
 
  plRecentFilesList& GetRecentProjectsList() { return m_RecentProjects; }
  plRecentFilesList& GetRecentDocumentsList() { return m_RecentDocuments; }
 
  plEditorEngineProcessConnection* GetEngineViewProcess() { return m_pEngineViewProcess; }
 
  void ShowSettingsDocument();
  void CloseSettingsDocument();
 
  void CloseProject();
  plResult OpenProject(const char* szProject, bool bImmediate = false);
 
  void GuiCreateDocument();
  void GuiOpenDocument();
 
  void GuiOpenDashboard();
  void GuiOpenDocsAndCommunity();
  bool GuiCreateProject(bool bImmediate = false);
  bool GuiOpenProject(bool bImmediate = false);
 
  void OpenDocumentQueued(plStringView sDocument, const plDocumentObject* pOpenContext = nullptr);
  plDocument* OpenDocument(plStringView sDocument, plBitflags<plDocumentFlags> flags, const plDocumentObject* pOpenContext = nullptr);
  plDocument* CreateDocument(plStringView sDocument, plBitflags<plDocumentFlags> flags, const plDocumentObject* pOpenContext = nullptr);
 
  plResult CreateOrOpenProject(bool bCreate, plStringView sFile);
 
  plStatus MakeRemoteProjectLocal(plStringBuilder& inout_sFilePath);
 
  bool ExistsPluginSelectionStateDDL(const char* szProjectDir = ":project");
  void WritePluginSelectionStateDDL(const char* szProjectDir = ":project");
  void CreatePluginSelectionDDL(const char* szProjectFile, const char* szTemplate);
  void LoadPluginBundleDlls(const char* szProjectFile);
  void DetectAvailablePluginBundles(plStringView sSearchDirectory);
 
  void LaunchEditor(const char* szProject, bool bCreate);
 
  void AddPluginDataDirDependency(const char* szSdkRootRelativePath, const char* szRootName = nullptr, bool bWriteable = false);
 
  const plApplicationFileSystemConfig& GetFileSystemConfig() const { return m_FileSystemConfig; }
  const plApplicationPluginConfig GetRuntimePluginConfig(bool bIncludeEditorPlugins) const;
 
  void SetFileSystemConfig(const plApplicationFileSystemConfig& cfg);
 
  bool MakeDataDirectoryRelativePathAbsolute(plStringBuilder& ref_sPath) const;
  bool MakeDataDirectoryRelativePathAbsolute(plString& ref_sPath) const;
  bool MakePathDataDirectoryRelative(plStringBuilder& ref_sPath) const;
  bool MakePathDataDirectoryRelative(plString& ref_sPath) const;
 
  bool MakePathDataDirectoryParentRelative(plStringBuilder& ref_sPath) const;
  bool MakeParentDataDirectoryRelativePathAbsolute(plStringBuilder& ref_sPath, bool bCheckExists) const;
 
  plStatus SaveTagRegistry();
 
  void GetKnownInputSlots(plDynamicArray<plString>& slots) const;
 
  void ReloadEngineResources();
 
  void RestartEngineProcessIfPluginsChanged(bool bForce);
  void SetStyleSheet();
 
Q_SIGNALS:
  void IdleEvent();
 
private:
  plString BuildDocumentTypeFileFilter(bool bForCreation);
 
  void GuiCreateOrOpenDocument(bool bCreate);
  bool GuiCreateOrOpenProject(bool bCreate);
 
private Q_SLOTS:
  void SlotTimedUpdate();
  void SlotQueuedCloseProject();
  void SlotQueuedOpenProject(QString sProject);
  void SlotQueuedOpenDocument(QString sProject, void* pOpenContext);
  void SlotQueuedGuiOpenDashboard();
  void SlotQueuedGuiOpenDocsAndCommunity();
  void SlotQueuedGuiCreateOrOpenProject(bool bCreate);
  void SlotSaveSettings();
  void SlotVersionCheckCompleted(bool bNewVersionReleased, bool bForced);
 
private:
  void UpdateGlobalStatusBarMessage();
 
  void DocumentManagerRequestHandler(plDocumentManager::Request& r);
  void DocumentManagerEventHandler(const plDocumentManager::Event& r);
  void DocumentEventHandler(const plDocumentEvent& e);
  void DocumentWindowEventHandler(const plQtDocumentWindowEvent& e);
  void ProjectRequestHandler(plToolsProjectRequest& r);
  void ProjectEventHandler(const plToolsProjectEvent& r);
  void EngineProcessMsgHandler(const plEditorEngineProcessConnection::Event& e);
  void UiServicesEvents(const plQtUiServices::Event& e);
 
  void SetupNewProject();
  void LoadEditorPreferences();
  void LoadProjectPreferences();
  void StoreEnginePluginModificationTimes();
  bool CheckForEnginePluginModifications();
  void SaveAllOpenDocuments();
 
  void ReadTagRegistry();
 
  void SetupDataDirectories();
  void CreatePanels();
 
  void SetupAndShowSplashScreen();
  void CloseSplashScreen();
 
  plResult AddBundlesInOrder(plDynamicArray<plApplicationPluginConfig::PluginConfig>& order, const plPluginBundleSet& bundles, const plString& start, bool bEditor, bool bEditorEngine, bool bRuntime) const;
 
  bool m_bSavePreferencesAfterOpenProject;
  bool m_bLoadingProjectInProgress = false;
  bool m_bAnyProjectOpened = false;
  bool m_bWroteCrashIndicatorFile = false;
 
  plBitflags<StartupFlags> m_StartupFlags;
  plDynamicArray<plString> m_DocumentsToOpen;
 
  plSet<plString> m_RestartRequiredReasons;
  plSet<plString> m_ReloadProjectRequiredReasons;
 
  plPluginBundleSet m_PluginBundles;
 
  void SaveRecentFiles();
  void LoadRecentFiles();
 
  plRecentFilesList m_RecentProjects;
  plRecentFilesList m_RecentDocuments;
 
  int m_iArgc = 0;
  QApplication* m_pQtApplication = nullptr;
  plLongOpControllerManager m_LongOpControllerManager;
  plEditorEngineProcessConnection* m_pEngineViewProcess;
  QTimer* m_pTimer = nullptr;
 
  QSplashScreen* m_pSplashScreen = nullptr;
 
  plLogWriter::HTML m_LogHTML;
 
  plTime m_LastPluginModificationCheck;
  plApplicationFileSystemConfig m_FileSystemConfig;
 
  // *** Recent Paths ***
  plString m_sLastDocumentFolder;
  plString m_sLastProjectFolder;
 
  // *** Progress Bar ***
public:
  bool IsProgressBarProcessingEvents() const;
 
private:
  plProgress* m_pProgressbar = nullptr;
  plQtProgressbar* m_pQtProgressbar = nullptr;
 
  // *** Localization ***
  plTranslatorFromFiles* m_pTranslatorFromFiles = nullptr;
 
  // *** Dynamic Enum Strings ***
  plSet<plString> m_DynamicEnumStringsToClear;
  void OnDemandDynamicStringEnumLoad(plStringView sEnumName, plDynamicStringEnum& e);
 
  plUniquePtr<plQtVersionChecker> m_pVersionChecker;
};
 
PL_DECLARE_FLAGS_OPERATORS(plQtEditorApp::StartupFlags);