EditorSession.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editor/EditConstraint.h"
#include "editor/EditorCommandService.h"
#include "editor/EditorDocumentService.h"
#include "editor/EditorTool.h"
#include "editor/EditorTransactions.h"
 
#include <cstdint>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace eve::editor {
 
class AutosaveService;
class EditorTargetCoordinator;
 
class EVENGINE_API_ORCHESTRATION EditorSession {
public:
    EditorSession();
    ~EditorSession() noexcept;
 
    EditorSession(const EditorSession&)            = delete;
    EditorSession& operator=(const EditorSession&) = delete;
 
    bool addTool(IEditorTool* tool);
    bool removeTool(const std::string& id);
    void clearTools();
 
    int          getToolCount() const;
    IEditorTool* getTool(int index) const;
    IEditorTool* findTool(const std::string& id) const;
 
    bool         activateTool(const std::string& id);
    IEditorTool* activeTool() const { return activeTool_; }
    std::string  activeToolId() const;
 
    ToolResponse dispatchPointer(const EditorPointerEvent& event);
    ToolResponse dispatchKey(const EditorKeyEvent& event);
    void update(float dt);
    void drawOverlay(IEditorOverlay& overlay);
    void inspect(IEditorInspector& inspector);
    void cancelActiveTool();
 
    bool                 hasPointerCapture() const { return capturedPointerId_ >= 0; }
    int                  capturedPointerId() const { return capturedPointerId_; }
    EditorContext&       context() { return context_; }
    const EditorContext& context() const { return context_; }
    void bindTarget(IEditableTarget& target);
    void bindTarget(IEditableTarget* target);
    void clearTarget();
    IEditableTarget* target() const;
    const TargetId&         boundTargetId() const noexcept { return boundTargetId_; }
    EditorTransactions&     transactions() { return transactions_; }
    EditConstraintPipeline& constraints() { return constraints_; }
    bool execute(std::unique_ptr<IEditCommand> command);
    [[nodiscard]] Result<void> executeChecked(std::unique_ptr<IEditCommand> command);
 
    void bindCommandService(EditorCommandService& service) { commandService_ = &service; }
    void clearCommandService() { commandService_ = nullptr; }
    void setCommandService(EditorCommandService* service) { commandService_ = service; }
    EditorCommandService* commandService() const { return commandService_; }
    void setHostProfile(HostProfile profile) { hostProfile_ = std::move(profile); }
    const HostProfile& hostProfile() const { return hostProfile_; }
    void setSessionId(SessionId id) { sessionId_ = std::move(id); }
    const SessionId& sessionId() const { return sessionId_; }
    EditorContextSnapshot contextSnapshot() const;
    Result<EditorValue> executeCommand(const CommandId& id, const EditorValue& payload = {},
                                             CommandSource source = CommandSource::Api);
    Result<CommandPlan> planCommand(const CommandId& id, const EditorValue& payload = {},
                                          CommandSource           source           = CommandSource::Api,
                                          std::optional<Revision> expectedRevision = std::nullopt) const;
    Result<TransactionReceipt> executePlan(const CommandPlan& plan, const EditorValue& payload = {},
                                                 CommandSource source = CommandSource::Api);
    Result<TransactionReceipt> executeCommandReceipt(const CommandId& id, const EditorValue& payload = {},
                                                           CommandSource source = CommandSource::Api);
    std::vector<CommandDescriptor> availableCommands() const;
    Result<PlanId> retainPlan(const CommandId& id, const EditorValue& payload = {},
                                    CommandSource           source           = CommandSource::Api,
                                    std::optional<Revision> expectedRevision = std::nullopt);
    Result<TransactionReceipt> executeRetainedPlan(const PlanId& id, CommandSource source = CommandSource::Api);
    Result<void> cancelRetainedPlan(const PlanId& id);
    void clearRetainedPlans();
 
    void setDocumentServices(DocumentService* documents, AutosaveService* autosave = nullptr);
    void bindDocumentServices(DocumentService& documents, AutosaveService* autosave = nullptr);
    void clearDocumentServices();
    Result<DocumentSnapshot> bindDocument(const DocumentId& document);
    void unbindDocument();
    const DocumentId& activeDocument() const { return activeDocument_; }
    Result<DocumentSnapshot> editDocument(EditorValue             content,
                                                std::optional<Revision> expectedRevision = std::nullopt);
    Result<DocumentSnapshot> saveDocument();
    Result<StoredDocument> autosaveDocument();
    Result<DocumentSnapshot> pollDocumentChanges();
    void setAutosaveInterval(float seconds);
    void setExternalPollInterval(float seconds);
    Revision lastAutosavedRevision() const { return lastAutosavedRevision_; }
 
private:
    friend class EditorTargetCoordinator;
    void bindTrackedTarget(IEditableTarget& target, std::weak_ptr<void> lifetime, EditorTargetCoordinator& coordinator,
                           std::uint64_t generation);
    void invalidateTrackedTarget(EditorTargetCoordinator& coordinator, const TargetId& target,
                                 std::uint64_t generation);
    void coordinatorDestroyed(EditorTargetCoordinator& coordinator) noexcept;
    void releaseTargetBinding();
    void deactivateCurrent();
 
    std::vector<IEditorTool*> tools_;
    IEditorTool*              activeTool_        = nullptr;
    int                       capturedPointerId_ = -1;
    EditorContext             context_;
    IEditableTarget*          target_ = nullptr;
    std::weak_ptr<void>       targetLifetime_;
    bool                      targetLifetimeTracked_ = false;
    TargetId                  boundTargetId_;
    std::uint64_t             targetGeneration_           = 0;
    std::uint64_t             nextDirectTargetGeneration_ = 1;
    EditorTargetCoordinator*  targetCoordinator_          = nullptr;
    EditorTransactions        transactions_;
    EditConstraintPipeline    constraints_;
    EditorCommandService*     commandService_ = nullptr;
    HostProfile               hostProfile_    = HostProfile::developer();
    SessionId                 sessionId_;
    std::uint64_t             receiptSequence_ = 0;
    std::uint64_t             toolGeneration_  = 0;
    struct RetainedPlan {
        CommandPlan plan;
        EditorValue payload;
    };
    std::vector<RetainedPlan> retainedPlans_;
    DocumentService*          documentService_ = nullptr;
    AutosaveService*          autosaveService_ = nullptr;
    DocumentId                activeDocument_;
    float                     autosaveInterval_      = 30.f;
    float                     autosaveElapsed_       = 0.f;
    float                     externalPollInterval_  = 1.f;
    float                     externalPollElapsed_   = 0.f;
    Revision                  lastAutosavedRevision_ = 0;
};
 
}  // namespace eve::editor