UiDocument.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditableTarget.h"
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
 
#include <map>
#include <string>
#include <vector>
 
namespace eve::ui {
class UIHost;
}
 
namespace eve::ui_editing {
 
using editing::CapabilityId;
using editing::DiagnosticSeverity;
using editing::DomainOperation;
using editing::EditRegion;
using editing::IDomainOperationTarget;
using editing::IDomainOperationTargetStaging;
using editing::IEditableTarget;
using editing::IPropertyProvider;
using editing::ObjectId;
using editing::PropertyDescriptor;
using editing::PropertyFlag;
using editing::PropertyPath;
using editing::PropertyReadResult;
using editing::PropertyReadState;
using editing::PropertySchema;
using editing::PropertySetMode;
using editing::PropertyType;
using editing::Revision;
using editing::RuleId;
using editing::SelectionItem;
using editing::SelectionSnapshot;
using editing::TargetDescriptor;
using editing::TargetId;
using editing::Result;
using EditorStatus     = editing::Status;
using EditorValue      = editing::Value;
using EditorDiagnostic = editing::Diagnostic;
 
struct UiLayoutValue {
    double x       = 0.0;
    double y       = 0.0;
    double width   = 0.0;
    double height  = 0.0;
    double anchorX = 0.0;
    double anchorY = 0.0;
    double pivotX  = 0.0;
    double pivotY  = 0.0;
 
    auto operator<=>(const UiLayoutValue&) const = default;
};
 
struct UiStyleValue {
    double      marginLeft = 0.0, marginTop = 0.0, marginRight = 0.0, marginBottom = 0.0;
    double      paddingLeft = 0.0, paddingTop = 0.0, paddingRight = 0.0, paddingBottom = 0.0;
    double      tintR = 1.0, tintG = 1.0, tintB = 1.0, tintA = 1.0;
    double      cornerRadius = 0.0;
    double      gap          = 0.0;
    double      flexGrow     = 0.0;
    std::string direction    = "row";
    std::string align        = "start";
    std::string justify      = "start";
 
    auto operator<=>(const UiStyleValue&) const = default;
};
 
struct UiContentValue {
    std::string fontAsset;
    double      fontSize = 16.0;
    double      textR = 1.0, textG = 1.0, textB = 1.0, textA = 1.0;
    std::string horizontalAlign = "start";
    std::string verticalAlign   = "start";
    std::string textureAsset;
    std::string imageFit = "stretch";
    bool        clip     = true;
 
