TypedElementDataStorageUiInterface.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainersFwd.h"
#include "Containers/StringFwd.h"
#include "DataStorage/Queries/Conditions.h"
#include "Elements/Interfaces/TypedElementDataStorageInterface.h"
#include "Elements/Framework/TypedElementMetaData.h"
#include "Elements/Framework/TypedElementQueryBuilder.h"
#include "Elements/Framework/TypedElementSorter.h"
#include "Features/IModularFeature.h"
#include "Templates/UnrealTypeTraits.h"
#include "Templates/SharedPointer.h"
#include "UObject/Interface.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include "TypedElementDataStorageUiInterface.generated.h"
 
namespace UE::Editor::DataStorage
{
    class ITedsWidget;
    class IUiProvider;
}
 
class SWidget;
struct FWidgetPurposeNameColumn;
 
USTRUCT()
struct FTedsWidgetConstructorBase
{
public:
 
    GENERATED_BODY()
 
    TYPEDELEMENTFRAMEWORK_API explicit FTedsWidgetConstructorBase(const UScriptStruct* InTypeInfo);
    explicit FTedsWidgetConstructorBase(EForceInit) {} //< For compatibility and shouldn't be directly used.
    virtual ~FTedsWidgetConstructorBase() = default;
    
    TYPEDELEMENTFRAMEWORK_API virtual bool Initialize(const UE::Editor::DataStorage::FMetaDataView& InArguments,
        TArray<TWeakObjectPtr<const UScriptStruct>> InMatchedColumnTypes, UE::Editor::DataStorage::RowHandle FactoryRowHandle);
 
    TYPEDELEMENTFRAMEWORK_API virtual const UScriptStruct* GetTypeInfo() const;
    TYPEDELEMENTFRAMEWORK_API virtual const TArray<TWeakObjectPtr<const UScriptStruct>>& GetMatchedColumns() const;
    
    TYPEDELEMENTFRAMEWORK_API virtual const UE::Editor::DataStorage::Queries::FConditions* GetQueryConditions(const UE::Editor::DataStorage::ICoreProvider* Storage) const;
protected:
    
    bool Initialize_Internal(const UE::Editor::DataStorage::FMetaDataView& InArguments,
        TArray<TWeakObjectPtr<const UScriptStruct>> InMatchedColumnTypes);
 
protected:
    // The columns this widget constructor matched against
    TArray<TWeakObjectPtr<const UScriptStruct>> MatchedColumnTypes;
 
    // If the constructor matched against any dynamic columns, map from the base template for the column -> FName identifier
    TMap<TWeakObjectPtr<const UScriptStruct>, FName> MatchedDynamicTemplates;
 
    // The row containing the widget factory this constructor was factories from
    UE::Editor::DataStorage::RowHandle WidgetFactoryRow = UE::Editor::DataStorage::InvalidRowHandle;
 
    // The query conditions required by this constructor
    const UE::Editor::DataStorage::Queries::FConditions* QueryConditions = nullptr;
 
    // The constructor's typeinfo
    const UScriptStruct* TypeInfo = nullptr;
};
 
template<>
struct TStructOpsTypeTraits<FTedsWidgetConstructorBase> : public TStructOpsTypeTraitsBase2<FTedsWidgetConstructorBase>
{
    enum
    {
        WithNoInitConstructor = true,
        WithPureVirtual = true,
    };
};
 
USTRUCT()
struct FTypedElementWidgetConstructor : public FTedsWidgetConstructorBase
{
    GENERATED_BODY()
 
public:
    TYPEDELEMENTFRAMEWORK_API explicit FTypedElementWidgetConstructor(const UScriptStruct* InTypeInfo);
    explicit FTypedElementWidgetConstructor(EForceInit) : FTedsWidgetConstructorBase(ForceInit) {} //< For compatibility and shouldn't be directly used.
 
    virtual ~FTypedElementWidgetConstructor() override = default;
    
    TYPEDELEMENTFRAMEWORK_API virtual TConstArrayView<const UScriptStruct*> GetAdditionalColumnsList() const;
    
    TYPEDELEMENTFRAMEWORK_API virtual FText CreateWidgetDisplayNameText(
        UE::Editor::DataStorage::ICoreProvider* DataStorage, UE::Editor::DataStorage::RowHandle Row = UE::Editor::DataStorage::InvalidRowHandle) const;
    
    TYPEDELEMENTFRAMEWORK_API virtual TSharedPtr<SWidget> ConstructFinalWidget(
        UE::Editor::DataStorage::RowHandle Row, 
        UE::Editor::DataStorage::ICoreProvider* DataStorage,
        UE::Editor::DataStorage::IUiProvider* DataStorageUi,
        const UE::Editor::DataStorage::FMetaDataView& Arguments);
 
