SWidget.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 "Misc/FrameValue.h"
#include "Stats/Stats.h"
#include "Styling/SlateColor.h"
#include "Layout/SlateRect.h"
#include "Layout/Visibility.h"
#include "Layout/Clipping.h"
#include "Layout/Geometry.h"
#include "Layout/ArrangedWidget.h"
#include "Layout/LayoutGeometry.h"
#include "Layout/Margin.h"
#include "Layout/FlowDirection.h"
#include "Rendering/SlateLayoutTransform.h"
#include "Input/CursorReply.h"
#include "Input/Reply.h"
#include "Input/NavigationReply.h"
#include "Input/PopupMethodReply.h"
#include "Types/ISlateMetaData.h"
#include "Types/WidgetActiveTimerDelegate.h"
#include "Types/WidgetMouseEventsDelegate.h"
#include "Textures/SlateShaderResource.h"
#include "SlateGlobals.h"
#include "Types/PaintArgs.h"
#include "Types/SlateAttribute.h"
#include "Types/SlateVector2.h"
#include "FastUpdate/WidgetProxy.h"
#include "InvalidateWidgetReason.h"
#include "Widgets/SlateControlledConstruction.h"
#include "Widgets/Accessibility/SlateWidgetAccessibleTypes.h"
#include "WidgetPixelSnapping.h"
 
class FActiveTimerHandle;
class FArrangedChildren;
class FChildren;
class FPaintArgs;
class FSlateWindowElementList;
class FSlotBase;
class FWeakWidgetPath;
class FWidgetPath;
class IToolTip;
class SWidget;
struct FSlateBaseNamedArgs;
struct FSlateBrush;
struct FSlatePaintElementLists;
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Widgets Created (Per Frame)"), STAT_SlateTotalWidgetsPerFrame, STATGROUP_Slate, SLATECORE_API);
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("SWidget::Paint (Count)"), STAT_SlateNumPaintedWidgets, STATGROUP_Slate, SLATECORE_API);
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("SWidget::Tick (Count)"), STAT_SlateNumTickedWidgets, STATGROUP_Slate, SLATECORE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Execute Active Timers"), STAT_SlateExecuteActiveTimers, STATGROUP_Slate, SLATECORE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("Tick Widgets"), STAT_SlateTickWidgets, STATGROUP_Slate, SLATECORE_API);
DECLARE_CYCLE_STAT_EXTERN(TEXT("SlatePrepass"), STAT_SlatePrepass, STATGROUP_Slate, SLATECORE_API);
 
#if !UE_BUILD_SHIPPING && !UE_BUILD_TEST
DECLARE_CYCLE_STAT_EXTERN(TEXT("SWidget MetaData"), STAT_SlateGetMetaData, STATGROUP_Slate, SLATECORE_API);
#endif
 
DECLARE_DWORD_ACCUMULATOR_STAT_EXTERN(TEXT("Total Widgets"), STAT_SlateTotalWidgets, STATGROUP_SlateMemory, SLATECORE_API);
DECLARE_MEMORY_STAT_EXTERN(TEXT("SWidget Total Allocated Size"), STAT_SlateSWidgetAllocSize, STATGROUP_SlateMemory, SLATECORE_API);
 
 
template <typename WidgetType>
struct TWidgetTypeTraits
{
    static constexpr bool SupportsInvalidation() { return false; }
};
 
 
enum class EAccessibleType : uint8
{
    Main,
    Summary
};
 
 
class FPopupLayer : public TSharedFromThis<FPopupLayer>
{
public:
    FPopupLayer(const TSharedRef<SWidget>& InitHostWidget, const TSharedRef<SWidget>& InitPopupContent)
        : HostWidget(InitHostWidget)
        , PopupContent(InitPopupContent)
    {
    }
 
    virtual ~FPopupLayer() { }
    
    virtual TSharedRef<SWidget> GetHost() { return HostWidget; }
    virtual TSharedRef<SWidget> GetContent() { return PopupContent; }
    virtual FSlateRect GetAbsoluteClientRect() = 0;
 
    virtual void Remove() = 0;
 
private:
    TSharedRef<SWidget> HostWidget;
    TSharedRef<SWidget> PopupContent;
};
 
 
template<typename TargetValueType, typename SourceValueType>
static bool SetWidgetAttribute(SWidget& ThisWidget, TAttribute<TargetValueType>& TargetValue, const TAttribute<SourceValueType>& SourceValue, EInvalidateWidgetReason BaseInvalidationReason);
 
class IToolTip;
 
