TypedElementSelectionSet.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 "Delegates/Delegate.h"
#include "Elements/Framework/TypedElementHandle.h"
#include "Elements/Framework/TypedElementInterfaceCustomization.h"
#include "Elements/Framework/TypedElementList.h"
#include "Elements/Framework/TypedElementListFwd.h"
#include "Elements/Framework/TypedElementListObjectUtil.h"
#include "Elements/Interfaces/TypedElementSelectionInterface.h"
#include "HAL/Platform.h"
#include "Templates/Function.h"
#include "Templates/SharedPointer.h"
#include "Templates/SubclassOf.h"
#include "Templates/Tuple.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include "TypedElementSelectionSet.generated.h"
 
class FArchive;
class UClass;
class UInterface;
class UTypedElementSelectionSet;
struct FFrame;
 
USTRUCT(BlueprintType)
struct FTypedElementSelectionNormalizationOptions
{
    GENERATED_BODY()
 
public:
    FTypedElementSelectionNormalizationOptions& SetExpandGroups(const bool InExpandGroups) { bExpandGroups = InExpandGroups; return *this; }
    bool ExpandGroups() const { return bExpandGroups; }
 
    FTypedElementSelectionNormalizationOptions& SetFollowAttachment(const bool InFollowAttachment) { bFollowAttachment = InFollowAttachment; return *this; }
    bool FollowAttachment() const { return bFollowAttachment; }
 
    // Set the selection set name that will be passed into the selection column in TEDS (if it is enabled)
    FTypedElementSelectionNormalizationOptions& SetNameForTEDSIntegration(const FName& InTEDSIntegrationSelectionSetName) { TEDSIntegrationSelectionSetName = InTEDSIntegrationSelectionSetName; return *this; }
    FName GetNameForTEDSIntegration() const { return TEDSIntegrationSelectionSetName; }
    
private:
    UPROPERTY(BlueprintReadWrite, Category="TypedElementInterfaces|Selection|NormalizationOptions", meta=(AllowPrivateAccess=true))
    bool bExpandGroups = false;
 
    UPROPERTY(BlueprintReadWrite, Category="TypedElementInterfaces|Selection|NormalizationOptions", meta=(AllowPrivateAccess=true))
    bool bFollowAttachment = false;
 
    FName TEDSIntegrationSelectionSetName = FName();
};
 
class FTypedElementSelectionCustomization
{
public:
    virtual ~FTypedElementSelectionCustomization() = default;
 
    //~ See ITypedElementSelectionInterface for API docs
    virtual bool IsElementSelected(const TTypedElement<ITypedElementSelectionInterface>& InElementSelectionHandle, FTypedElementListConstRef InSelectionSet, const FTypedElementIsSelectedOptions& InSelectionOptions) { return InElementSelectionHandle.IsElementSelected(InSelectionSet, InSelectionOptions); }
    virtual bool CanSelectElement(const TTypedElement<ITypedElementSelectionInterface>& InElementSelectionHandle, const FTypedElementSelectionOptions& InSelectionOptions) { return InElementSelectionHandle.CanSelectElement(InSelectionOptions); }
    virtual bool CanDeselectElement(const TTypedElement<ITypedElementSelectionInterface>& InElementSelectionHandle, const FTypedElementSelectionOptions& InSelectionOptions) { return InElementSelectionHandle.CanDeselectElement(InSelectionOptions); }
    virtual bool SelectElement(const TTypedElement<ITypedElementSelectionInterface>& InElementSelectionHandle, FTypedElementListRef InSelectionSet, const FTypedElementSelectionOptions& InSelectionOptions) { return InElementSelectionHandle.SelectElement(InSelectionSet, InSelectionOptions); }
    virtual bool DeselectElement(const TTypedElement<ITypedElementSelectionInterface>& InElementSelectionHandle, FTypedElementListRef InSelectionSet, const FTypedElementSelectionOptions& InSelectionOptions) { return InElementSelectionHandle.DeselectElement(InSelectionSet, InSelectionOptions); }
    virtual bool AllowSelectionModifiers(const TTypedElement<ITypedElementSelectionInterface>& InElementSelectionHandle, FTypedElementListConstRef InSelectionSet) { return InElementSelectionHandle.AllowSelectionModifiers(InSelectionSet); }
    virtual FTypedElementHandle GetSelectionElement(const TTypedElement<ITypedElementSelectionInterface>& InElementSelectionHandle, FTypedElementListConstRef InCurrentSelection, const ETypedElementSelectionMethod InSelectionMethod) { return InElementSelectionHandle.GetSelectionElement(InCurrentSelection, InSelectionMethod); }
    TYPEDELEMENTRUNTIME_API virtual void GetNormalizedElements(const TTypedElement<ITypedElementSelectionInterface>& InElementSelectionHandle, FTypedElementListConstRef InSelectionSet, const FTypedElementSelectionNormalizationOptions& InNormalizationOptions, FTypedElementListRef OutNormalizedElements);
};
 