    TYPEDELEMENTFRAMEWORK_API virtual TSharedPtr<SWidget> Construct(
        UE::Editor::DataStorage::RowHandle Row, 
        UE::Editor::DataStorage::ICoreProvider* DataStorage,
        UE::Editor::DataStorage::IUiProvider* DataStorageUi,
        const UE::Editor::DataStorage::FMetaDataView& Arguments);
    
    TYPEDELEMENTFRAMEWORK_API virtual TArray<TSharedPtr<const UE::Editor::DataStorage::FColumnSorterInterface>> ConstructColumnSorters(
        UE::Editor::DataStorage::ICoreProvider* DataStorage,
        UE::Editor::DataStorage::IUiProvider* DataStorageUi,
        const UE::Editor::DataStorage::FMetaDataView& Arguments);
 
    TYPEDELEMENTFRAMEWORK_API UE::Editor::DataStorage::RowHandle GetWidgetFactoryRow() const;
 
    /*
     * Deprecated public functions
     */
 
    UE_DEPRECATED(5.6, "CreateWidgetDisplayName is deprecated, please use CreateWidgetDisplayNameText instead, which will return FText rather than an FString.")
    TYPEDELEMENTFRAMEWORK_API virtual FString CreateWidgetDisplayName(
        UE::Editor::DataStorage::ICoreProvider* DataStorage, UE::Editor::DataStorage::RowHandle Row) const final;
 
    // To get around name hiding since the deprecated functions overload methods from the base class
    using FTedsWidgetConstructorBase::Initialize;
    using FTedsWidgetConstructorBase::GetQueryConditions;
 
    UE_DEPRECATED(5.6, "Use Initialize that takes in the factory row handle instead")
    TYPEDELEMENTFRAMEWORK_API virtual bool Initialize(const UE::Editor::DataStorage::FMetaDataView& InArguments,
        TArray<TWeakObjectPtr<const UScriptStruct>> InMatchedColumnTypes, const UE::Editor::DataStorage::Queries::FConditions& InQueryConditions);
 
    UE_DEPRECATED(5.6, "Use GetQueryConditions that takes in ICoreProvider* instead")
    TYPEDELEMENTFRAMEWORK_API virtual const UE::Editor::DataStorage::Queries::FConditions* GetQueryConditions() const final;
 
protected:
    TYPEDELEMENTFRAMEWORK_API virtual TSharedPtr<SWidget> CreateWidget(const UE::Editor::DataStorage::FMetaDataView& Arguments);
    TYPEDELEMENTFRAMEWORK_API virtual TSharedPtr<SWidget> CreateWidget(
        UE::Editor::DataStorage::ICoreProvider* DataStorage,
        UE::Editor::DataStorage::IUiProvider* DataStorageUi,
        UE::Editor::DataStorage::RowHandle TargetRow,
        UE::Editor::DataStorage::RowHandle WidgetRow, 
        const UE::Editor::DataStorage::FMetaDataView& Arguments);
    TYPEDELEMENTFRAMEWORK_API virtual bool SetColumns(UE::Editor::DataStorage::ICoreProvider* DataStorage, UE::Editor::DataStorage::RowHandle Row);
    
    TYPEDELEMENTFRAMEWORK_API virtual FText DescribeColumnType(const UScriptStruct* ColumnType) const;
 
    TYPEDELEMENTFRAMEWORK_API virtual bool FinalizeWidget(
        UE::Editor::DataStorage::ICoreProvider* DataStorage,
        UE::Editor::DataStorage::IUiProvider* DataStorageUi,
        UE::Editor::DataStorage::RowHandle Row,
        const TSharedPtr<SWidget>& Widget);
 
    TYPEDELEMENTFRAMEWORK_API void AddDefaultWidgetColumns(UE::Editor::DataStorage::RowHandle Row, UE::Editor::DataStorage::ICoreProvider* DataStorage) const;
 
    TYPEDELEMENTFRAMEWORK_API UE::Editor::DataStorage::RowHandle GetTargetRow(
        UE::Editor::DataStorage::ICoreProvider* DataStorage, UE::Editor::DataStorage::RowHandle WidgetRow) const;
};
 
USTRUCT()
struct FSimpleWidgetConstructor : public FTypedElementWidgetConstructor
{
    GENERATED_BODY()
 
    
    TYPEDELEMENTFRAMEWORK_API explicit FSimpleWidgetConstructor(const UScriptStruct* InTypeInfo);
 