    auto operator<=>(const UiContentValue&) const = default;
};
 
struct UiWidgetSnapshot {
    ObjectId       id;
    ObjectId       parent;
    std::string    type;
    std::string    name;
    std::string    text;
    bool           visible = true;
    bool           enabled = true;
    UiLayoutValue  layout;
    UiStyleValue   style;
    UiContentValue content;
};
 
struct CreateUiWidgetRequest {
    ObjectId      id;
    ObjectId      parent;
    std::string   type;
    std::string   name;
    UiLayoutValue layout;
};
 
class IUiDocumentEditTarget {
public:
    virtual ~IUiDocumentEditTarget() = default;
    static CapabilityId editorCapabilityId() { return CapabilityId("eve.editor.target.ui-document"); }
    virtual Result<UiWidgetSnapshot> widget(const ObjectId& id) const                                     = 0;
    virtual std::vector<ObjectId>          children(const ObjectId& parent) const                               = 0;
    virtual Result<DomainOperation>  makeCreate(const CreateUiWidgetRequest& request) const               = 0;
    virtual Result<DomainOperation>  makeDelete(const ObjectId& id) const                                 = 0;
    virtual Result<DomainOperation>  makeRename(const ObjectId& id, const std::string& name) const        = 0;
    virtual Result<DomainOperation>  makeReparent(const ObjectId& id, const ObjectId& parent) const       = 0;
    virtual Result<DomainOperation>  makeSetLayout(const ObjectId& id, const UiLayoutValue& layout) const = 0;
    virtual Result<DomainOperation> makeSetStyle(const ObjectId& id, const UiStyleValue& style) const = 0;
    virtual Result<DomainOperation> makeSetContent(const ObjectId& id, const UiContentValue& content) const = 0;
};
 
class EVENGINE_API_DOMAINS UiDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                    public virtual IEditableTarget,
                                                    public IDomainOperationTarget,
                                                    public IDomainOperationTargetStaging,
                                                    public IUiDocumentEditTarget,
                                                    public IPropertyProvider {
public:
    explicit UiDocumentTarget(std::string id);
 
    TargetId         targetId() const override { return TargetId(id_); }
    TargetDescriptor describe() const override;
    void*              queryCapability(const CapabilityId& capability) override;
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    Result<void> commitDomainState(std::unique_ptr<IDomainOperationTarget> candidate) override;
 
    Result<UiWidgetSnapshot> widget(const ObjectId& id) const override;
    std::vector<ObjectId>          children(const ObjectId& parent) const override;
    Result<DomainOperation>  makeCreate(const CreateUiWidgetRequest& request) const override;
    Result<DomainOperation>  makeDelete(const ObjectId& id) const override;
    Result<DomainOperation>  makeRename(const ObjectId& id, const std::string& name) const override;
    Result<DomainOperation>  makeReparent(const ObjectId& id, const ObjectId& parent) const override;
    Result<DomainOperation>  makeSetLayout(const ObjectId& id, const UiLayoutValue& layout) const override;
    Result<DomainOperation>  makeSetStyle(const ObjectId& id, const UiStyleValue& style) const override;
    Result<DomainOperation>  makeSetContent(const ObjectId& id, const UiContentValue& content) const override;
 
    std::vector<EditorDiagnostic> validate() const;
 
    eve::Result<eve::Revision>    currentRevision(const SelectionSnapshot& selection) const override;
    PropertySchema                schema(const SelectionSnapshot& selection) const override;
    PropertyReadResult            read(const SelectionSnapshot& selection, const PropertyPath& path) const override;
    Result<DomainOperation> makeSet(const SelectionSnapshot& selection, const PropertyPath& path,
                                          const EditorValue& value, PropertySetMode mode) const override;
    Result<DomainOperation> makeReset(const SelectionSnapshot& selection,
                                            const PropertyPath&      path) const override;
 
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    static EditorValue                    layoutValue(const UiLayoutValue& layout);
    static Result<UiLayoutValue>    parseLayout(const EditorValue& value);
    static EditorValue                    styleValue(const UiStyleValue& style);
    static Result<UiStyleValue>     parseStyle(const EditorValue& value);
    static EditorValue                    contentValue(const UiContentValue& content);
    static Result<UiContentValue>   parseContent(const EditorValue& value);
    static EditorValue                    widgetValue(const UiWidgetSnapshot& widget);
    static Result<UiWidgetSnapshot> parseWidget(const EditorValue& value);
    Result<DomainOperation>         makeReplace(const UiWidgetSnapshot& before, UiWidgetSnapshot after,
                                                      std::string property = {}) const;
    bool                                  wouldCycle(const ObjectId& id, const ObjectId& parent,
                                                     const std::map<ObjectId, UiWidgetSnapshot>& widgets) const;
 
    std::string                          id_;
    std::map<ObjectId, UiWidgetSnapshot> widgets_;
};
 
struct UiPreviewWidget {
    ObjectId id;
    ObjectId parent;
    double   x = 0.0, y = 0.0, width = 0.0, height = 0.0;
    int      depth   = 0;
    bool     visible = true;
};
 
struct UiPreviewSnapshot {
    EditorStatus                  status           = EditorStatus::Failed;
    Revision                      documentRevision = 0;
    double                        viewportWidth = 0.0, viewportHeight = 0.0;
    std::vector<UiPreviewWidget>  widgets;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class EVENGINE_API_DOMAINS UiDocumentPreviewService {
public:
    UiPreviewSnapshot build(const UiDocumentTarget& document, double width, double height) const;
    Result<ObjectId> pick(const UiPreviewSnapshot& preview, double x, double y) const;
    Result<EditorValue> anchorGizmo(const UiDocumentTarget& document, const UiPreviewSnapshot& preview,
                                          const ObjectId& widget) const;
};
 
class UiDocumentRuntimeBridge {
public:
    Result<void> publish(const UiDocumentTarget& document, const ObjectId& root, ui::UIHost* host) const;
};
 
}  // namespace eve::ui_editing