Document.h

#pragma once
 
#include <Foundation/Communication/Event.h>
#include <Foundation/Logging/Log.h>
#include <Foundation/Strings/String.h>
#include <Foundation/Threading/Implementation/TaskSystemDeclarations.h>
#include <Foundation/Types/Status.h>
#include <Foundation/Types/UniquePtr.h>
#include <ToolsFoundation/CommandHistory/CommandHistory.h>
#include <ToolsFoundation/Document/Implementation/Declarations.h>
#include <ToolsFoundation/Object/ObjectMetaData.h>
#include <ToolsFoundation/Selection/SelectionManager.h>
#include <ToolsFoundation/ToolsFoundationDLL.h>
 
class plObjectAccessorBase;
class plObjectCommandAccessor;
class plEditorInputContext;
class plAbstractObjectNode;
 
struct PL_TOOLSFOUNDATION_DLL plObjectAccessorChangeEvent
{
  plDocument* m_pDocument;
  plObjectAccessorBase* m_pOldObjectAccessor;
  plObjectAccessorBase* m_pNewObjectAccessor;
};
 
class PL_TOOLSFOUNDATION_DLL plDocumentObjectMetaData : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plDocumentObjectMetaData, plReflectedClass);
 
public:
  enum ModifiedFlags : unsigned int
  {
    HiddenFlag = PL_BIT(0),
    PrefabFlag = PL_BIT(1),
 
    AllFlags = 0xFFFFFFFF
  };
 
  plDocumentObjectMetaData() { m_bHidden = false; }
 
  bool m_bHidden;            
  plUuid m_CreateFromPrefab; 
  plUuid m_PrefabSeedGuid;   
  plString m_sBasePrefab;    
};
 
enum class plManipulatorSearchStrategy
{
  None,
  SelectedObject,
  ChildrenOfSelectedObject
};
 
class PL_TOOLSFOUNDATION_DLL plDocument : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plDocument, plReflectedClass);
 
public:
  plDocument(plStringView sPath, plDocumentObjectManager* pDocumentObjectManagerImpl);
  virtual ~plDocument();
 
 
  bool IsModified() const { return m_bModified; }
  bool IsReadOnly() const { return m_bReadOnly; }
  const plUuid GetGuid() const { return m_pDocumentInfo ? m_pDocumentInfo->m_DocumentID : plUuid(); }
 
  const plDocumentObjectManager* GetObjectManager() const { return m_pObjectManager.Borrow(); }
  plDocumentObjectManager* GetObjectManager() { return m_pObjectManager.Borrow(); }
  plSelectionManager* GetSelectionManager() const { return m_pSelectionManager.Borrow(); }
  plCommandHistory* GetCommandHistory() const { return m_pCommandHistory.Borrow(); }
  virtual plObjectAccessorBase* GetObjectAccessor() const;
 
 
  bool IsMainDocument() const { return m_pHostDocument == this; }
  bool IsSubDocument() const { return m_pHostDocument != this; }
  const plDocument* GetMainDocument() const { return m_pHostDocument; }
  const plDocument* GetActiveSubDocument() const { return m_pActiveSubDocument; }
  plDocument* GetMainDocument() { return m_pHostDocument; }
  plDocument* GetActiveSubDocument() { return m_pActiveSubDocument; }
 
protected:
  plDocument* m_pHostDocument = nullptr;
  plDocument* m_pActiveSubDocument = nullptr;
 
 
