UiTheme.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditableTarget.h"
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
#include "ui/Theme.h"
 
#include <string>
#include <vector>
 
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::IEditingSnapshotProvider;
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::SelectionSnapshot;
using editing::TargetDescriptor;
using editing::TargetId;
using editing::Result;
using EditorStatus     = editing::Status;
using EditorValue      = editing::Value;
using EditorDiagnostic = editing::Diagnostic;
 
enum class UiThemeBasePreset { Dark, Light, Custom };
 
struct UiThemeAsset {
    ObjectId           id;
    std::string        name;
    UiThemeBasePreset  basePreset = UiThemeBasePreset::Dark;
    ui::Theme          tokens;
};
 
class EVENGINE_API_DOMAINS UiThemeCatalogTarget final : public ::eve::editing::EditableTargetState,
                                                        public virtual IEditableTarget,
                                                        public IDomainOperationTarget,
                                                        public IDomainOperationTargetStaging,
                                                        public IPropertyProvider,
                                                        public IEditingSnapshotProvider {
public:
    explicit UiThemeCatalogTarget(std::string id);
 
    static CapabilityId propertyCapabilityId() { return CapabilityId("eve.editor.target.ui-theme-properties"); }
 
    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;
 
    const std::vector<UiThemeAsset>& themes() const noexcept { return themes_; }
    const ObjectId& activeId() const noexcept { return activeId_; }
 
    Result<UiThemeAsset> theme(const ObjectId& id) const;
    std::string runtimeName(const ObjectId& id) const;
 
    [[nodiscard]] Result<DomainOperation> makeCreateFromPreset(const ObjectId& id, std::string name,
                                                                     UiThemeBasePreset preset) const;
    [[nodiscard]] Result<DomainOperation> makeDuplicate(const ObjectId& source, const ObjectId& id,
                                                              std::string name) const;
    [[nodiscard]] Result<DomainOperation> makeRename(const ObjectId& id, std::string name) const;
    [[nodiscard]] Result<DomainOperation> makeDelete(const ObjectId& id) const;
    [[nodiscard]] Result<DomainOperation> makeSetActive(const ObjectId& id) const;
    [[nodiscard]] Result<DomainOperation> makeResetToBase(const ObjectId& id) 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 override;
    Result<void>     loadSnapshot(const EditorValue& snapshot);
    std::vector<EditorDiagnostic> validate() const;
 
private:
    Result<DomainOperation> replacement(EditorValue content, std::string property = {}) const;
    EditorValue                   contentValue() const;
    bool                          matches(const SelectionSnapshot& selection) const;
    UiThemeAsset* mutableTheme(const ObjectId& id);
    const UiThemeAsset* findTheme(const ObjectId& id) const;
 
    std::string                id_;
    std::vector<UiThemeAsset>  themes_;
    ObjectId                   activeId_;
};
 
struct UiThemePreviewSnapshot {
    EditorStatus                  status = EditorStatus::Failed;
    Revision                      documentRevision = 0;
    ObjectId                      themeId;
    ui::Theme                     theme;
    std::string                   runtimeName;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class EVENGINE_API_DOMAINS UiThemePreviewService {
public:
    UiThemePreviewSnapshot build(const UiThemeCatalogTarget& catalog, const ObjectId& themeId,
                                 Revision expectedRevision) const;
};
 
class EVENGINE_API_DOMAINS UiThemeRuntimePublisher {
public:
    [[nodiscard]] Result<void> publish(const UiThemeCatalogTarget& catalog) const;
};
 
}  // namespace eve::ui_editing