    FSimpleWidgetConstructor() : Super(StaticStruct()) {} //< For compatibility and shouldn't be directly used.
    
    virtual ~FSimpleWidgetConstructor() override = default;
 
    /*
     * Required function to create the actual widget instance.
     * 
     * @param DataStorage A pointer to the TEDS data storage interface
     * @param DataStorageUi A pointer to the TEDS data storage UI interface
     * @param TargetRow The row for the actual data this widget is being created for (can be InvalidRowHandle if there is no target row attached to this widget)
     * @param WidgetRow The row that contains information about the widget itself
     * @param Arguments Any metadata arguments that were specified
     * @return The actual widget instance
     */
    TYPEDELEMENTFRAMEWORK_API virtual TSharedPtr<SWidget> CreateWidget(
        UE::Editor::DataStorage::ICoreProvider* DataStorage,
        UE::Editor::DataStorage::IUiProvider* DataStorageUi,
        UE::Editor::DataStorage::RowHandle TargetRow,
        UE::Editor::DataStorage::RowHandle WidgetRow,
        const UE::Editor::DataStorage::FMetaDataView& Arguments) override;
 
    /*
     * Override this function to add any columns to the WidgetRow before CreateWidget is called
     * 
     * @param DataStorage A pointer to the TEDS data storage interface
     * @param WidgetRow The row that contains information about the widget itself
     * @return Whether any columns were added
     */
    TYPEDELEMENTFRAMEWORK_API virtual bool SetColumns(UE::Editor::DataStorage::ICoreProvider* DataStorage, UE::Editor::DataStorage::RowHandle WidgetRow) override;
 
protected:
 
    TYPEDELEMENTFRAMEWORK_API virtual TSharedPtr<SWidget> CreateWidget(const UE::Editor::DataStorage::FMetaDataView& Arguments) override final;
    
    TYPEDELEMENTFRAMEWORK_API virtual bool FinalizeWidget(
        UE::Editor::DataStorage::ICoreProvider* DataStorage,
        UE::Editor::DataStorage::IUiProvider* DataStorageUi,
        UE::Editor::DataStorage::RowHandle Row,
        const TSharedPtr<SWidget>& Widget) override final;
    
    TYPEDELEMENTFRAMEWORK_API virtual TSharedPtr<SWidget> Construct(
        UE::Editor::DataStorage::RowHandle WidgetRow,
        UE::Editor::DataStorage::ICoreProvider* DataStorage,
        UE::Editor::DataStorage::IUiProvider* DataStorageUi,
        const UE::Editor::DataStorage::FMetaDataView& Arguments) override final;
};
 
template<>
struct TStructOpsTypeTraits<FTypedElementWidgetConstructor> : public TStructOpsTypeTraitsBase2<FTypedElementWidgetConstructor>
{
    enum
    {
        WithNoInitConstructor = true,
        WithPureVirtual = true,
    };
};
 
namespace UE::Editor::DataStorage
{
    class IUiProvider : public IModularFeature
    {
    public:
        inline static const FName PurposeMappingDomain = "WidgetPurpose";
 
        enum class EPurposeType : uint8
        {
            Generic,
            UniqueByName,
            UniqueByNameAndColumn
        };
 
        enum class EMatchApproach : uint8
        {
            LongestMatch,
            ExactMatch,
            SingleMatch
        };
 
        using FPurposeID = FMapKey;
 
        /*
         * Struct describing the default init params for a widget purpose. These can also be added to the purpose row post init using the columns
         * in WidgetPurposeColumns.h
         */
        struct FPurposeInfo
        {
            FName Namespace;
 
            FName Name;
 
            FName Frame;
 
            EPurposeType Type;
 
            FText Description;
 
            FPurposeID ParentPurposeID;
 
            TYPEDELEMENTFRAMEWORK_API FPurposeInfo(const FName& InNamespace, const FName& InName, const FName& InFrame,
                EPurposeType InPurposeType = EPurposeType::UniqueByNameAndColumn, const FText& InDescription = FText::GetEmpty(),
                const FPurposeID& InParent = FPurposeID());
        
            TYPEDELEMENTFRAMEWORK_API FPurposeInfo(const FName& InLegacyPurposeName, EPurposeType InPurposeType, const FText& InDescription,
                const FPurposeID& InParent = FPurposeID());
 
            TYPEDELEMENTFRAMEWORK_API explicit FPurposeInfo(const FWidgetPurposeNameColumn& WidgetPurposeNameColumn);
 
            TYPEDELEMENTFRAMEWORK_API FPurposeID GeneratePurposeID() const;
 