public:
  plStringView GetDocumentPath() const { return m_sDocumentPath; }
 
  plStatus SaveDocument(bool bForce = false);
  using AfterSaveCallback = plDelegate<void(plDocument*, plStatus)>;
  plTaskGroupID SaveDocumentAsync(AfterSaveCallback callback, bool bForce = false);
  void DocumentRenamed(plStringView sNewDocumentPath);
 
  static plStatus ReadDocument(plStringView sDocumentPath, plUniquePtr<plAbstractObjectGraph>& ref_pHeader, plUniquePtr<plAbstractObjectGraph>& ref_pObjects,
    plUniquePtr<plAbstractObjectGraph>& ref_pTypes);
  static plStatus ReadAndRegisterTypes(const plAbstractObjectGraph& types);
 
  plStatus LoadDocument() { return InternalLoadDocument(); }
 
  void EnsureVisible();
 
  plDocumentManager* GetDocumentManager() const { return m_pDocumentManager; }
 
  bool HasWindowBeenRequested() const { return m_bWindowRequested; }
 
  const plDocumentTypeDescriptor* GetDocumentTypeDescriptor() const { return m_pTypeDescriptor; }
 
  plStringView GetDocumentTypeName() const
  {
    if (m_pTypeDescriptor == nullptr)
    {
      // if this is a document without a type descriptor, use the RTTI type name as a fallback
      return GetDynamicRTTI()->GetTypeName();
    }
 
    return m_pTypeDescriptor->m_sDocumentTypeName;
  }
 
  const plDocumentInfo* GetDocumentInfo() const { return m_pDocumentInfo; }
 
  virtual bool CanEngineProcessBeRestarted() const { return true; }
 
 
  struct PasteInfo
  {
    PL_DECLARE_POD_TYPE();
 
    plDocumentObject* m_pObject = nullptr;
    plDocumentObject* m_pParent = nullptr;
    plInt32 m_Index = -1;
  };
 
  virtual void GetSupportedMimeTypesForPasting(plHybridArray<plString, 4>& out_mimeTypes) const {}
  virtual bool CopySelectedObjects(plAbstractObjectGraph& out_objectGraph, plStringBuilder& out_sMimeType) const { return false; };
  virtual bool Paste(const plArrayPtr<PasteInfo>& info, const plAbstractObjectGraph& objectGraph, bool bAllowPickedPosition, plStringView sMimeType)
  {
    return false;
  };
 
 
  void BroadcastInterDocumentMessage(plReflectedClass* pMessage, plDocument* pSender);
 
  virtual void OnInterDocumentMessage(plReflectedClass* pMessage, plDocument* pSender) {}
 
 
  virtual plEditorInputContext* GetEditorInputContextOverride() { return nullptr; }
 
 
  virtual void DeleteSelectedObjects() const;
 
  const plSet<plString>& GetUnknownObjectTypes() const { return m_UnknownObjectTypes; }
  plUInt32 GetUnknownObjectTypeInstances() const { return m_uiUnknownObjectTypeInstances; }
 
  void SetAddToResetFilesList(bool b) { m_bAddToRecentFilesList = b; }
 
  bool GetAddToRecentFilesList() const { return m_bAddToRecentFilesList; }
 
  void ShowDocumentStatus(const plFormatString& msg) const;
 
  virtual plResult ComputeObjectTransformation(const plDocumentObject* pObject, plTransform& out_result) const;
 
  virtual plManipulatorSearchStrategy GetManipulatorSearchStrategy() const { return plManipulatorSearchStrategy::None; }
 
 
  virtual bool ArePrefabsAllowed() const { return true; }
 
  virtual void UpdatePrefabs();
 
  void RevertPrefabs(const plDeque<const plDocumentObject*>& selection);
 
  virtual void UnlinkPrefabs(const plDeque<const plDocumentObject*>& selection);
 
  virtual plStatus CreatePrefabDocumentFromSelection(plStringView sFile, const plRTTI* pRootType, plDelegate<void(plAbstractObjectNode*)> adjustGraphNodeCB = {}, plDelegate<void(plDocumentObject*)> adjustNewNodesCB = {}, plDelegate<void(plAbstractObjectGraph& graph, plDynamicArray<plAbstractObjectNode*>& graphRootNodes)> finalizeGraphCB = {});
  virtual plStatus CreatePrefabDocument(plStringView sFile, plArrayPtr<const plDocumentObject*> rootObjects, const plUuid& invPrefabSeed, plUuid& out_newDocumentGuid, plDelegate<void(plAbstractObjectNode*)> adjustGraphNodeCB = {}, bool bKeepOpen = false, plDelegate<void(plAbstractObjectGraph& graph, plDynamicArray<plAbstractObjectNode*>& graphRootNodes)> finalizeGraphCB = {});
 
  // Returns new guid of replaced object.
  virtual plUuid ReplaceByPrefab(const plDocumentObject* pRootObject, plStringView sPrefabFile, const plUuid& prefabAsset, const plUuid& prefabSeed, bool bEnginePrefab);
  // Returns new guid of reverted object.
  virtual plUuid RevertPrefab(const plDocumentObject* pObject);
 
 
public:
  plUniquePtr<plObjectMetaData<plUuid, plDocumentObjectMetaData>> m_DocumentObjectMetaData;
 
  mutable plEvent<const plDocumentEvent&> m_EventsOne;
  static plEvent<const plDocumentEvent&> s_EventsAny;
 
  mutable plEvent<const plObjectAccessorChangeEvent&> m_ObjectAccessorChangeEvents;
 
protected:
  void SetModified(bool b);
  void SetReadOnly(bool b);
  virtual plTaskGroupID InternalSaveDocument(AfterSaveCallback callback);
  virtual plStatus InternalLoadDocument();
  virtual plDocumentInfo* CreateDocumentInfo() = 0;
 
  virtual void InternalAfterSaveDocument() {}
 
  virtual void AttachMetaDataBeforeSaving(plAbstractObjectGraph& graph) const;
  virtual void RestoreMetaDataAfterLoading(const plAbstractObjectGraph& graph, bool bUndoable);
 
  virtual void InitializeAfterLoading(bool bFirstTimeCreation) {}
  virtual void InitializeAfterLoadingAndSaving() {}
 
  virtual void BeforeClosing();
 
  void SetUnknownObjectTypes(const plSet<plString>& Types, plUInt32 uiInstances);
 
 
  virtual void UpdatePrefabsRecursive(plDocumentObject* pObject);
  virtual void UpdatePrefabObject(plDocumentObject* pObject, const plUuid& PrefabAsset, const plUuid& PrefabSeed, plStringView sBasePrefab);
 
 
  plUniquePtr<plDocumentObjectManager> m_pObjectManager;
  mutable plUniquePtr<plCommandHistory> m_pCommandHistory;
  mutable plUniquePtr<plSelectionManager> m_pSelectionManager;
  mutable plUniquePtr<plObjectCommandAccessor> m_pObjectAccessor; 
 
  plDocumentInfo* m_pDocumentInfo = nullptr;
  const plDocumentTypeDescriptor* m_pTypeDescriptor = nullptr;
 
private:
  friend class plDocumentManager;
  friend class plCommandHistory;
  friend class plSaveDocumentTask;
  friend class plAfterSaveDocumentTask;
 
  void SetupDocumentInfo(const plDocumentTypeDescriptor* pTypeDescriptor);
 
  plDocumentManager* m_pDocumentManager = nullptr;
 
  plString m_sDocumentPath;
  bool m_bModified;
  bool m_bReadOnly;
  bool m_bWindowRequested;
  bool m_bAddToRecentFilesList;
 
  plSet<plString> m_UnknownObjectTypes;
  plUInt32 m_uiUnknownObjectTypeInstances;
 
  plTaskGroupID m_ActiveSaveTask;
  plStatus m_LastSaveResult;
};