SlotBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/Attribute.h"
#include "Widgets/InvalidateWidgetReason.h"
 
class FChildren;
class SWidget;
 
class FSlotBase
{
public:
    SLATECORE_API FSlotBase();
    SLATECORE_API FSlotBase(const FChildren& InParent);
    SLATECORE_API FSlotBase(const TSharedRef<SWidget>& InWidget);
    FSlotBase& operator=(const FSlotBase&) = delete;
    FSlotBase(const FSlotBase&) = delete;
 
    SLATECORE_API virtual ~FSlotBase();
 
public:
    struct FSlotArguments {};
 
public:
    const FChildren* GetOwner() const { return Owner; }
 
    SLATECORE_API SWidget* GetOwnerWidget() const;
 
    SLATECORE_API void SetOwner(const FChildren& Children);
 
    inline void AttachWidget(TSharedRef<SWidget>&& InWidget)
    {
        DetatchParentFromContent();
        Widget = MoveTemp(InWidget);
        AfterContentOrOwnerAssigned();
    }
    inline void AttachWidget( const TSharedRef<SWidget>& InWidget )
    {
        DetatchParentFromContent();
        Widget = InWidget;
        AfterContentOrOwnerAssigned();
    }
 
    inline const TSharedRef<SWidget>& GetWidget() const
    {
        return Widget;
    }
 
    SLATECORE_API const TSharedPtr<SWidget> DetachWidget();
 
    SLATECORE_API void Invalidate(EInvalidateWidgetReason InvalidateReason);
 
protected:
    template<typename TargetValueType, typename SourceValueType>
    bool SetAttribute(TAttribute<TargetValueType>& TargetValue, const TAttribute<SourceValueType>& SourceValue, EInvalidateWidgetReason BaseInvalidationReason)
    {
        if (!TargetValue.IdenticalTo(SourceValue))
        {
            const bool bWasBound = TargetValue.IsBound();
            const bool bBoundnessChanged = bWasBound != SourceValue.IsBound();
            TargetValue = SourceValue;
 
            EInvalidateWidgetReason InvalidateReason = BaseInvalidationReason;
            if (bBoundnessChanged)
            {
                InvalidateReason |= EInvalidateWidgetReason::Volatility;
            }
 
            Invalidate(InvalidateReason);
            return true;
        }
 
        return false;
    }
 
private:
    SLATECORE_API void DetatchParentFromContent();
    SLATECORE_API void AfterContentOrOwnerAssigned();
 
private:
    const FChildren* Owner;
    TSharedRef<SWidget> Widget;
};
 
 
template <typename SlotType>
class TSlotBase : public FSlotBase
{
public:
    using FSlotBase::FSlotBase;
 
    SlotType& operator[](TSharedRef<SWidget>&& InChildWidget)
    {
        this->AttachWidget(MoveTemp(InChildWidget));
        return static_cast<SlotType&>(*this);
    }
    SlotType& operator[]( const TSharedRef<SWidget>& InChildWidget )
    {
        this->AttachWidget(InChildWidget);
        return static_cast<SlotType&>(*this);
    }
 
    SlotType& Expose(SlotType*& OutVarToInit)
    {
        OutVarToInit = static_cast<SlotType*>(this);
        return static_cast<SlotType&>(*this);
    }
 
 
    enum EConstructSlotIsFChildren { ConstructSlotIsFChildren };
 
    struct FSlotArguments : public FSlotBase::FSlotArguments
    {
    public:
        FSlotArguments(EConstructSlotIsFChildren) {}
        FSlotArguments(TUniquePtr<SlotType> InSlot)
            : Slot(MoveTemp(InSlot))
        {
            check(Slot.Get());
        }
        FSlotArguments(const FSlotArguments&) = delete;
        FSlotArguments& operator=(const FSlotArguments&) = delete;
        FSlotArguments(FSlotArguments&&) = default;
        FSlotArguments& operator=(FSlotArguments&&) = default;
 
 
    public:
        typename SlotType::FSlotArguments& operator[](TSharedRef<SWidget>&& InChildWidget)
        {
            ChildWidget = MoveTemp(InChildWidget);
            return Me();
        }
        typename SlotType::FSlotArguments& operator[](const TSharedRef<SWidget>& InChildWidget)
        {
            ChildWidget = InChildWidget;
            return Me();
        }
 
        typename SlotType::FSlotArguments& Expose(SlotType*& OutVarToInit)
        {
            OutVarToInit = Slot.Get();
            return Me();
        }
 
        void AttachWidget(const TSharedRef<SWidget>& InChildWidget)
        {
            ChildWidget = InChildWidget;
        }
 
        const TSharedPtr<SWidget>& GetAttachedWidget() const { return ChildWidget; }
 
        SlotType* GetSlot() const { return Slot.Get(); }
 
        TUniquePtr<SlotType> StealSlot()
        {
            return MoveTemp(Slot);
        }
 
        typename SlotType::FSlotArguments& Me()
        {
            return static_cast<typename SlotType::FSlotArguments&>(*this);
        }
 
    private:
        TUniquePtr<SlotType> Slot;
        TSharedPtr<SWidget> ChildWidget;
    };
 
    void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
    {
        if (InArgs.GetAttachedWidget())
        {
            AttachWidget(InArgs.GetAttachedWidget().ToSharedRef());
        }
        SetOwner(SlotOwner);
    }
};