struct FTypedElementSelectionSetElement
{
public:
    FTypedElementSelectionSetElement() = default;
 
    FTypedElementSelectionSetElement(TTypedElement<ITypedElementSelectionInterface> InElementSelectionHandle, FTypedElementListPtr InElementList, FTypedElementSelectionCustomization* InSelectionCustomization)
        : ElementSelectionHandle(MoveTemp(InElementSelectionHandle))
        , ElementList(InElementList)
        , SelectionCustomization(InSelectionCustomization)
    {
    }
 
    FTypedElementSelectionSetElement(const FTypedElementSelectionSetElement&) = default;
    FTypedElementSelectionSetElement& operator=(const FTypedElementSelectionSetElement&) = default;
 
    FTypedElementSelectionSetElement(FTypedElementSelectionSetElement&&) = default;
    FTypedElementSelectionSetElement& operator=(FTypedElementSelectionSetElement&&) = default;
 
    inline explicit operator bool() const
    {
        return IsSet();
    }
 
    inline bool IsSet() const
    {
        return ElementSelectionHandle.IsSet()
            && ElementList
            && SelectionCustomization;
    }
 
    //~ See ITypedElementSelectionInterface for API docs
    bool IsElementSelected(const FTypedElementIsSelectedOptions& InSelectionOptions) const { return SelectionCustomization->IsElementSelected(ElementSelectionHandle, ElementList.ToSharedRef(), InSelectionOptions); }
    bool CanSelectElement(const FTypedElementSelectionOptions& InSelectionOptions) const { return SelectionCustomization->CanSelectElement(ElementSelectionHandle, InSelectionOptions); }
    bool CanDeselectElement(const FTypedElementSelectionOptions& InSelectionOptions) const { return SelectionCustomization->CanDeselectElement(ElementSelectionHandle, InSelectionOptions); }
    bool SelectElement(const FTypedElementSelectionOptions& InSelectionOptions) const { return SelectionCustomization->SelectElement(ElementSelectionHandle, ElementList.ToSharedRef(), InSelectionOptions); }
    bool DeselectElement(const FTypedElementSelectionOptions& InSelectionOptions) const { return SelectionCustomization->DeselectElement(ElementSelectionHandle, ElementList.ToSharedRef(), InSelectionOptions); }
    bool AllowSelectionModifiers() const { return SelectionCustomization->AllowSelectionModifiers(ElementSelectionHandle, ElementList.ToSharedRef()); }
    FTypedElementHandle GetSelectionElement(const ETypedElementSelectionMethod InSelectionMethod) const { return SelectionCustomization->GetSelectionElement(ElementSelectionHandle, ElementList.ToSharedRef(), InSelectionMethod); }
    void GetNormalizedElements(const FTypedElementSelectionNormalizationOptions& InNormalizationOptions, FTypedElementListRef OutNormalizedElements) const { return SelectionCustomization->GetNormalizedElements(ElementSelectionHandle, ElementList.ToSharedRef(), InNormalizationOptions, OutNormalizedElements); }
 
private:
    TTypedElement<ITypedElementSelectionInterface> ElementSelectionHandle;
    FTypedElementListPtr ElementList;
    FTypedElementSelectionCustomization* SelectionCustomization = nullptr;
};
 