            TYPEDELEMENTFRAMEWORK_API FName ToString() const;
        };
 
        using WidgetCreatedCallback = TFunctionRef<void(const TSharedRef<SWidget>& NewWidget, UE::Editor::DataStorage::RowHandle Row)>;
        using WidgetConstructorCallback = TFunctionRef<bool(TUniquePtr<FTypedElementWidgetConstructor>, TConstArrayView<TWeakObjectPtr<const UScriptStruct>>)>;
        using WidgetPurposeCallback = TFunctionRef<void(FName, EPurposeType, const FText&)>;
        using PropertySorterConstructorCallback = 
            TFunction<TSharedPtr<const FColumnSorterInterface>(TWeakObjectPtr<const UScriptStruct> ColumnType, const FProperty& Property)>;
 
        virtual RowHandle RegisterWidgetPurpose(const FPurposeInfo& InPurposeInfo) = 0;
    
        virtual RowHandle RegisterWidgetPurpose(const FPurposeID& PurposeID, const FPurposeInfo& InPurposeInfo) = 0;
 
        virtual RowHandle FindPurpose(const FPurposeID& PurposeID) const = 0;
 
        virtual void ListWidgetPurposes(const WidgetPurposeCallback& Callback) const = 0;
 
 
        virtual FPurposeID GetDefaultWidgetPurposeID() const = 0;
 
        virtual FPurposeID GetGeneralWidgetPurposeID() const = 0;
    
        virtual bool RegisterWidgetFactory(RowHandle PurposeRow, const UScriptStruct* Constructor) = 0;
 
        template<typename ConstructorType>
        bool RegisterWidgetFactory(RowHandle PurposeRow);
 
        virtual bool RegisterWidgetFactory(RowHandle PurposeRow, const UScriptStruct* Constructor,
            Queries::FConditions Columns) = 0;
    
        template<typename ConstructorType>
        bool RegisterWidgetFactory(RowHandle PurposeRow, Queries::FConditions Columns);
 
        template<TColumnType ColumnType>
        bool RegisterDecoratorWidgetFactory(RowHandle PurposeRow, const UScriptStruct* Constructor);
 
        virtual bool RegisterDecoratorWidgetFactory(RowHandle PurposeRow, const UScriptStruct* Constructor,
            const UScriptStruct* Column) = 0;
    
        virtual void CreateWidgetConstructors(RowHandle PurposeRow, 
            const FMetaDataView& Arguments, const WidgetConstructorCallback& Callback) = 0;
    
        virtual void CreateWidgetConstructors(RowHandle PurposeRow, EMatchApproach MatchApproach, TArray<TWeakObjectPtr<const UScriptStruct>>& Columns,
            const FMetaDataView& Arguments, const WidgetConstructorCallback& Callback) = 0;
    
        virtual void ConstructWidgets(RowHandle PurposeRow, const FMetaDataView& Arguments,
            const WidgetCreatedCallback& ConstructionCallback) = 0;
    
        virtual TSharedPtr<SWidget> ConstructWidget(RowHandle Row, FTypedElementWidgetConstructor& Constructor,
            const FMetaDataView& Arguments) = 0;
 
        virtual TSharedPtr<SWidget> ConstructInternalWidget(RowHandle Row, FTypedElementWidgetConstructor& Constructor,
            const FMetaDataView& Arguments) = 0;
 
        virtual TSharedPtr<ITedsWidget> CreateContainerTedsWidget(RowHandle UiRowHandle) const = 0;
 
        virtual TableHandle GetWidgetTable() const = 0;
 
        virtual void GeneratePropertySorters(TArray<TSharedPtr<const FColumnSorterInterface>>& Results,
            TArrayView<TWeakObjectPtr<const UScriptStruct>> Columns) const = 0;
 
        virtual void RegisterSorterGeneratorForProperty(const FFieldClass* PropertyType, 
            PropertySorterConstructorCallback PropertySorterConstructor) = 0;
 
        template<typename PropertyClassType> requires(std::is_base_of_v<FProperty, PropertyClassType>)
            void RegisterSorterGeneratorForProperty(PropertySorterConstructorCallback PropertySorterConstructor);
 
        virtual void UnregisterSorterGeneratorForProperty(const FFieldClass* PropertyType) = 0;
 
        template<typename PropertyClassType> requires(std::is_base_of_v<FProperty, PropertyClassType>)
            void UnregisterSorterGeneratorForProperty();
 
        virtual bool SupportsExtension(FName Extension) const = 0;
        virtual void ListExtensions(TFunctionRef<void(FName)> Callback) const = 0;
 