class SWidget
    : public FSlateControlledConstruction,
    public TSharedFromThis<SWidget>     // Enables 'this->AsShared()'
{
    SLATE_DECLARE_WIDGET_API(SWidget, FSlateControlledConstruction, SLATECORE_API)
 
    friend class FWidgetProxy;
    friend class FSlateAttributeMetaData;
    friend class FSlateInvalidationRoot;
    friend class FSlateInvalidationWidgetList;
    friend class FSlateWindowElementList;
    friend class SWindow;
    friend class FSlateTrace;
    friend struct FSlateCachedElementList;
    template<class WidgetType, typename RequiredArgsPayloadType>
    friend struct TSlateDecl;
 
protected:
    template<typename InObjectType, EInvalidateWidgetReason InInvalidationReasonValue = EInvalidateWidgetReason::None, typename InComparePredicate = TSlateAttributeComparePredicate<>>
    struct TSlateAttribute : public ::SlateAttributePrivate::TSlateMemberAttribute<
        InObjectType,
        typename std::conditional<InInvalidationReasonValue == EInvalidateWidgetReason::None, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeInvalidationReason<InInvalidationReasonValue>>::type,
        InComparePredicate>
    {
        using ::SlateAttributePrivate::TSlateMemberAttribute<
            InObjectType,
            typename std::conditional<InInvalidationReasonValue == EInvalidateWidgetReason::None, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeInvalidationReason<InInvalidationReasonValue>>::type,
            InComparePredicate>::TSlateMemberAttribute;
    };
 
    //~ Override for FText that use the TSlateAttributeFTextComparePredicate to compare FText
    template<>
    struct TSlateAttribute<FText, EInvalidateWidgetReason::None> : public ::SlateAttributePrivate::TSlateMemberAttribute<FText, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeFTextComparePredicate>
    {
        using ::SlateAttributePrivate::TSlateMemberAttribute<FText, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeFTextComparePredicate>::TSlateMemberAttribute;
    };
 
    //~ Override for FText that use the TSlateAttributeFTextComparePredicate to compare FText
    template<EInvalidateWidgetReason InInvalidationReasonValue>
    struct TSlateAttribute<FText, InInvalidationReasonValue> : public ::SlateAttributePrivate::TSlateMemberAttribute<
        FText,
        typename std::conditional<InInvalidationReasonValue == EInvalidateWidgetReason::None, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeInvalidationReason<InInvalidationReasonValue>>::type,
        TSlateAttributeFTextComparePredicate>
    {
        using ::SlateAttributePrivate::TSlateMemberAttribute<
            FText,
            typename std::conditional<InInvalidationReasonValue == EInvalidateWidgetReason::None, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeInvalidationReason<InInvalidationReasonValue>>::type,
            TSlateAttributeFTextComparePredicate>::TSlateMemberAttribute;
    };
 
    template<typename InObjectType, EInvalidateWidgetReason InInvalidationReasonValue = EInvalidateWidgetReason::None, typename InComparePredicate = TSlateAttributeComparePredicate<>>
    struct TSlateManagedAttribute : public ::SlateAttributePrivate::TSlateManagedAttribute<
        InObjectType,
        typename std::conditional<InInvalidationReasonValue == EInvalidateWidgetReason::None, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeInvalidationReason<InInvalidationReasonValue>>::type,
        InComparePredicate>
    {
        using ::SlateAttributePrivate::TSlateManagedAttribute<
            InObjectType,
            typename std::conditional<InInvalidationReasonValue == EInvalidateWidgetReason::None, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeInvalidationReason<InInvalidationReasonValue>>::type,
            InComparePredicate>::TSlateManagedAttribute;
    };
 
    //~ Override for FText that use the TSlateAttributeFTextComparePredicate to compare FText
    template<>
    struct TSlateManagedAttribute<FText, EInvalidateWidgetReason::None> : public ::SlateAttributePrivate::TSlateManagedAttribute<FText, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeFTextComparePredicate>
    {
        using ::SlateAttributePrivate::TSlateManagedAttribute<FText, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeFTextComparePredicate>::TSlateManagedAttribute;
    };
 
    //~ Override for FText that use the TSlateAttributeFTextComparePredicate to compare FText
    template<EInvalidateWidgetReason InInvalidationReasonValue>
    struct TSlateManagedAttribute<FText, InInvalidationReasonValue> : public ::SlateAttributePrivate::TSlateManagedAttribute<
        FText,
        typename std::conditional<InInvalidationReasonValue == EInvalidateWidgetReason::None, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeInvalidationReason<InInvalidationReasonValue>>::type,
        TSlateAttributeFTextComparePredicate>
    {
        using ::SlateAttributePrivate::TSlateManagedAttribute<
            FText,
            typename std::conditional<InInvalidationReasonValue == EInvalidateWidgetReason::None, ::SlateAttributePrivate::FSlateAttributeNoInvalidationReason, TSlateAttributeInvalidationReason<InInvalidationReasonValue>>::type,
            TSlateAttributeFTextComparePredicate>::TSlateManagedAttribute;
    };
 
    template<typename InObjectType, EInvalidateWidgetReason InInvalidationReasonValue = EInvalidateWidgetReason::None, typename InComparePredicate = TSlateAttributeComparePredicate<>>
    struct TSlateAttributeRef : public ::SlateAttributePrivate::TSlateMemberAttributeRef<TSlateAttribute<InObjectType, InInvalidationReasonValue, InComparePredicate>>
    {
        using ::SlateAttributePrivate::TSlateMemberAttributeRef<TSlateAttribute<InObjectType, InInvalidationReasonValue, InComparePredicate>>::TSlateMemberAttributeRef;
    };
 
    //~ Override for FText that use the TSlateAttributeFTextComparePredicate to compare FText
    template<>
    struct TSlateAttributeRef<FText, EInvalidateWidgetReason::None> : public ::SlateAttributePrivate::TSlateMemberAttributeRef<TSlateAttribute<FText>>
    {
        using ::SlateAttributePrivate::TSlateMemberAttributeRef<TSlateAttribute<FText>>::TSlateMemberAttributeRef;
    };
 
    //~ Override for FText that use the TSlateAttributeFTextComparePredicate to compare FText
    template<EInvalidateWidgetReason InInvalidationReasonValue>
    struct TSlateAttributeRef<FText, InInvalidationReasonValue> : public ::SlateAttributePrivate::TSlateMemberAttributeRef<TSlateAttribute<FText, InInvalidationReasonValue>>
    {
        using ::SlateAttributePrivate::TSlateMemberAttributeRef<TSlateAttribute<FText, InInvalidationReasonValue>>::TSlateMemberAttributeRef;
    };
 
public:
    //
    // GENERAL EVENTS
    //
 
    SLATECORE_API int32 Paint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const;
 
    SLATECORE_API virtual void Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime);
 
    //
    // KEY INPUT
    //
 
    SLATECORE_API virtual FReply OnFocusReceived(const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent);
 
    SLATECORE_API virtual void OnFocusLost(const FFocusEvent& InFocusEvent);
 
    SLATECORE_API virtual void OnFocusChanging(const FWeakWidgetPath& PreviousFocusPath, const FWidgetPath& NewWidgetPath, const FFocusEvent& InFocusEvent);
 
    SLATECORE_API virtual FReply OnKeyChar(const FGeometry& MyGeometry, const FCharacterEvent& InCharacterEvent);
 
    SLATECORE_API virtual FReply OnPreviewKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent);
 
    SLATECORE_API virtual FReply OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent);
 
    SLATECORE_API virtual FReply OnKeyUp(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent);
 
    SLATECORE_API virtual FReply OnAnalogValueChanged(const FGeometry& MyGeometry, const FAnalogInputEvent& InAnalogInputEvent);
 
    //
    // MOUSE INPUT
    //
 
    SLATECORE_API virtual FReply OnMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
 
    SLATECORE_API virtual FReply OnPreviewMouseButtonDown(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
 
    SLATECORE_API virtual FReply OnMouseButtonUp(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
 
    SLATECORE_API virtual FReply OnMouseMove(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
 
    SLATECORE_API virtual void OnMouseEnter(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
 
    SLATECORE_API virtual void OnMouseLeave(const FPointerEvent& MouseEvent);
 
    SLATECORE_API virtual FReply OnMouseWheel(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
 
    SLATECORE_API virtual FCursorReply OnCursorQuery(const FGeometry& MyGeometry, const FPointerEvent& CursorEvent) const;
 
    SLATECORE_API virtual TOptional<TSharedRef<SWidget>> OnMapCursor(const FCursorReply& CursorReply) const;
 
    SLATECORE_API virtual FReply OnMouseButtonDoubleClick(const FGeometry& InMyGeometry, const FPointerEvent& InMouseEvent);
 
    SLATECORE_API virtual bool OnVisualizeTooltip(const TSharedPtr<SWidget>& TooltipContent);
 
    SLATECORE_API virtual TSharedPtr<FPopupLayer> OnVisualizePopup(const TSharedRef<SWidget>& PopupContent);
 
    SLATECORE_API virtual FReply OnDragDetected(const FGeometry& MyGeometry, const FPointerEvent& MouseEvent);
 
    //
    // DRAG AND DROP (DragDrop)
    //
 
    SLATECORE_API virtual void OnDragEnter(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent);
 
    SLATECORE_API virtual void OnDragLeave(const FDragDropEvent& DragDropEvent);
 
    SLATECORE_API virtual FReply OnDragOver(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent);
 
    SLATECORE_API virtual FReply OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent);
 
    //
    // TOUCH and GESTURES
    //
 
    SLATECORE_API virtual FReply OnTouchGesture(const FGeometry& MyGeometry, const FPointerEvent& GestureEvent);
 
    SLATECORE_API virtual FReply OnTouchStarted(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent);
 
    SLATECORE_API virtual FReply OnTouchMoved(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent);
 
    SLATECORE_API virtual FReply OnTouchEnded(const FGeometry& MyGeometry, const FPointerEvent& InTouchEvent);
 
    SLATECORE_API virtual FReply OnTouchForceChanged(const FGeometry& MyGeometry, const FPointerEvent& TouchEvent);
 
    SLATECORE_API virtual FReply OnTouchFirstMove(const FGeometry& MyGeometry, const FPointerEvent& TouchEvent);
 
    SLATECORE_API virtual FReply OnMotionDetected(const FGeometry& MyGeometry, const FMotionEvent& InMotionEvent);
 
    SLATECORE_API virtual TOptional<bool> OnQueryShowFocus(const EFocusCause InFocusCause) const;
 
    SLATECORE_API virtual FPopupMethodReply OnQueryPopupMethod() const;
 
    SLATECORE_API virtual TOptional<FVirtualPointerPosition> TranslateMouseCoordinateForCustomHitTestChild(const SWidget& ChildWidget, const FGeometry& MyGeometry, const FVector2D ScreenSpaceMouseCoordinate, const FVector2D LastScreenSpaceMouseCoordinate) const;
 
    SLATECORE_API virtual void OnFinishedPointerInput();
 
    SLATECORE_API virtual void OnFinishedKeyInput();
 
    SLATECORE_API virtual FNavigationReply OnNavigation(const FGeometry& MyGeometry, const FNavigationEvent& InNavigationEvent);
 
    SLATECORE_API virtual EWindowZone::Type GetWindowZoneOverride() const;
 
#if WITH_ACCESSIBILITY
    SLATECORE_API virtual TSharedRef<class FSlateAccessibleWidget> CreateAccessibleWidget();
#endif
 
public:
    //  
    // LAYOUT
    //
 
    bool NeedsPrepass() const { return bNeedsPrepass; }
    //UE_DEPRECATED(4.20, "SlatePrepass requires a layout scale to be accurate.")
    SLATECORE_API void SlatePrepass();
 
    SLATECORE_API void SlatePrepass(float InLayoutScaleMultiplier);
 
    void SetCanTick(bool bInCanTick) { bInCanTick ? AddUpdateFlags(EWidgetUpdateFlags::NeedsTick) : RemoveUpdateFlags(EWidgetUpdateFlags::NeedsTick); }
    bool GetCanTick() const { return HasAnyUpdateFlags(EWidgetUpdateFlags::NeedsTick); }
 
    bool HasRegisteredSlateAttribute() const { return bHasRegisteredSlateAttribute; }
    bool IsAttributesUpdatesEnabled() const { return bEnabledAttributesUpdate; }
 
    const FSlateWidgetPersistentState& GetPersistentState() const { return PersistentState; }
    const FWidgetProxyHandle GetProxyHandle() const { return FastPathProxyHandle; }
 
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetDesiredSize() const;
 
    SLATECORE_API void AssignParentWidget(TSharedPtr<SWidget> InParent);
    SLATECORE_API bool ConditionallyDetatchParentWidget(SWidget* InExpectedParent);
 
    virtual bool ValidatePathToChild(SWidget* InChild) { return true; }
 
    inline bool IsParentValid() const { return ParentWidgetPtr.IsValid(); }
    inline TSharedPtr<SWidget> GetParentWidget() const { return ParentWidgetPtr.Pin(); }
 
    inline TSharedPtr<SWidget> Advanced_GetPaintParentWidget() const { return PersistentState.PaintParent.Pin(); }
 
    SLATECORE_API FSlateRect CalculateCullingAndClippingRules(const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, bool& bClipToBounds, bool& bAlwaysClip, bool& bIntersectClipBounds) const;
 
    bool HasAnyUpdateFlags(EWidgetUpdateFlags FlagsToCheck) const
    {
        return EnumHasAnyFlags(UpdateFlags, FlagsToCheck);
    }
 
protected:
    void SetVolatilePrepass(bool bVolatile) { bVolatile ? AddUpdateFlags(EWidgetUpdateFlags::NeedsVolatilePrepass) : RemoveUpdateFlags(EWidgetUpdateFlags::NeedsVolatilePrepass); }
 
    virtual bool CustomPrepass(float LayoutScaleMultiplier) { return false; }
 
    SLATECORE_API virtual void CacheDesiredSize(float InLayoutScaleMultiplier);
 
    virtual FVector2D ComputeDesiredSize(float LayoutScaleMultiplier) const = 0;
 
 
private:
    void SetFastPathProxyHandle(const FWidgetProxyHandle& Handle) { FastPathProxyHandle = Handle; }
    SLATECORE_API void SetFastPathProxyHandle(const FWidgetProxyHandle& Handle, FSlateInvalidationWidgetVisibility Visibility, bool bParentVolatile);
    SLATECORE_API void SetFastPathSortOrder(const FSlateInvalidationWidgetSortOrder SortOrder);
 
    SLATECORE_API void UpdateFastPathVisibility(FSlateInvalidationWidgetVisibility ParentVisibility, FHittestGrid* ParentHittestGrid);
    SLATECORE_API void UpdateFastPathWidgetRemoved(FHittestGrid* ParentHittestGrid);
    SLATECORE_API void UpdateFastPathVolatility(bool bParentVolatile);
 
    void SetDesiredSize(const FVector2D& InDesiredSize)
    {
        DesiredSize = FVector2f(InDesiredSize);
        bDesiredSizeSet = true;
    }
 
#if STATS || ENABLE_STATNAMEDEVENTS
    SLATECORE_API void CreateStatID() const;
#endif
 
    void AddUpdateFlags(EWidgetUpdateFlags FlagsToAdd)
    {
        EWidgetUpdateFlags Previous = UpdateFlags;
        UpdateFlags |= FlagsToAdd;
        FastPathProxyHandle.UpdateWidgetFlags(this, Previous, UpdateFlags);
    }
 
    void RemoveUpdateFlags(EWidgetUpdateFlags FlagsToRemove)
    {
        EWidgetUpdateFlags Previous = UpdateFlags;
        UpdateFlags &= (~FlagsToRemove);
        FastPathProxyHandle.UpdateWidgetFlags(this, Previous, UpdateFlags);
    }
 
    SLATECORE_API void UpdateWidgetProxy(int32 NewLayerId, FSlateCachedElementsHandle& CacheHandle);
 
public:
#if UE_SLATE_TRACE_ENABLED
    uint8 Debug_GetWidgetInfoTraced() const 
    { 
        return Debug_LastTraceInfoSent; 
    }
 
    void Debug_SetWidgetInfoTraced(uint8 InDebug_LastTraceInfoSent) const 
    { 
        Debug_LastTraceInfoSent = InDebug_LastTraceInfoSent; 
    }
#endif // UE_SLATE_TRACE_ENABLED
 
#if WITH_SLATE_DEBUGGING
    uint32 Debug_GetLastPaintFrame() const 
    { 
        return LastPaintFrame; 
    }
    uint32 Debug_GetLastPrepassFrame() const 
    { 
        return LastPrepassFrame; 
    }
private:
    void Debug_UpdateLastPaintFrame() 
    { 
        LastPaintFrame = GFrameNumber; 
    }
    void Debug_UpdateLastPrepassFrame() 
    { 
        LastPrepassFrame = GFrameNumber; 
    }
#endif // WITH_SLATE_DEBUGGING
 
public:
 
    inline TStatId GetStatID(bool bForDeferredUse = false) const
    {
#if STATS
        // this is done to avoid even registering stats for a disabled group (unless we plan on using it later)
        if (bForDeferredUse || FThreadStats::IsCollectingData())
        {
            if (!StatID.IsValidStat())
            {
                CreateStatID();
            }
            return StatID;
        }
        return TStatId(); // not doing stats at the moment, or ever
#elif ENABLE_STATNAMEDEVENTS
        if (!StatID.IsValidStat() && (bForDeferredUse || GCycleStatsShouldEmitNamedEvents))
        {
            CreateStatID();
        }
        return StatID;
#else
        return TStatId(); // not doing stats at the moment, or ever
#endif
    }
 
    SLATECORE_API virtual float GetRelativeLayoutScale(const int32 ChildIndex, float LayoutScaleMultiplier) const;
 
    SLATECORE_API void ArrangeChildren(const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren, bool bUpdateAttributes = false) const;
 
    virtual FChildren* GetChildren() = 0;
 
    virtual FChildren* GetAllChildren() { return GetChildren(); }
 
#if WITH_SLATE_DEBUGGING
    virtual FChildren* Debug_GetChildrenForReflector() { return GetAllChildren(); }
#endif
 
    SLATECORE_API virtual bool SupportsKeyboardFocus() const;
 
    SLATECORE_API virtual bool HasKeyboardFocus() const;
 
    SLATECORE_API TOptional<EFocusCause> HasUserFocus(int32 UserIndex) const;
 
    SLATECORE_API TOptional<EFocusCause> HasAnyUserFocus() const;
 
    SLATECORE_API bool HasUserFocusedDescendants(int32 UserIndex) const;
 
    SLATECORE_API bool HasFocusedDescendants() const;
 
    SLATECORE_API bool HasAnyUserFocusOrFocusedDescendants() const;
 
    SLATECORE_API bool HasMouseCapture() const;
 
    SLATECORE_API bool HasMouseCaptureByUser(int32 UserIndex, TOptional<int32> PointerIndex = TOptional<int32>()) const;
 
public:
    SLATECORE_API virtual void OnMouseCaptureLost(const FCaptureLostEvent& CaptureLostEvent);
 
    void SetEnabled(TAttribute<bool> InEnabledState)
    {
        EnabledStateAttribute.Assign(*this, MoveTemp(InEnabledState));
    }
 
    inline bool IsEnabled() const
    {
        return EnabledStateAttribute.Get();
    }
 
    virtual bool IsInteractable() const
    {
        return false;
    }
 
    SLATECORE_API virtual TSharedPtr<IToolTip> GetToolTip();
 
    SLATECORE_API virtual void OnToolTipClosing();
 
    SLATECORE_API void EnableToolTipForceField(const bool bEnableForceField);
 
    bool HasToolTipForceField() const
    {
        return bToolTipForceFieldEnabled;
    }
 
    bool IsHovered() const
    {
        return HoveredAttribute.Get();
    }
 
    SLATECORE_API bool IsDirectlyHovered() const;
 
protected:
    void SetHover(TAttribute<bool> InHovered)
    {
        bIsHoveredAttributeSet = InHovered.IsSet();
        HoveredAttribute.Assign(*this, MoveTemp(InHovered));
    }
 
public:
 
    inline EVisibility GetVisibility() const { return VisibilityAttribute.Get(); }
 
    SLATECORE_API virtual void SetVisibility(TAttribute<EVisibility> InVisibility);
 
#if WITH_ACCESSIBILITY
    SLATECORE_API FText GetAccessibleText(EAccessibleType AccessibleType = EAccessibleType::Main) const;
 
    SLATECORE_API FText GetAccessibleSummary() const;
 
    SLATECORE_API bool IsAccessible() const;
 
    SLATECORE_API EAccessibleBehavior GetAccessibleBehavior(EAccessibleType AccessibleType = EAccessibleType::Main) const;
 
    SLATECORE_API bool CanChildrenBeAccessible() const;
 
    SLATECORE_API void SetAccessibleBehavior(EAccessibleBehavior InBehavior, const TAttribute<FText>& InText = TAttribute<FText>(), EAccessibleType AccessibleType = EAccessibleType::Main);
 
    SLATECORE_API void SetCanChildrenBeAccessible(bool InCanChildrenBeAccessible);
 
    SLATECORE_API virtual TOptional<FText> GetDefaultAccessibleText(EAccessibleType AccessibleType = EAccessibleType::Main) const;
#endif
 
    inline bool IsVolatile() const { return bCachedVolatile; }
 
    inline bool IsVolatileIndirectly() const { return bInheritedVolatility; }
 
    inline void ForceVolatile(bool bForce)
    {
        if (bForceVolatile != bForce)
        {
            bForceVolatile = bForce;
            Invalidate(EInvalidateWidgetReason::PaintAndVolatility);
        }
    }
 
    inline bool ShouldInvalidatePrepassDueToVolatility() { return bVolatilityAlwaysInvalidatesPrepass; }
 
    SLATECORE_API void Invalidate(EInvalidateWidgetReason InvalidateReason);
 
    inline void CacheVolatility()
    {
        bCachedVolatile = bForceVolatile || ComputeVolatility();
    }
 
    void MarkPrepassAsDirty() { bNeedsPrepass = true; }
 
protected:
 
#if SLATE_CULL_WIDGETS
    SLATECORE_API bool IsChildWidgetCulled(const FSlateRect& MyCullingRect, const FArrangedWidget& ArrangedChild) const;
#else
    inline bool IsChildWidgetCulled(const FSlateRect&, const FArrangedWidget&) const { return false; }
#endif
 
protected:
 
 
    SLATECORE_API void InvalidateChildRemovedFromTree(SWidget& Child);
 
    inline bool Advanced_InvalidateVolatility()
    {
        const bool bWasDirectlyVolatile = IsVolatile();
        CacheVolatility();
        return bWasDirectlyVolatile != IsVolatile();
    }
public:
 
    inline float GetRenderOpacity() const
    {
        return RenderOpacity;
    }
 
    inline void SetRenderOpacity(float InRenderOpacity)
    {
        if(RenderOpacity != InRenderOpacity)
        {
            RenderOpacity = InRenderOpacity;
            Invalidate(EInvalidateWidgetReason::Paint);
        }
    }
 
    inline void SetTag(FName InTag)
    {
        Tag = InTag;
    }
 
    inline const TOptional<FSlateRenderTransform>& GetRenderTransform() const
    {
        return RenderTransformAttribute.Get();
    }
 
    inline TOptional<FSlateRenderTransform> GetRenderTransformWithRespectToFlowDirection() const
    {
        if (LIKELY(GSlateFlowDirection == EFlowDirection::LeftToRight))
        {
            return RenderTransformAttribute.Get();
        }
        else
        {
            // If we're going right to left, flip the X translation on render transforms.
            TOptional<FSlateRenderTransform> Transform = RenderTransformAttribute.Get();
            if (Transform.IsSet())
            {
                FVector2D Translation = Transform.GetValue().GetTranslation();
                Transform.GetValue().SetTranslation(FVector2D(-Translation.X, Translation.Y));
            }
            return Transform;
        }
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetRenderTransformPivotWithRespectToFlowDirection() const
    {
        FVector2f TransformPivot = UE::Slate::CastToVector2f(RenderTransformPivotAttribute.Get());
        if (LIKELY(GSlateFlowDirection == EFlowDirection::LeftToRight))
        {
            return TransformPivot;
        }
        else
        {
            // If we're going right to left, flip the X's pivot mirrored about 0.5.
            TransformPivot.X = 0.5f + (0.5f - TransformPivot.X);
            return TransformPivot;
        }
    }
 
    inline void SetRenderTransform(TAttribute<TOptional<FSlateRenderTransform>> InTransform)
    {
        RenderTransformAttribute.Assign(*this, MoveTemp(InTransform));
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetRenderTransformPivot() const
    {
        FVector2f TransformPivot = UE::Slate::CastToVector2f(RenderTransformPivotAttribute.Get());
        return TransformPivot;
    }
 
    inline void SetRenderTransformPivot(TAttribute<FVector2D> InTransformPivot)
    {
        RenderTransformPivotAttribute.Assign(*this, MoveTemp(InTransformPivot));
    }
 
    SLATECORE_API void SetClipping(EWidgetClipping InClipping);
 
    inline EWidgetClipping GetClipping() const
    {
        return Clipping;
    }
    
    SLATECORE_API void SetPixelSnapping(EWidgetPixelSnapping InPixelSnappingMethod);
 
    inline EWidgetPixelSnapping GetPixelSnapping() const
    {
        return PixelSnappingMethod;
    }
 
    inline void SetCullingBoundsExtension(const FMargin& InCullingBoundsExtension)
    {
        if (CullingBoundsExtension != InCullingBoundsExtension)
        {
            CullingBoundsExtension = InCullingBoundsExtension;
            // @todo - Fast path should this be Paint?
            Invalidate(EInvalidateWidgetReason::Layout);
        }
    }
 
    inline FMargin GetCullingBoundsExtension() const
    {
        return CullingBoundsExtension;
    }
 
    void SetFlowDirectionPreference(EFlowDirectionPreference InFlowDirectionPreference)
    {
        if (FlowDirectionPreference != InFlowDirectionPreference)
        {
            FlowDirectionPreference = InFlowDirectionPreference;
            Invalidate(EInvalidateWidgetReason::Paint);
        }
    }
 
    EFlowDirectionPreference GetFlowDirectionPreference() const
    {
        return FlowDirectionPreference;
    }
 
protected:
    EFlowDirection ComputeFlowDirection() const
    {
        switch (FlowDirectionPreference)
        {
        case EFlowDirectionPreference::Culture:
            return FLayoutLocalization::GetLocalizedLayoutDirection();
        case EFlowDirectionPreference::LeftToRight:
            return EFlowDirection::LeftToRight;
        case EFlowDirectionPreference::RightToLeft:
            return EFlowDirection::RightToLeft;
        }
 
        return GSlateFlowDirection;
    }
 
public:
    SLATECORE_API void SetToolTipText(const TAttribute<FText>& ToolTipText);
 
    SLATECORE_API void SetToolTipText( const FText& InToolTipText );
 
    SLATECORE_API void SetToolTip(const TAttribute<TSharedPtr<IToolTip>>& InToolTip);
 
    SLATECORE_API void SetCursor( const TAttribute< TOptional<EMouseCursor::Type> >& InCursor );
 
protected:
 
    SLATECORE_API void SetDebugInfo( const ANSICHAR* InType, const ANSICHAR* InFile, int32 OnLine, size_t InAllocSize );
 
    SLATECORE_API virtual TOptional<EMouseCursor::Type> GetCursor() const;
 
public:
    template<typename MetaDataType>
    TSharedPtr<MetaDataType> GetMetaData() const
    {
#if !UE_BUILD_SHIPPING && !UE_BUILD_TEST
        SCOPE_CYCLE_COUNTER(STAT_SlateGetMetaData);
#endif
        for (const auto& MetaDataEntry : MetaData)
        {
            if (MetaDataEntry->IsOfType<MetaDataType>())
            {
                return StaticCastSharedRef<MetaDataType>(MetaDataEntry);
            }
        }
        return TSharedPtr<MetaDataType>();  
    }
 
    template<typename MetaDataType>
    TArray<TSharedRef<MetaDataType>> GetAllMetaData() const
    {
#if !UE_BUILD_SHIPPING && !UE_BUILD_TEST
        SCOPE_CYCLE_COUNTER(STAT_SlateGetMetaData);
#endif
        TArray<TSharedRef<MetaDataType>> FoundMetaData;
        for (const auto& MetaDataEntry : MetaData)
        {
            if (MetaDataEntry->IsOfType<MetaDataType>())
            {
                FoundMetaData.Add(StaticCastSharedRef<MetaDataType>(MetaDataEntry));
            }
        }
        return FoundMetaData;
    }
 
    template<typename MetaDataType>
    void AddMetadata(const TSharedRef<MetaDataType>& AddMe)
    {
        AddMetadataInternal(AddMe);
    }
 
    template<typename MetaDataType>
    int32 RemoveMetaData(const TSharedRef<MetaDataType>& RemoveMe)
    {
        int32 Index = MetaData.Find(RemoveMe);
        if (Index == INDEX_NONE)
        {
            return 0;
        }
 
        checkf(Index != 0 || !HasRegisteredSlateAttribute(), TEXT("The first slot is reserved for SlateAttribute"));
        MetaData.RemoveAtSwap(Index, 1);
        return 1;
    }
 
private:
 
    SLATECORE_API void AddMetadataInternal(const TSharedRef<ISlateMetaData>& AddMe);
 
    template<typename MetaDataType>
    int32 RemoveAllMetaData()
    {
        int32 NumBefore = MetaData.Num();
        for (int32 Index = NumBefore - 1; Index >= 0; --Index)
        {
            const auto& MetaDataEntry = MetaData[Index];
            if (MetaDataEntry->IsOfType<MetaDataType>())
            {
                checkf(Index != 0 || !HasRegisteredSlateAttribute(), TEXT("The first slot is reserved for SlateAttribute"));
                MetaData.RemoveAtSwap(Index);
            }
        }
        return NumBefore - MetaData.Num();
    }
 
    template<typename MetaDataType>
    bool RemoveMetaData()
    {
        for (int32 Index = MetaData.Num() - 1; Index >= 0; --Index)
        {
            const auto& MetaDataEntry = MetaData[Index];
            if (MetaDataEntry->IsOfType<MetaDataType>())
            {
                checkf(Index != 0 || !HasRegisteredSlateAttribute(), TEXT("The first slot is reserved for SlateAttribute"));
                MetaData.RemoveAtSwap(Index);
                return true;
            }
        }
        return false;
    }
 
public:
 
    SLATECORE_API void SetOnMouseButtonDown(FPointerEventHandler EventHandler);
 
    SLATECORE_API void SetOnMouseButtonUp(FPointerEventHandler EventHandler);
 
    SLATECORE_API void SetOnMouseMove(FPointerEventHandler EventHandler);
 
    SLATECORE_API void SetOnMouseDoubleClick(FPointerEventHandler EventHandler);
 
    SLATECORE_API void SetOnMouseEnter(FNoReplyPointerEventHandler EventHandler);
 
    SLATECORE_API void SetOnMouseLeave(FSimpleNoReplyPointerEventHandler EventHandler);
 
public:
 
    // Widget Inspector and debugging methods
 
    SLATECORE_API virtual FString ToString() const;
 
    SLATECORE_API FString GetTypeAsString() const;
 
    SLATECORE_API FName GetType() const;
 
    SLATECORE_API virtual FString GetReadableLocation() const;
 
    SLATECORE_API FName GetCreatedInLocation() const;
 
    SLATECORE_API virtual FName GetTag() const;
 
#if STATS
    size_t GetAllocSize() const { return AllocSize; }
#endif
 
#if UE_SLATE_WITH_WIDGET_UNIQUE_IDENTIFIER
    uint64 GetId() const { return UniqueIdentifier; }
#endif
 
    SLATECORE_API virtual FSlateColor GetForegroundColor() const;
 
    SLATECORE_API virtual FSlateColor GetDisabledForegroundColor() const;
 
    //UE_DEPRECATED(4.23, "GetCachedGeometry has been deprecated, use GetTickSpaceGeometry instead")
    SLATECORE_API const FGeometry& GetCachedGeometry() const;
 
    SLATECORE_API const FGeometry& GetTickSpaceGeometry() const;
 
    SLATECORE_API const FGeometry& GetPaintSpaceGeometry() const;
 
    const TOptional<FSlateClippingState>& GetCurrentClippingState() const { return PersistentState.InitialClipState; }
 
    virtual bool Advanced_IsWindow() const { return false; }
    virtual bool Advanced_IsInvalidationRoot() const { return false; }
    virtual const FSlateInvalidationRoot* Advanced_AsInvalidationRoot() const { return nullptr; }
 
 
#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
 
    SLATECORE_API bool SupportsInvalidation() const;
 
    SLATECORE_API virtual bool SupportsInvalidationRecursive(bool bUseCachedValue = true) const;
private:
    SLATECORE_API void SetSelfAndParentAsNotSupportingInvalidationRecursive();
;
    mutable bool CachedSupportsInvalidationRecursive = false;
#endif
 
protected:
    SLATECORE_API SWidget();
 
    SLATECORE_API void SWidgetConstruct(const FSlateBaseNamedArgs& Args);
 
    bool IsConstructed() const { return bIsDeclarativeSyntaxConstructionCompleted; }
 
    SLATECORE_API bool FindChildGeometries( const FGeometry& MyGeometry, const TSet< TSharedRef<SWidget> >& WidgetsToFind, TMap<TSharedRef<SWidget>, FArrangedWidget>& OutResult ) const;
 
    SLATECORE_API void FindChildGeometries_Helper( const FGeometry& MyGeometry, const TSet< TSharedRef<SWidget> >& WidgetsToFind, TMap<TSharedRef<SWidget>, FArrangedWidget>& OutResult ) const;
 
    SLATECORE_API FGeometry FindChildGeometry( const FGeometry& MyGeometry, TSharedRef<SWidget> WidgetToFind ) const;
 
    static SLATECORE_API int32 FindChildUnderMouse( const FArrangedChildren& Children, const FPointerEvent& MouseEvent );
 
    static SLATECORE_API int32 FindChildUnderPosition(const FArrangedChildren& Children, const UE::Slate::FDeprecateVector2DParameter& ArrangedSpacePosition);
 
    bool ShouldBeEnabled( bool InParentEnabled ) const
    {
        // This widget should be enabled if its parent is enabled and it is enabled
        return InParentEnabled && IsEnabled();
    }
 
    SLATECORE_API virtual const FSlateBrush* GetFocusBrush() const;
 
    virtual bool ComputeVolatility() const { return false; }
 
    static TAttribute<EVisibility> AccessWidgetVisibilityAttribute(const TSharedRef<SWidget>& Widget)
    {
        return Widget->VisibilityAttribute.ToAttribute(Widget.Get());
    }
 
    SLATECORE_API virtual void OnClippingChanged();
 
private:
 
    virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const = 0;
 
    virtual void OnArrangeChildren(const FGeometry& AllottedGeometry, FArrangedChildren& ArrangedChildren) const = 0;
 
    SLATECORE_API void Prepass_Internal(float LayoutScaleMultiplier);
 
protected:
    float GetPrepassLayoutScaleMultiplier() const
    {
        return bPrepassLayoutScaleMultiplierSet ? PrepassLayoutScaleMultiplierValue : 1.0f;
    }
    
    SLATECORE_API void Prepass_ChildLoop(float InLayoutScaleMultiplier, FChildren* MyChildren);
 
public:
    SLATECORE_API TSharedRef<FActiveTimerHandle> RegisterActiveTimer( float TickPeriod, FWidgetActiveTimerDelegate TickFunction );
 
    SLATECORE_API void UnRegisterActiveTimer( const TSharedRef<FActiveTimerHandle>& ActiveTimerHandle );
    
    bool HasActiveTimers() const
    {
        return bHasActiveTimers;
    }
 
private:
 
    SLATECORE_API void ExecuteActiveTimers(double CurrentTime, float DeltaTime);
 
protected:
    template<typename TargetValueType, typename SourceValueType>
    bool SetAttribute(TAttribute<TargetValueType>& TargetValue, const TAttribute<SourceValueType>& SourceValue, EInvalidateWidgetReason BaseInvalidationReason)
    {
        return SetWidgetAttribute(*this, TargetValue, SourceValue, BaseInvalidationReason);
    }
 
    TSlateAttributeRef<bool> GetEnabledStateAttribute() const { return TSlateAttributeRef<bool>(SharedThis(this), EnabledStateAttribute); }
    TSlateAttributeRef<bool> GetHoveredAttribute() const { return TSlateAttributeRef<bool>(SharedThis(this), HoveredAttribute); }
    TSlateAttributeRef<EVisibility> GetVisibilityAttribute() const { return TSlateAttributeRef<EVisibility>(SharedThis(this), VisibilityAttribute); }
    TSlateAttributeRef<TOptional<FSlateRenderTransform>> GetRenderTransformAttribute() const { return TSlateAttributeRef<TOptional<FSlateRenderTransform>>(SharedThis(this), RenderTransformAttribute); }
    TSlateAttributeRef<FVector2D> GetRenderTransformPivotAttribute() const { return TSlateAttributeRef<FVector2D>(SharedThis(this), RenderTransformPivotAttribute); }
 
protected:
    SLATECORE_API virtual ~SWidget();
 
private:
    mutable FWidgetProxyHandle FastPathProxyHandle;
 
protected:
    uint8 bCanSupportFocus : 1;
 
    uint8 bCanHaveChildren : 1;
 
    uint8 bClippingProxy : 1;
 
private:
    uint8 bToolTipForceFieldEnabled : 1;
 
    uint8 bForceVolatile : 1;
 
    uint8 bCachedVolatile : 1;
 
    uint8 bInheritedVolatility : 1;
 
    uint8 bNeedsPrepass : 1;
 
    uint8 bHasRegisteredSlateAttribute : 1;
 
    uint8 bEnabledAttributesUpdate : 1;
 
    uint8 bIsDeclarativeSyntaxConstructionCompleted : 1;
 
    uint8 bIsHoveredAttributeSet : 1;
 
    uint8 bHasActiveTimers : 1;
 
    uint8 bDesiredSizeSet : 1;
 
    uint8 bPrepassLayoutScaleMultiplierSet : 1;
 
#if UE_SLATE_WITH_DYNAMIC_INVALIDATION
    template<class WidgetType, typename RequiredArgsPayloadType>
    friend struct TSlateDecl;
 
    // We need to keep this information for each widget as not all widgets have a class to store this information
    uint8 bSupportsInvalidation : 1 = false;
#endif
 
protected:
    uint8 bHasCustomPrepass : 1;
 
    uint8 bHasRelativeLayoutScale : 1;
    
    uint8 bVolatilityAlwaysInvalidatesPrepass : 1;
 
#if WITH_ACCESSIBILITY
    uint8 bCanChildrenBeAccessible : 1;
    EAccessibleBehavior AccessibleBehavior;
    EAccessibleBehavior AccessibleSummaryBehavior;
#endif
 
    EWidgetClipping Clipping;
    
    EWidgetPixelSnapping PixelSnappingMethod;
 
private:
    EFlowDirectionPreference FlowDirectionPreference;
 
    EWidgetUpdateFlags UpdateFlags;
 
    TSlateAttribute<EVisibility> VisibilityAttribute;
 
    TSlateAttribute<bool> EnabledStateAttribute;
 
    TSlateAttribute<bool> HoveredAttribute;
 
    //~ See PrepassLayoutScaleMultiplier
    float PrepassLayoutScaleMultiplierValue;
 
    mutable FSlateWidgetPersistentState PersistentState;
 
    FVector2f DesiredSize;
 
    TSlateAttribute<FVector2D> RenderTransformPivotAttribute;
 
    TSlateAttribute<TOptional<FSlateRenderTransform>> RenderTransformAttribute;
 
protected:
    FMargin CullingBoundsExtension;
 
    float RenderOpacity;
 
private:
    TArray<TSharedRef<ISlateMetaData>> MetaData;
 
    TWeakPtr<SWidget> ParentWidgetPtr;
 
    FName Tag;
 
    FName TypeOfWidget;
 
protected:
#if WITH_EDITORONLY_DATA
    UE_DEPRECATED(5.5, "Direct access to PrepassLayoutScaleMultiplier is deprecated. Use the GetPrepassLayoutScaleMultiplier. The scale multitplier can only be set in the prepass.")
    TOptional<float> PrepassLayoutScaleMultiplier;
#endif
 
private: 
#if !UE_BUILD_SHIPPING
    FName CreatedInLocation;
#endif
 
#if WITH_SLATE_DEBUGGING
    uint32 LastPaintFrame = 0;
    uint32 LastPrepassFrame = 0;
    uint8 Debug_DestroyedTag = 0xDC;
#endif // WITH_SLATE_DEBUGGING
 
#if UE_SLATE_TRACE_ENABLED
    mutable uint8 Debug_LastTraceInfoSent = 0;
#endif // UE_SLATE_TRACE_ENABLED
 
#if UE_SLATE_WITH_WIDGET_UNIQUE_IDENTIFIER
    uint64 UniqueIdentifier;
#endif
 
#if STATS
    size_t AllocSize;
#endif
 
#if STATS || ENABLE_STATNAMEDEVENTS
    mutable TStatId             StatID;
#endif
 
#if ENABLE_STATNAMEDEVENTS
    mutable PROFILER_CHAR* StatIDStringStorage;
#endif
};
 
//=================================================================
// FGeometry Arranged Widget Inlined Functions
//=================================================================
 
inline FArrangedWidget FGeometry::MakeChild(const TSharedRef<SWidget>& ChildWidget, const UE::Slate::FDeprecateVector2DParameter& InLocalSize, const FSlateLayoutTransform& LayoutTransform) const
{
    // If there is no render transform set, use the simpler MakeChild call that doesn't bother concatenating the render transforms.
    // This saves a significant amount of overhead since every widget does this, and most children don't have a render transform.
    const TOptional<FSlateRenderTransform> RenderTransform = ChildWidget->GetRenderTransformWithRespectToFlowDirection();
    if (RenderTransform.IsSet() )
    {
        const FVector2f RenderTransformPivot = UE::Slate::CastToVector2f(ChildWidget->GetRenderTransformPivotWithRespectToFlowDirection());
        return FArrangedWidget(ChildWidget, MakeChild(InLocalSize, LayoutTransform, RenderTransform.GetValue(), RenderTransformPivot));
    }
    else
    {
        return FArrangedWidget(ChildWidget, MakeChild(InLocalSize, LayoutTransform));
    }
}
 
inline FArrangedWidget FGeometry::MakeChild(const TSharedRef<SWidget>& ChildWidget, const FLayoutGeometry& LayoutGeometry) const
{
    return MakeChild(ChildWidget, FVector2f(LayoutGeometry.GetSizeInLocalSpace()), LayoutGeometry.GetLocalToParentTransform());
}
 
inline FArrangedWidget FGeometry::MakeChild(const TSharedRef<SWidget>& ChildWidget, const UE::Slate::FDeprecateVector2DParameter& ChildOffset, const UE::Slate::FDeprecateVector2DParameter& InLocalSize, float ChildScale) const
{
    // Since ChildOffset is given as a LocalSpaceOffset, we MUST convert this offset into the space of the parent to construct a valid layout transform.
    // The extra TransformPoint below does this by converting the local offset to an offset in parent space.
    return MakeChild(ChildWidget, UE::Slate::CastToVector2f(InLocalSize), FSlateLayoutTransform(ChildScale, TransformPoint(ChildScale, UE::Slate::CastToVector2f(ChildOffset))));
}
 
template<typename TargetValueType, typename SourceValueType>
bool SetWidgetAttribute(SWidget& ThisWidget, 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::PaintAndVolatility;
        }
 
        ThisWidget.Invalidate(InvalidateReason);
        return true;
    }
 
    return false;
}