USTRUCT(BlueprintType)
struct FTypedElementSelectionSetState
{
    GENERATED_BODY()
 
    friend class UTypedElementSelectionSet;
 
    FTypedElementSelectionSetState() = default;
 
    FTypedElementSelectionSetState(FTypedElementSelectionSetState&&) = default;
    FTypedElementSelectionSetState& operator=(FTypedElementSelectionSetState&&) = default;
 
    FTypedElementSelectionSetState(const FTypedElementSelectionSetState& InOther)
        : CreatedFromSelectionSet(InOther.CreatedFromSelectionSet)
    {
        TransactedElements.Reserve(InOther.TransactedElements.Num());
        for (const TUniquePtr<ITypedElementTransactedElement>& OtherTransactedElement : InOther.TransactedElements)
        {
            TransactedElements.Emplace(OtherTransactedElement->Clone());
        }
    }
 
    FTypedElementSelectionSetState& operator=(const FTypedElementSelectionSetState& InOther)
    {
        if (&InOther != this)
        {
            CreatedFromSelectionSet = InOther.CreatedFromSelectionSet;
 
            TransactedElements.Reset(InOther.TransactedElements.Num());
            for (const TUniquePtr<ITypedElementTransactedElement>& OtherTransactedElement : InOther.TransactedElements)
            {
                TransactedElements.Emplace(OtherTransactedElement->Clone());
            }
        }
        return *this;
    }
 
private:
    UPROPERTY()
    TWeakObjectPtr<const UTypedElementSelectionSet> CreatedFromSelectionSet;
 
    TArray<TUniquePtr<ITypedElementTransactedElement>> TransactedElements;
};
 
UCLASS(Transient, BlueprintType, meta=(DontUseGenericSpawnObject="True"), MinimalAPI)
class UTypedElementSelectionSet : public UObject, public TTypedElementInterfaceCustomizationRegistry<FTypedElementSelectionCustomization>
{
    GENERATED_BODY()
 
public:
    TYPEDELEMENTRUNTIME_API UTypedElementSelectionSet();
 
    //~ UObject interface
#if WITH_EDITOR
    TYPEDELEMENTRUNTIME_API virtual void PreEditUndo() override;
    TYPEDELEMENTRUNTIME_API virtual void PostEditUndo() override;
    TYPEDELEMENTRUNTIME_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
#endif  // WITH_EDITOR
    TYPEDELEMENTRUNTIME_API virtual void BeginDestroy() override;
    TYPEDELEMENTRUNTIME_API virtual void Serialize(FArchive& Ar) override;
 
    TYPEDELEMENTRUNTIME_API bool IsElementSelected(const FTypedElementHandle& InElementHandle, const FTypedElementIsSelectedOptions InSelectionOptions) const;
 
    TYPEDELEMENTRUNTIME_API bool CanSelectElement(const FTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions) const;
 
    TYPEDELEMENTRUNTIME_API bool CanDeselectElement(const FTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions) const;
 
    TYPEDELEMENTRUNTIME_API bool SelectElement(const FTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions);
 