        UE_DEPRECATED(5.7, "Registering Widget Factories by instance is not supported anymore, register them by type instead")
        virtual bool RegisterWidgetFactory(RowHandle PurposeRow, TUniquePtr<FTypedElementWidgetConstructor>&& Constructor) = 0;
    
        UE_DEPRECATED(5.7, "Registering Widget Factories by instance is not supported anymore, register them by type instead")
        virtual bool RegisterWidgetFactory(RowHandle PurposeRow, TUniquePtr<FTypedElementWidgetConstructor>&& Constructor, 
            Queries::FConditions Columns) = 0;
        
        UE_DEPRECATED(5.6, "Use the version that takes in an FPurposeInfo struct instead")
        virtual void RegisterWidgetPurpose(FName Purpose, EPurposeType Type, FText Description) = 0;
    
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        virtual bool RegisterWidgetFactory(FName Purpose, const UScriptStruct* Constructor) = 0;
    
        template<typename ConstructorType>
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        bool RegisterWidgetFactory(FName Purpose);
 
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        virtual bool RegisterWidgetFactory(FName Purpose, const UScriptStruct* Constructor, Queries::FConditions Columns) = 0;
 
        template<typename ConstructorType>
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        bool RegisterWidgetFactory(FName Purpose, Queries::FConditions Columns);
 
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        virtual bool RegisterWidgetFactory(FName Purpose, TUniquePtr<FTypedElementWidgetConstructor>&& Constructor) = 0;
 
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        virtual bool RegisterWidgetFactory(FName Purpose, TUniquePtr<FTypedElementWidgetConstructor>&& Constructor, 
            Queries::FConditions Columns) = 0;
 
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        virtual void CreateWidgetConstructors(FName Purpose, const FMetaDataView& Arguments, const WidgetConstructorCallback& Callback) = 0;
 
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        virtual void CreateWidgetConstructors(FName Purpose, EMatchApproach MatchApproach, TArray<TWeakObjectPtr<const UScriptStruct>>& Columns,
            const FMetaDataView& Arguments, const WidgetConstructorCallback& Callback) = 0;
 
        UE_DEPRECATED(5.6, "Use the version that takes in PurposeRowHandle instead. FindPurpose() to lookup row handle by PurposeID")
        virtual void ConstructWidgets(FName Purpose, const FMetaDataView& Arguments, const WidgetCreatedCallback& ConstructionCallback) = 0;
 
    };
 
    using FWidgetConstructor = FTypedElementWidgetConstructor;
    using FSimpleWidgetConstructor = FSimpleWidgetConstructor;
 
    //
    // Implementations
    //
 
    template<typename ConstructorType>
    bool IUiProvider::RegisterWidgetFactory(FName Purpose)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return this->RegisterWidgetFactory(Purpose, ConstructorType::StaticStruct());
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    template<typename ConstructorType>
    bool IUiProvider::RegisterWidgetFactory(RowHandle PurposeRow)
    {
        return this->RegisterWidgetFactory(PurposeRow, ConstructorType::StaticStruct());
    }
 
    template<typename ConstructorType>
    bool IUiProvider::RegisterWidgetFactory(FName Purpose, Queries::FConditions Columns)
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return this->RegisterWidgetFactory(Purpose, ConstructorType::StaticStruct(), Columns);
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    template<typename ConstructorType>
    bool IUiProvider::RegisterWidgetFactory(RowHandle PurposeRow, Queries::FConditions Columns)
    {
        return this->RegisterWidgetFactory(PurposeRow, ConstructorType::StaticStruct(), Columns);
    }
 
    template<TColumnType ColumnType>
    bool IUiProvider::RegisterDecoratorWidgetFactory(RowHandle PurposeRow, const UScriptStruct* Constructor)
    {
        return this->RegisterDecoratorWidgetFactory(PurposeRow, Constructor, ColumnType::StaticStruct());
    }
 
    template<typename PropertyClassType> requires(std::is_base_of_v<FProperty, PropertyClassType>)
        void IUiProvider::RegisterSorterGeneratorForProperty(PropertySorterConstructorCallback PropertySorterConstructor)
    {
        RegisterSorterGeneratorForProperty(PropertyClassType::StaticClass(), PropertySorterConstructor);
    }
 
    template<typename PropertyClassType> requires(std::is_base_of_v<FProperty, PropertyClassType>)
        void IUiProvider::UnregisterSorterGeneratorForProperty()
    {
        UnregisterSorterGeneratorForProperty(PropertyClassType::StaticClass());
    }
}