    TYPEDELEMENTRUNTIME_API bool SelectElements(const TArray<FTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
    TYPEDELEMENTRUNTIME_API bool SelectElements(TArrayView<const FTypedElementHandle> InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
    TYPEDELEMENTRUNTIME_API bool SelectElements(FTypedElementListConstRef InElementList, const FTypedElementSelectionOptions InSelectionOptions);
 
    TYPEDELEMENTRUNTIME_API bool DeselectElement(const FTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions);
 
    TYPEDELEMENTRUNTIME_API bool DeselectElements(const TArray<FTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
    TYPEDELEMENTRUNTIME_API bool DeselectElements(TArrayView<const FTypedElementHandle> InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
    TYPEDELEMENTRUNTIME_API bool DeselectElements(FTypedElementListConstRef InElementList, const FTypedElementSelectionOptions InSelectionOptions);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool ClearSelection(const FTypedElementSelectionOptions InSelectionOptions);
 
    TYPEDELEMENTRUNTIME_API bool SetSelection(const TArray<FTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
    TYPEDELEMENTRUNTIME_API bool SetSelection(TArrayView<const FTypedElementHandle> InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
    TYPEDELEMENTRUNTIME_API bool SetSelection(FTypedElementListConstRef InElementList, const FTypedElementSelectionOptions InSelectionOptions);
 
    TYPEDELEMENTRUNTIME_API bool AllowSelectionModifiers(const FTypedElementHandle& InElementHandle) const;
 
    TYPEDELEMENTRUNTIME_API void SetNameForTedsIntegration(const FName InNameForIntegration);
 
    TYPEDELEMENTRUNTIME_API FTypedElementHandle GetSelectionElement(const FTypedElementHandle& InElementHandle, const ETypedElementSelectionMethod InSelectionMethod) const;
 
    TYPEDELEMENTRUNTIME_API FTypedElementListRef GetNormalizedSelection(const FTypedElementSelectionNormalizationOptions InNormalizationOptions) const;
    TYPEDELEMENTRUNTIME_API void GetNormalizedSelection(const FTypedElementSelectionNormalizationOptions& InNormalizationOptions, FTypedElementListRef OutNormalizedElements) const;
 
    TYPEDELEMENTRUNTIME_API FTypedElementListRef GetNormalizedElementList(FTypedElementListConstRef InElementList, const FTypedElementSelectionNormalizationOptions InNormalizationOptions) const;
    TYPEDELEMENTRUNTIME_API void GetNormalizedElementList(FTypedElementListConstRef InElementList, const FTypedElementSelectionNormalizationOptions& InNormalizationOptions, FTypedElementListRef OutNormalizedElements) const;
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Selection")
    int32 GetNumSelectedElements() const
    {
        return ElementList->Num();
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="TypedElementFramework|Selection")
    bool HasSelectedElements(const TSubclassOf<UInterface> InBaseInterfaceType = {}) const
    {
        return ElementList->HasElements(InBaseInterfaceType);
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="TypedElementFramework|Selection")
    int32 CountSelectedElements(const TSubclassOf<UInterface> InBaseInterfaceType = {}) const
    {
        return ElementList->CountElements(InBaseInterfaceType);
    }
 
    TArray<FTypedElementHandle> GetSelectedElementHandles(const TSubclassOf<UInterface> InBaseInterfaceType = {}) const
    {
        return ElementList->GetElementHandles(InBaseInterfaceType);
    }
 
    template <typename ArrayAllocator>
    void GetSelectedElementHandles(TArray<FTypedElementHandle, ArrayAllocator>& OutArray, const TSubclassOf<UInterface>& InBaseInterfaceType = {}) const
    {
        ElementList->GetElementHandles(OutArray, InBaseInterfaceType);
    }
 
    void ForEachSelectedElementHandle(TFunctionRef<bool(const FTypedElementHandle&)> InCallback, const TSubclassOf<UInterface>& InBaseInterfaceType = {}) const
    {
        ElementList->ForEachElementHandle(InCallback, InBaseInterfaceType);
    }
 
    template <typename BaseInterfaceType>
    void ForEachSelectedElement(TFunctionRef<bool(const TTypedElement<BaseInterfaceType>&)> InCallback) const
    {
        ElementList->ForEachElement<BaseInterfaceType>(InCallback);
    }
 
    template <typename BaseInterfaceType>
    TTypedElement<BaseInterfaceType> GetTopSelectedElement() const
    {
        return ElementList->GetTopElement<BaseInterfaceType>();
    }
 
    template <typename BaseInterfaceType>
    TTypedElement<BaseInterfaceType> GetTopSelectedElement(TFunctionRef<bool (const TTypedElement<BaseInterfaceType>&)> Predicate) const
    {
        return ElementList->GetTopElement<BaseInterfaceType>(Predicate);
    }
 
    template <typename BaseInterfaceType>
    TTypedElement<BaseInterfaceType> GetBottomSelectedElement() const
    {
        return ElementList->GetBottomElement<BaseInterfaceType>();
    }
 
    template <typename BaseInterfaceType>
    TTypedElement<BaseInterfaceType> GetBottomSelectedElement(TFunctionRef<bool (const TTypedElement<BaseInterfaceType>&)> Predicate) const
    {
        return ElementList->GetBottomElement<BaseInterfaceType>(Predicate);
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="TypedElementFramework|Selection")
    bool HasSelectedObjects(const UClass* InRequiredClass = nullptr) const
    {
        return TypedElementListObjectUtil::HasObjects(ElementList.ToSharedRef(), InRequiredClass);
    }
 
    template <typename RequiredClassType>
    bool HasSelectedObjects() const
    {
        return TypedElementListObjectUtil::HasObjects<RequiredClassType>(ElementList.ToSharedRef());
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="TypedElementFramework|Selection")
    int32 CountSelectedObjects(const UClass* InRequiredClass = nullptr) const
    {
        return TypedElementListObjectUtil::CountObjects(ElementList.ToSharedRef(), InRequiredClass);
    }
 
    template <typename RequiredClassType>
    int32 CountSelectedObjects() const
    {
        return TypedElementListObjectUtil::CountObjects<RequiredClassType>(ElementList.ToSharedRef());
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, Category="TypedElementFramework|Selection")
    TArray<UObject*> GetSelectedObjects(const UClass* InRequiredClass = nullptr) const
    {
        return TypedElementListObjectUtil::GetObjects(ElementList.ToSharedRef(), InRequiredClass);
    }
 
    template <typename RequiredClassType>
    TArray<RequiredClassType*> GetSelectedObjects() const
    {
        return TypedElementListObjectUtil::GetObjects<RequiredClassType>(ElementList.ToSharedRef());
    }
 
    void ForEachSelectedObject(TFunctionRef<bool(UObject*)> InCallback, const UClass* InRequiredClass = nullptr) const
    {
        TypedElementListObjectUtil::ForEachObject(ElementList.ToSharedRef(), InCallback, InRequiredClass);
    }
 
    template <typename RequiredClassType>
    void ForEachSelectedObject(TFunctionRef<bool(RequiredClassType*)> InCallback) const
    {
        TypedElementListObjectUtil::ForEachObject<RequiredClassType>(ElementList.ToSharedRef(), InCallback);
    }
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Selection")
    UObject* GetTopSelectedObject(const UClass* InRequiredClass = nullptr) const
    {
        return TypedElementListObjectUtil::GetTopObject(ElementList.ToSharedRef(), InRequiredClass);
    }
 
    template <typename RequiredClassType>
    RequiredClassType* GetTopSelectedObject() const
    {
        return TypedElementListObjectUtil::GetTopObject<RequiredClassType>(ElementList.ToSharedRef());
    }
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Selection")
    UObject* GetBottomSelectedObject(const UClass* InRequiredClass = nullptr) const
    {
        return TypedElementListObjectUtil::GetBottomObject(ElementList.ToSharedRef(), InRequiredClass);
    }
 
    template <typename RequiredClassType>
    RequiredClassType* GetBottomSelectedObject() const
    {
        return TypedElementListObjectUtil::GetBottomObject<RequiredClassType>(ElementList.ToSharedRef());
    }
 
    DECLARE_EVENT_OneParam(UTypedElementSelectionSet, FOnPreChange, const UTypedElementSelectionSet* /*InElementSelectionSet*/);
    FOnPreChange& OnPreChange()
    {
        return OnPreChangeDelegate;
    }
 
    DECLARE_EVENT_OneParam(UTypedElementSelectionSet, FOnChanged, const UTypedElementSelectionSet* /*InElementSelectionSet*/);
    FOnChanged& OnChanged()
    {
        return OnChangedDelegate;
    }
 
    void NotifyPendingChanges()
    {
        ElementList->NotifyPendingChanges();
    }
 
    FTypedElementList::FScopedClearNewPendingChange GetScopedClearNewPendingChange()
    {
        return ElementList->GetScopedClearNewPendingChange();
    }
 
    FTypedElementList::FLegacySync& Legacy_GetElementListSync()
    {
        return ElementList->Legacy_GetSync();
    }
 
    FTypedElementList::FLegacySync* Legacy_GetElementListSyncPtr()
    {
        return ElementList->Legacy_GetSyncPtr();
    }
 
    FTypedElementListConstRef GetElementList() const
    {
        return ElementList.ToSharedRef();
    }
 
    UFUNCTION(BlueprintPure, Category = "TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API FTypedElementSelectionSetState GetCurrentSelectionState() const;
 
    UFUNCTION(BlueprintCallable, Category = "TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API void RestoreSelectionState(const FTypedElementSelectionSetState& InSelectionState);
 
 
    /*
     * Script Api
     */
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool IsElementSelected(const FScriptTypedElementHandle& InElementHandle, const FTypedElementIsSelectedOptions InSelectionOptions) const;
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool CanSelectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions) const;
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool CanDeselectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions) const;
 
    UFUNCTION(BlueprintCallable, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool SelectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool SelectElements(const TArray<FScriptTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool DeselectElement(const FScriptTypedElementHandle& InElementHandle, const FTypedElementSelectionOptions InSelectionOptions);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool DeselectElements(const TArray<FScriptTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
 
    UFUNCTION(BlueprintCallable, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool SetSelection(const TArray<FScriptTypedElementHandle>& InElementHandles, const FTypedElementSelectionOptions InSelectionOptions);
 
    UFUNCTION(BlueprintPure, Category="TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API bool AllowSelectionModifiers(const FScriptTypedElementHandle& InElementHandle) const;
 
    UFUNCTION(BlueprintPure, Category = "TypedElementFramework|Selection")
    TYPEDELEMENTRUNTIME_API FScriptTypedElementHandle GetSelectionElement(const FScriptTypedElementHandle& InElementHandle, const ETypedElementSelectionMethod InSelectionMethod) const;
 
 
    UFUNCTION(BlueprintCallable, BlueprintPure=false, DisplayName="Get Selected Element Handles", Category="TypedElementFramework|Selection", meta=(ScriptName="GetSelectedElementHandles"))
    TYPEDELEMENTRUNTIME_API TArray<FScriptTypedElementHandle> K2_GetSelectedElementHandles(const TSubclassOf<UInterface> InBaseInterfaceType = {}) const;
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPreChangeDynamic, const UTypedElementSelectionSet*, SelectionSet);
 
    UPROPERTY(BlueprintAssignable, Category = "TypedElementFramework|Selection")
    FOnPreChangeDynamic OnPreSelectionChange;
 
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnChangeDynamic, const UTypedElementSelectionSet*, SelectionSet);
 
    UPROPERTY(BlueprintAssignable, Category = "TypedElementFramework|Selection")
    FOnChangeDynamic OnSelectionChange;
 
private:
    TYPEDELEMENTRUNTIME_API FTypedElementSelectionSetElement ResolveSelectionSetElement(const FTypedElementHandle& InElementHandle) const;
 
    TYPEDELEMENTRUNTIME_API void OnElementReplaced(TArrayView<const TTuple<FTypedElementHandle, FTypedElementHandle>> InReplacedElements);
 
    TYPEDELEMENTRUNTIME_API void OnElementUpdated(TArrayView<const FTypedElementHandle> InUpdatedElements);
 
    TYPEDELEMENTRUNTIME_API void OnElementListPreChange(const FTypedElementList& InElementList);
 
    TYPEDELEMENTRUNTIME_API void OnElementListChanged(const FTypedElementList& InElementList);
 
    FTypedElementListPtr ElementList;
 
    FOnPreChange OnPreChangeDelegate;
 
    FOnChanged OnChangedDelegate;
 
    bool bIsRestoringState = false;
 
    TUniquePtr<FTypedElementSelectionSetState> PendingUndoRedoState;
 
    FName ListNameForTedsIntegration;
};