UserWidget.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "CoreMinimal.h"
#endif //UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_4
#include "Blueprint/UMGSequencePlayMode.h"
#include "Blueprint/WidgetChild.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectSaveContext.h"
#include "Styling/SlateColor.h"
#include "Layout/Geometry.h"
#include "Input/CursorReply.h"
#include "Input/Events.h"
#include "Input/Reply.h"
#include "Widgets/SWidget.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "Layout/Margin.h"
#include "Components/SlateWrapperTypes.h"
#include "Components/Widget.h"
#include "Components/NamedSlotInterface.h"
#include "Engine/World.h"
#include "GameFramework/PlayerController.h"
#include "Engine/LocalPlayer.h"
#include "Widgets/Layout/Anchors.h"
#include "Logging/MessageLog.h"
#include "Stats/Stats.h"
#include "EngineStats.h"
#include "SlateGlobals.h"
#include "Animation/WidgetAnimationEvents.h"
#include "Animation/WidgetAnimationHandle.h"
#include "Animation/WidgetAnimationState.h"
#include "UserWidget.generated.h"
 
class Error;
class FSlateWindowElementList;
class UDragDropOperation;
class UTexture2D;
class UUMGSequencePlayer;
class UUMGSequenceTickManager;
class UWidgetAnimation;
class UWidgetBlueprintGeneratedClass;
class UWidgetTree;
class UNamedSlot;
class UUserWidget;
class UUserWidgetExtension;
 
enum class EQueuedWidgetAnimationMode : uint8
{
    Play,
    PlayTo,
    Forward,
    Reverse,
    Stop,
    Pause,
    None,
};
 
enum class ERequiresLegacyPlayer : uint8
{
    AutoDetect,
    Yes,
    No
};
 
USTRUCT()
struct FQueuedWidgetAnimationTransition
{
    GENERATED_BODY()
 
    
    UPROPERTY(Transient)
    TObjectPtr<UWidgetAnimation> WidgetAnimation;
 
    EQueuedWidgetAnimationMode TransitionMode;
 
    TOptional<float> StartAtTime;
 
    TOptional<float> EndAtTime;
 
    TOptional<int32> NumLoopsToPlay;
 
    TOptional<EUMGSequencePlayMode::Type> PlayMode;
 
    TOptional<float> PlaybackSpeed;
 
    TOptional<bool> bRestoreState;
 
    FQueuedWidgetAnimationTransition()
        : WidgetAnimation(nullptr)
        , TransitionMode(EQueuedWidgetAnimationMode::None)
    {}
};
 
UENUM()
enum class EWidgetTickFrequency : uint8
{
    Never = 0,
 
    Auto,
};
 
UENUM(BlueprintType)
enum class EWidgetAnimationEvent : uint8
{
    Started,
    Finished
};
 
USTRUCT()
struct FAnimationEventBinding
{
    GENERATED_BODY()
 
public:
 
    FAnimationEventBinding()
        : Animation(nullptr)
        , Delegate()
        , AnimationEvent(EWidgetAnimationEvent::Started)
        , UserTag(NAME_None)
    {
    }
 
    UPROPERTY()
    TObjectPtr<UWidgetAnimation> Animation;
 
    UPROPERTY()
    FWidgetAnimationDynamicEvent Delegate;
 
    UPROPERTY()
    EWidgetAnimationEvent AnimationEvent;
 
    UPROPERTY()
    FName UserTag;
};
 
 
USTRUCT(BlueprintType)
struct FPaintContext
{
    GENERATED_USTRUCT_BODY()
 
public:
 
    UMG_API FPaintContext();
 
    FPaintContext(const FGeometry& InAllottedGeometry, const FSlateRect& InMyCullingRect, FSlateWindowElementList& InOutDrawElements, const int32 InLayerId, const FWidgetStyle& InWidgetStyle, const bool bInParentEnabled)
        : AllottedGeometry(InAllottedGeometry)
        , MyCullingRect(InMyCullingRect)
        , OutDrawElements(InOutDrawElements)
        , LayerId(InLayerId)
        , WidgetStyle(InWidgetStyle)
        , bParentEnabled(bInParentEnabled)
        , MaxLayer(InLayerId)
    {
    }
 
    void operator=( const FPaintContext& Other )
    {
        FPaintContext* Ptr = this;
        Ptr->~FPaintContext();
        new(Ptr) FPaintContext(Other.AllottedGeometry, Other.MyCullingRect, Other.OutDrawElements, Other.LayerId, Other.WidgetStyle, Other.bParentEnabled);
        Ptr->MaxLayer = Other.MaxLayer;
    }
 
public:
 
    const FGeometry& AllottedGeometry;
    const FSlateRect& MyCullingRect;
    FSlateWindowElementList& OutDrawElements;
    int32 LayerId;
    const FWidgetStyle& WidgetStyle;
    bool bParentEnabled;
 
    int32 MaxLayer;
};
 
USTRUCT()
struct FNamedSlotBinding
{
    GENERATED_USTRUCT_BODY()
 
public:
 
    FNamedSlotBinding()
        : Name(NAME_None)
        , Content(nullptr)
    { }
 
    UPROPERTY()
    FName Name;
 
#if WITH_EDITORONLY_DATA
    // GUID of the NamedSlot is used as a secondary identifier to find a binding in case the name of NamedSlot has changed.
    UPROPERTY()
    FGuid Guid;
#endif
 
    UPROPERTY(Instanced)
    TObjectPtr<UWidget> Content;
};
 
#if WITH_EDITORONLY_DATA
 
UENUM()
enum class EDesignPreviewSizeMode : uint8
{
    FillScreen,
    Custom,
    CustomOnScreen,
    Desired,
    DesiredOnScreen,
};
 
#endif
 
UCLASS()
class UUserWidgetFunctionLibrary : public UBlueprintFunctionLibrary
{
    GENERATED_BODY()
 
public:
    UFUNCTION(BlueprintPure, Category = "UMG", meta = (BlueprintAutocast, DeprecatedFunction, DeprecatedMessage="UMGSequencePlayer is deprecated, please use FWidgetAnimationState"))
    static UUMGSequencePlayer* Conv_UMGSequencePlayer(const FWidgetAnimationHandle& WidgetAnimationHandle);
 
    UFUNCTION(BlueprintPure, Category = "UMG")
    static UUserWidget* GetOuterUserWidget(const UWidget* Widget);
};
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnConstructEvent);
 
DECLARE_DYNAMIC_DELEGATE( FOnInputAction );
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnVisibilityChangedEvent, ESlateVisibility, InVisibility);
 
UCLASS(Abstract, editinlinenew, BlueprintType, Blueprintable, meta=( DontUseGenericSpawnObject="True", DisableNativeTick) , MinimalAPI)
class UUserWidget : public UWidget, public INamedSlotInterface
{
    GENERATED_BODY()
 
    friend class SObjectWidget;
public:
    UMG_API UUserWidget(const FObjectInitializer& ObjectInitializer);
 
    //~ Begin UObject interface
    UMG_API virtual class UWorld* GetWorld() const override;
    UMG_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    UMG_API virtual void BeginDestroy() override;
    UMG_API virtual void PostLoad() override;
    //~ End UObject Interface
 
    UMG_API void DuplicateAndInitializeFromWidgetTree(UWidgetTree* InWidgetTree, const TMap<FName, UWidget*>& NamedSlotContentToMerge);
 
    UMG_API virtual bool Initialize();
 
    EWidgetTickFrequency GetDesiredTickFrequency() const { return TickFrequency; }
 
    UMG_API UWidgetBlueprintGeneratedClass* GetWidgetTreeOwningClass() const;
 
    UMG_API void UpdateCanTick();
 
protected:
    virtual void InitializeNativeClassData() {}
 
    virtual ERequiresLegacyPlayer GetLegacyPlayerRequirement() const { return ERequiresLegacyPlayer::AutoDetect; }
 
    UMG_API void InitializeNamedSlots();
 
public:
    //~ Begin UVisual interface
    UMG_API virtual void ReleaseSlateResources(bool bReleaseChildren) override;
    //~ End UVisual Interface
 
    //~ Begin UWidget Interface
    UMG_API virtual void SynchronizeProperties() override;
    //~ End UWidget Interface
 
    //~ Begin UNamedSlotInterface Begin
    UMG_API virtual void GetSlotNames(TArray<FName>& SlotNames) const override;
    UMG_API virtual UWidget* GetContentForSlot(FName SlotName) const override;
    UMG_API virtual void SetContentForSlot(FName SlotName, UWidget* Content) override;
    //~ UNamedSlotInterface End
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Viewport", meta=( AdvancedDisplay = "ZOrder" ))
    UMG_API void AddToViewport(int32 ZOrder = 0);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Viewport", meta=( AdvancedDisplay = "ZOrder" ))
    UMG_API bool AddToPlayerScreen(int32 ZOrder = 0);
 
    UE_DEPRECATED(5.1, "RemoveFromViewport is deprecated. Use RemoveFromParent instead.")
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Viewport", meta=( DeprecatedFunction, DeprecationMessage="Use RemoveFromParent instead" ))
    UMG_API void RemoveFromViewport();
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Viewport")
    UMG_API void SetPositionInViewport(FVector2D Position, bool bRemoveDPIScale = true);
 
    /*  */
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Viewport")
    UMG_API void SetDesiredSizeInViewport(FVector2D Size);
 
    /*  */
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Viewport")
    UMG_API void SetAnchorsInViewport(FAnchors Anchors);
 
    /*  */
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Viewport")
    UMG_API void SetAlignmentInViewport(FVector2D Alignment);
 
    /*  */
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Viewport")
    UMG_API FAnchors GetAnchorsInViewport() const;
 
    /*  */
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Viewport")
    UMG_API FVector2D GetAlignmentInViewport() const;
 
    /*  */
    UE_DEPRECATED(5.1, "GetIsVisible is deprecated. Please use IsInViewport instead.")
    UFUNCTION(BlueprintPure, BlueprintCosmetic, Category="Appearance", meta=( DeprecatedFunction, DeprecationMessage="Use IsInViewport instead" ))
    UMG_API bool GetIsVisible() const;
 
    UMG_API virtual void SetVisibility(ESlateVisibility InVisibility) override;
 
    UMG_API void SetPlayerContext(const FLocalPlayerContext& InPlayerContext);
 
    UMG_API const FLocalPlayerContext& GetPlayerContext() const;
 
    UMG_API virtual ULocalPlayer* GetOwningLocalPlayer() const override;
    
    template < class T >
    T* GetOwningLocalPlayer() const
    {
        return Cast<T>(GetOwningLocalPlayer());
    }
 
    UMG_API void SetOwningLocalPlayer(ULocalPlayer* LocalPlayer);
 
    UMG_API virtual APlayerController* GetOwningPlayer() const override;
    
    template < class T >
    T* GetOwningPlayer() const
    {
        return Cast<T>(GetOwningPlayer());
    }
    
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="Player")
    UMG_API void SetOwningPlayer(APlayerController* LocalPlayerController);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="Player")
    UMG_API class APawn* GetOwningPlayerPawn() const;
    
    template < class T >
    T* GetOwningPlayerPawn() const
    {
        return Cast<T>(GetOwningPlayerPawn());
    }
 
    template <class TPlayerState = APlayerState>
    TPlayerState* GetOwningPlayerState(bool bChecked = false) const
    {
        if (auto Controller = GetOwningPlayer())
        {
            return !bChecked ? Cast<TPlayerState>(Controller->PlayerState) :
                               CastChecked<TPlayerState>(Controller->PlayerState, ECastCheckedType::NullAllowed);
        }
 
        return nullptr;
    }
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "Player")
    UMG_API class APlayerCameraManager* GetOwningPlayerCameraManager() const;
 
    template <class T>
    T* GetOwningPlayerCameraManager() const
    {
        return Cast<T>(GetOwningPlayerCameraManager());
    }
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="User Interface")
    UMG_API void OnInitialized();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="User Interface")
    UMG_API void PreConstruct(bool IsDesignTime);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="User Interface", meta=( Keywords="Begin Play" ))
    UMG_API void Construct();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="User Interface", meta=( Keywords="End Play, Destroy" ))
    UMG_API void Destruct();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="User Interface")
    UMG_API void Tick(FGeometry MyGeometry, float InDeltaTime);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="User Interface | Painting")
    UMG_API void OnPaint(UPARAM(ref) FPaintContext& Context) const;
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="User Interface | Interaction")
    UMG_API bool IsInteractable() const;
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Input")
    UMG_API FEventReply OnFocusReceived(FGeometry MyGeometry, FFocusEvent InFocusEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Input")
    UMG_API void OnFocusLost(FFocusEvent InFocusEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Input")
    UMG_API void OnAddedToFocusPath(FFocusEvent InFocusEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Input")
    UMG_API void OnRemovedFromFocusPath(FFocusEvent InFocusEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Input")
    UMG_API FEventReply OnKeyChar(FGeometry MyGeometry, FCharacterEvent InCharacterEvent);
 
    UFUNCTION(BlueprintImplementableEvent, Category="Input")
    UMG_API FEventReply OnPreviewKeyDown(FGeometry MyGeometry, FKeyEvent InKeyEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Input")
    UMG_API FEventReply OnKeyDown(FGeometry MyGeometry, FKeyEvent InKeyEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Input")
    UMG_API FEventReply OnKeyUp(FGeometry MyGeometry, FKeyEvent InKeyEvent);
 
    UFUNCTION(BlueprintImplementableEvent, Category = "Input")
    UMG_API FEventReply OnAnalogValueChanged(FGeometry MyGeometry, FAnalogInputEvent InAnalogInputEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Mouse")
    UMG_API FEventReply OnMouseButtonDown(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Mouse")
    UMG_API FEventReply OnPreviewMouseButtonDown(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Mouse")
    UMG_API FEventReply OnMouseButtonUp(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Mouse")
    UMG_API FEventReply OnMouseMove(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Mouse")
    UMG_API void OnMouseEnter(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Mouse")
    UMG_API void OnMouseLeave(const FPointerEvent& MouseEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Mouse")
    UMG_API FEventReply OnMouseWheel(FGeometry MyGeometry, const FPointerEvent& MouseEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Mouse")
    UMG_API FEventReply OnMouseButtonDoubleClick(FGeometry InMyGeometry, const FPointerEvent& InMouseEvent);
 
    // TODO
    //UFUNCTION(BlueprintImplementableEvent, Category="Mouse")
    //FCursorReply OnCursorQuery(FGeometry MyGeometry, const FPointerEvent& CursorEvent) const;
 
    // TODO
    //virtual bool OnVisualizeTooltip(const TSharedPtr<SWidget>& TooltipContent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Drag and Drop")
    UMG_API void OnDragDetected(FGeometry MyGeometry, const FPointerEvent& PointerEvent, UDragDropOperation*& Operation);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Drag and Drop")
    UMG_API void OnDragCancelled(const FPointerEvent& PointerEvent, UDragDropOperation* Operation);
    
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Drag and Drop")
    UMG_API void OnDragEnter(FGeometry MyGeometry, FPointerEvent PointerEvent, UDragDropOperation* Operation);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Drag and Drop")
    UMG_API void OnDragLeave(FPointerEvent PointerEvent, UDragDropOperation* Operation);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Drag and Drop")
    UMG_API bool OnDragOver(FGeometry MyGeometry, FPointerEvent PointerEvent, UDragDropOperation* Operation);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Drag and Drop")
    UMG_API bool OnDrop(FGeometry MyGeometry, FPointerEvent PointerEvent, UDragDropOperation* Operation);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Touch Input")
    UMG_API FEventReply OnTouchGesture(FGeometry MyGeometry, const FPointerEvent& GestureEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Touch Input")
    UMG_API FEventReply OnTouchStarted(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
    
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Touch Input")
    UMG_API FEventReply OnTouchMoved(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Touch Input")
    UMG_API FEventReply OnTouchEnded(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
    
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Touch Input")
    UMG_API FEventReply OnMotionDetected(FGeometry MyGeometry, FMotionEvent InMotionEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category="Touch Input")
    UMG_API void OnMouseCaptureLost();
 
    UFUNCTION(BlueprintCallable, Category = "Delay")
    UMG_API void CancelLatentActions();
 
    UFUNCTION(BlueprintCallable, Category = "Delay")
    UMG_API void StopAnimationsAndLatentActions();
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category = "Touch Input")
    UMG_API FEventReply OnTouchForceChanged(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
 
    UFUNCTION(BlueprintImplementableEvent, BlueprintCosmetic, Category = "Touch Input")
    UMG_API FEventReply OnTouchFirstMove(FGeometry MyGeometry, const FPointerEvent& InTouchEvent);
 
public:
 
    UFUNCTION(BlueprintCallable, Category=Animation)
    UMG_API void BindToAnimationStarted(UWidgetAnimation* Animation, FWidgetAnimationDynamicEvent Delegate);
 
    UFUNCTION(BlueprintCallable, Category = Animation)
    UMG_API void UnbindFromAnimationStarted(UWidgetAnimation* Animation, FWidgetAnimationDynamicEvent Delegate);
 
    UFUNCTION(BlueprintCallable, Category = Animation)
    UMG_API void UnbindAllFromAnimationStarted(UWidgetAnimation* Animation);
 
    UFUNCTION(BlueprintCallable, Category = Animation)
    UMG_API void BindToAnimationFinished(UWidgetAnimation* Animation, FWidgetAnimationDynamicEvent Delegate);
 
    UFUNCTION(BlueprintCallable, Category = Animation)
    UMG_API void UnbindFromAnimationFinished(UWidgetAnimation* Animation, FWidgetAnimationDynamicEvent Delegate);
 
    UFUNCTION(BlueprintCallable, Category = Animation)
    UMG_API void UnbindAllFromAnimationFinished(UWidgetAnimation* Animation);
 
    UFUNCTION(BlueprintCallable, Category = Animation)
    UMG_API void BindToAnimationEvent(UWidgetAnimation* Animation, FWidgetAnimationDynamicEvent Delegate, EWidgetAnimationEvent AnimationEvent, FName UserTag = NAME_None);
 
    virtual bool IsEditorUtility() const { return false; }
 
protected:
 
    UFUNCTION( BlueprintNativeEvent, BlueprintCosmetic, Category = "Animation" )
    UMG_API void OnAnimationStarted( const UWidgetAnimation* Animation );
 
    UMG_API virtual void OnAnimationStarted_Implementation(const UWidgetAnimation* Animation);
 
    UFUNCTION( BlueprintNativeEvent, BlueprintCosmetic, Category = "Animation" )
    UMG_API void OnAnimationFinished( const UWidgetAnimation* Animation );
 
    UMG_API virtual void OnAnimationFinished_Implementation(const UWidgetAnimation* Animation);
 
    UE_DEPRECATED(5.6, "UUMGSequencePlayer is deprecated")
    UMG_API void BroadcastAnimationStateChange(const UUMGSequencePlayer& Player, EWidgetAnimationEvent AnimationEvent);
 
private:
 
    UMG_API void BroadcastAnimationStateChange(const FWidgetAnimationState& State, EWidgetAnimationEvent AnimationEvent);
 
    UMG_API void BroadcastAnimationStateChange(const UWidgetAnimation* Animation, FName UserTag, EWidgetAnimationEvent AnimationEvent);
 
    UMG_API void BroadcastAnimationStartedPlaying(FWidgetAnimationState& State);
    UMG_API void BroadcastAnimationFinishedPlaying(FWidgetAnimationState& State);
 
protected:
 
    FOnWidgetAnimationEvent& OnAnimationStartedPlaying() { return OnAnimationStartedPlayingEvent; }
 
    FOnWidgetAnimationEvent& OnAnimationFinishedPlaying() { return OnAnimationFinishedPlayingEvent; }
 
    UE_DEPRECATED(5.6, "UUMGSequencePlayer is deprecated")
    virtual void OnAnimationStartedPlaying(UUMGSequencePlayer& Player) {}
 
    UE_DEPRECATED(5.6, "UUMGSequencePlayer is deprecated")
    virtual void OnAnimationFinishedPlaying(UUMGSequencePlayer& Player) {}
 
private:
 
    FOnWidgetAnimationEvent OnAnimationStartedPlayingEvent;
    FOnWidgetAnimationEvent OnAnimationFinishedPlayingEvent;
 
public:
 
    UE_DEPRECATED(5.2, "Direct access to ColorAndOpacity is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, BlueprintSetter = "SetColorAndOpacity", Category = "Appearance")
    FLinearColor ColorAndOpacity;
 
    UPROPERTY()
    FGetLinearColor ColorAndOpacityDelegate;
 
    UE_DEPRECATED(5.2, "Direct access to ForegroundColor is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, BlueprintSetter = "SetForegroundColor", Category = "Appearance")
    FSlateColor ForegroundColor;
 
    UPROPERTY()
    FGetSlateColor ForegroundColorDelegate;
 
    UPROPERTY(BlueprintAssignable, Category = "Appearance|Event")
    FOnVisibilityChangedEvent OnVisibilityChanged;
    DECLARE_EVENT_OneParam(UUserWidget, FNativeOnVisibilityChangedEvent, ESlateVisibility);
    FNativeOnVisibilityChangedEvent OnNativeVisibilityChanged;
 
    DECLARE_EVENT_OneParam(UUserWidget, FNativeOnDestruct, UUserWidget*);
    FNativeOnDestruct OnNativeDestruct;
 
    UE_DEPRECATED(5.2, "Direct access to Padding is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, BlueprintSetter = "SetPadding", Category = "Appearance")
    FMargin Padding;
 
    UE_DEPRECATED(5.2, "Direct access to Priority is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter = "GetInputActionPriority", Setter = "SetInputActionPriority", BlueprintSetter = "SetInputActionPriority", Category = "Input")
    int32 Priority;
 
    UE_DEPRECATED(5.2, "Direct access to bIsFocusable is deprecated. Please use the getter. Note that this property is only set at construction and is not modifiable at runtime.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter = "IsFocusable", Setter = "SetIsFocusable", Category = "Interaction")
    uint8 bIsFocusable : 1;
     
    UE_DEPRECATED(5.2, "Direct access to bStopAction is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter = "IsInputActionBlocking", Setter = "SetInputActionBlocking", BlueprintSetter = "SetInputActionBlocking", Category = "Input")
    uint8 bStopAction : 1;
 
    UPROPERTY()
    uint8 bAutomaticallyRegisterInputOnConstruction : 1;
 
public:
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="Appearance")
    UMG_API void SetColorAndOpacity(FLinearColor InColorAndOpacity);
 
    UMG_API const FLinearColor& GetColorAndOpacity() const;
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="Appearance")
    UMG_API void SetForegroundColor(FSlateColor InForegroundColor);
 
    UMG_API const FSlateColor& GetForegroundColor() const;
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="Appearance")
    UMG_API void SetPadding(FMargin InPadding);
 
    UMG_API FMargin GetPadding() const;
 
    UMG_API int32 GetInputActionPriority() const;
 
    UMG_API bool IsInputActionBlocking() const;
 
    UMG_API bool IsFocusable() const;
 
    UMG_API void SetIsFocusable(bool InIsFocusable);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void QueuePlayAnimation(UWidgetAnimation* InAnimation, float StartAtTime = 0.0f, int32 NumLoopsToPlay = 1, EUMGSequencePlayMode::Type PlayMode = EUMGSequencePlayMode::Forward, float PlaybackSpeed = 1.0f, bool bRestoreState = false);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void QueuePlayAnimationTimeRange(UWidgetAnimation* InAnimation, float StartAtTime = 0.0f, float EndAtTime = 0.0f, int32 NumLoopsToPlay = 1, EUMGSequencePlayMode::Type PlayMode = EUMGSequencePlayMode::Forward, float PlaybackSpeed = 1.0f, bool bRestoreState = false);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void QueuePlayAnimationForward(UWidgetAnimation* InAnimation, float PlaybackSpeed = 1.0f, bool bRestoreState = false);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void QueuePlayAnimationReverse(UWidgetAnimation* InAnimation, float PlaybackSpeed = 1.0f, bool bRestoreState = false);
 
    UFUNCTION(BlueprintCallable, Category="User Interface|Animation")
    UMG_API void QueueStopAnimation(const UWidgetAnimation* InAnimation);
 
    UFUNCTION(BlueprintCallable, Category="User Interface|Animation")
    UMG_API void QueueStopAllAnimations();
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Animation")
    UMG_API float QueuePauseAnimation(const UWidgetAnimation* InAnimation);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API FWidgetAnimationHandle PlayAnimation(UWidgetAnimation* InAnimation, float StartAtTime = 0.0f, int32 NumLoopsToPlay = 1, EUMGSequencePlayMode::Type PlayMode = EUMGSequencePlayMode::Forward, float PlaybackSpeed = 1.0f, bool bRestoreState = false);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API FWidgetAnimationHandle PlayAnimationTimeRange(UWidgetAnimation* InAnimation, float StartAtTime = 0.0f, float EndAtTime = 0.0f, int32 NumLoopsToPlay = 1, EUMGSequencePlayMode::Type PlayMode = EUMGSequencePlayMode::Forward, float PlaybackSpeed = 1.0f, bool bRestoreState = false);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API FWidgetAnimationHandle PlayAnimationForward(UWidgetAnimation* InAnimation, float PlaybackSpeed = 1.0f, bool bRestoreState = false);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API FWidgetAnimationHandle PlayAnimationReverse(UWidgetAnimation* InAnimation, float PlaybackSpeed = 1.0f, bool bRestoreState = false);
 
    UFUNCTION(BlueprintCallable, Category="User Interface|Animation")
    UMG_API void StopAnimation(const UWidgetAnimation* InAnimation);
 
    UFUNCTION(BlueprintCallable, Category="User Interface|Animation")
    UMG_API void StopAllAnimations();
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Animation")
    UMG_API float PauseAnimation(const UWidgetAnimation* InAnimation);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API float GetAnimationCurrentTime(const UWidgetAnimation* InAnimation) const;
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void SetAnimationCurrentTime(const UWidgetAnimation* InAnimation, float InTime);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Animation")
    UMG_API bool IsAnimationPlaying(const UWidgetAnimation* InAnimation) const;
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="User Interface|Animation")
    UMG_API bool IsAnyAnimationPlaying() const;
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void SetNumLoopsToPlay(const UWidgetAnimation* InAnimation, int32 NumLoopsToPlay);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void SetPlaybackSpeed(const UWidgetAnimation* InAnimation, float PlaybackSpeed = 1.0f);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void ReverseAnimation(const UWidgetAnimation* InAnimation);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API bool IsAnimationPlayingForward(const UWidgetAnimation* InAnimation);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "User Interface|Animation")
    UMG_API void FlushAnimations();
 
    template<typename ExtensionType>
    ExtensionType* GetExtension() const
    {
        return CastChecked<ExtensionType>(GetExtension(ExtensionType::StaticClass()), ECastCheckedType::NullAllowed);
    }
 
    UFUNCTION(BlueprintCallable, Category = "User Interface|Extension", Meta = (DeterminesOutputType = "ExtensionType"))
    UMG_API UUserWidgetExtension* GetExtension(TSubclassOf<UUserWidgetExtension> ExtensionType) const;
 
    UFUNCTION(BlueprintCallable, Category = "User Interface|Extension", Meta = (DeterminesOutputType = "ExtensionType"))
    UMG_API TArray<UUserWidgetExtension*> GetExtensions(TSubclassOf<UUserWidgetExtension> ExtensionType) const;
 
    template<typename ExtensionType>
    ExtensionType* AddExtension()
    {
        return CastChecked<ExtensionType>(AddExtension(ExtensionType::StaticClass()), ECastCheckedType::NullAllowed);
    }
 
    UFUNCTION(BlueprintCallable, Category = "User Interface|Extension", Meta = (DeterminesOutputType = "InExtensionType"))
    UMG_API UUserWidgetExtension* AddExtension(TSubclassOf<UUserWidgetExtension> InExtensionType);
 
    UFUNCTION(BlueprintCallable, Category = "User Interface|Extension")
    UMG_API void RemoveExtension(UUserWidgetExtension* InExtension);
 
    template<typename ExtensionType>
    void RemoveExtensions()
    {
        return RemoveExtensions(ExtensionType::StaticClass());
    }
 
    UFUNCTION(BlueprintCallable, Category = "User Interface|Extension")
    UMG_API void RemoveExtensions(TSubclassOf<UUserWidgetExtension> InExtensionType);
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category="Sound", meta=( DeprecatedFunction, DeprecationMessage="Use the UGameplayStatics::PlaySound2D instead." ))
    UMG_API void PlaySound(class USoundBase* SoundToPlay);
 
    UMG_API bool SetDesiredFocusWidget(FName WidgetName);
 
    UFUNCTION(BlueprintCallable, Category = "User Interface|Focus")
    UMG_API bool SetDesiredFocusWidget(UWidget* Widget);
 
    UMG_API FName GetDesiredFocusWidgetName() const;
 
    UMG_API UWidget* GetDesiredFocusWidget() const;
 
    UMG_API UWidget* GetWidgetHandle(TSharedRef<SWidget> InWidget);
 
    UMG_API UWidget* GetRootWidget() const;
 
    UMG_API TSharedPtr<SWidget> GetSlateWidgetFromName(const FName& Name) const;
 
    UMG_API UWidget* GetWidgetFromName(const FName& Name) const;
 
    //~ Begin UObject Interface
    UMG_API virtual bool IsAsset() const;
    UMG_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    //~ End UObject Interface
 
    UFUNCTION(BlueprintCallable, Category="User Interface|Animation")
    UMG_API bool IsPlayingAnimation() const;
 
#if WITH_EDITOR
    //~ Begin UWidget Interface
    UMG_API virtual const FText GetPaletteCategory() override;
    //~ End UWidget Interface
 
    UMG_API virtual void SetDesignerFlags(EWidgetDesignFlags NewFlags) override;
    UMG_API virtual void OnDesignerChanged(const FDesignerChangedEventArgs& EventArgs) override;
    UMG_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
 
    UMG_API void UpdateBindingForSlot(FName SlotName);
 
    UMG_API void AssignGUIDToBindings();
 
    UMG_API void ValidateBlueprint(const UWidgetTree& BlueprintWidgetTree, class IWidgetCompilerLog& CompileLog) const;
 
    virtual void ValidateCompiledWidgetTree(const UWidgetTree& BlueprintWidgetTree, class IWidgetCompilerLog& CompileLog) const {};
#endif
 
    static UMG_API UUserWidget* CreateWidgetInstance(UWidget& OwningWidget, TSubclassOf<UUserWidget> UserWidgetClass, FName WidgetName);
    static UMG_API UUserWidget* CreateWidgetInstance(UWidgetTree& OwningWidgetTree, TSubclassOf<UUserWidget> UserWidgetClass, FName WidgetName);
    static UMG_API UUserWidget* CreateWidgetInstance(APlayerController& OwnerPC, TSubclassOf<UUserWidget> UserWidgetClass, FName WidgetName);
    static UMG_API UUserWidget* CreateWidgetInstance(UGameInstance& GameInstance, TSubclassOf<UUserWidget> UserWidgetClass, FName WidgetName);
    static UMG_API UUserWidget* CreateWidgetInstance(UWorld& World, TSubclassOf<UUserWidget> UserWidgetClass, FName WidgetName);
 
private:
 
    static UMG_API UUserWidget* CreateInstanceInternal(UObject* Outer, TSubclassOf<UUserWidget> UserWidgetClass, FName WidgetName, UWorld* World, ULocalPlayer* LocalPlayer);
 
    void ClearStoppedAnimationStates();
 
    // If this widget's player context is invalid, this function will set it to the provided player context, otherwise it will keep its current player context and call CheckUpdatePlayerContext on its children
    void UpdatePlayerContextIfInvalid(const FLocalPlayerContext& ParentPlayerContext);
 
public:
 
    UPROPERTY(Transient)
    TArray<FQueuedWidgetAnimationTransition> QueuedWidgetAnimationTransitions;
 
    UE_DEPRECATED(5.6, "Please use ActiveAnimations")
    UPROPERTY(Transient)
    TArray<TObjectPtr<UUMGSequencePlayer>> ActiveSequencePlayers;
    
    UPROPERTY(Transient)
    TObjectPtr<UUMGSequenceTickManager> AnimationTickManager;
 
    UE_DEPRECATED(5.6, "Please use ActiveAnimations")
    UPROPERTY(Transient)
    TArray<TObjectPtr<UUMGSequencePlayer>> StoppedSequencePlayers;
 
private:
 
    TArray<TSharedRef<FWidgetAnimationState>> ActiveAnimations;
 
    bool bIsTickingAnimations = false;
 
private:
 
    UPROPERTY()
    TArray<FNamedSlotBinding> NamedSlotBindings;
 
    UPROPERTY()
    TArray<TObjectPtr<UUserWidgetExtension>> Extensions;
 
public:
    UPROPERTY(Transient, DuplicateTransient, TextExportTransient)
    TObjectPtr<UWidgetTree> WidgetTree;
 
public:
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY()
    FVector2D DesignTimeSize;
 
    UPROPERTY()
    EDesignPreviewSizeMode DesignSizeMode;
 
    UPROPERTY()
    FText PaletteCategory;
 
    UPROPERTY(EditDefaultsOnly, Category="Designer")
    TObjectPtr<UTexture2D> PreviewBackground;
 
#endif
 
    UPROPERTY()
    uint8 bHasScriptImplementedTick : 1;
 
    UPROPERTY()
    uint8 bHasScriptImplementedPaint : 1;
 
private:
 
    uint8 bInitialized : 1;
 
    uint8 bAreExtensionsPreConstructed : 1;
    
    uint8 bAreExtensionsConstructed : 1;
 
    uint8 bStoppingAllAnimations : 1;
 
protected:
 
    static UMG_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
 
    UMG_API virtual TSharedRef<SWidget> RebuildWidget() override;
    UMG_API virtual void OnWidgetRebuilt() override;
 
    UE_DEPRECATED(5.1, "GetFullScreenOffset is deprecated. Use the GameViewportSubsystem.")
    UMG_API FMargin GetFullScreenOffset() const;
 
    UMG_API virtual void NativeOnInitialized();
    UMG_API virtual void NativePreConstruct();
    UMG_API virtual void NativeConstruct();
    UMG_API virtual void NativeDestruct();
    UMG_API virtual void NativeTick(const FGeometry& MyGeometry, float InDeltaTime);
 
    UMG_API virtual int32 NativePaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const;
 
    inline FVector2D GetMinimumDesiredSize() const { return MinimumDesiredSize; }
    UMG_API void SetMinimumDesiredSize(FVector2D InMinimumDesiredSize);
 
    UMG_API virtual bool NativeIsInteractable() const;
    UMG_API virtual bool NativeSupportsKeyboardFocus() const;
    virtual bool NativeSupportsCustomNavigation() const { return false; }
 
    UMG_API virtual FReply NativeOnFocusReceived( const FGeometry& InGeometry, const FFocusEvent& InFocusEvent );
    UMG_API virtual void NativeOnFocusLost( const FFocusEvent& InFocusEvent );
    UMG_API virtual void NativeOnFocusChanging(const FWeakWidgetPath& PreviousFocusPath, const FWidgetPath& NewWidgetPath, const FFocusEvent& InFocusEvent);
    UMG_API virtual void NativeOnAddedToFocusPath(const FFocusEvent& InFocusEvent);
    UMG_API virtual void NativeOnRemovedFromFocusPath(const FFocusEvent& InFocusEvent);
    UMG_API virtual FNavigationReply NativeOnNavigation(const FGeometry& MyGeometry, const FNavigationEvent& InNavigationEvent, const FNavigationReply& InDefaultReply);
    UMG_API virtual FReply NativeOnKeyChar( const FGeometry& InGeometry, const FCharacterEvent& InCharEvent );
    UMG_API virtual FReply NativeOnPreviewKeyDown( const FGeometry& InGeometry, const FKeyEvent& InKeyEvent );
    UMG_API virtual FReply NativeOnKeyDown( const FGeometry& InGeometry, const FKeyEvent& InKeyEvent );
    UMG_API virtual FReply NativeOnKeyUp( const FGeometry& InGeometry, const FKeyEvent& InKeyEvent );
    UMG_API virtual FReply NativeOnAnalogValueChanged( const FGeometry& InGeometry, const FAnalogInputEvent& InAnalogEvent );
    UMG_API virtual FReply NativeOnMouseButtonDown( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent );
    UMG_API virtual FReply NativeOnPreviewMouseButtonDown( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent );
    UMG_API virtual FReply NativeOnMouseButtonUp( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent );
    UMG_API virtual FReply NativeOnMouseMove( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent );
    UMG_API virtual void NativeOnMouseEnter( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent );
    UMG_API virtual void NativeOnMouseLeave( const FPointerEvent& InMouseEvent );
    UMG_API virtual FReply NativeOnMouseWheel( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent );
    UMG_API virtual FReply NativeOnMouseButtonDoubleClick( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent );
    UMG_API virtual void NativeOnDragDetected( const FGeometry& InGeometry, const FPointerEvent& InMouseEvent, UDragDropOperation*& OutOperation );
    UMG_API virtual void NativeOnDragEnter( const FGeometry& InGeometry, const FDragDropEvent& InDragDropEvent, UDragDropOperation* InOperation );
    UMG_API virtual void NativeOnDragLeave( const FDragDropEvent& InDragDropEvent, UDragDropOperation* InOperation );
    UMG_API virtual bool NativeOnDragOver( const FGeometry& InGeometry, const FDragDropEvent& InDragDropEvent, UDragDropOperation* InOperation );
    UMG_API virtual bool NativeOnDrop( const FGeometry& InGeometry, const FDragDropEvent& InDragDropEvent, UDragDropOperation* InOperation );
    UMG_API virtual void NativeOnDragCancelled( const FDragDropEvent& InDragDropEvent, UDragDropOperation* InOperation );
    UMG_API virtual FReply NativeOnTouchGesture( const FGeometry& InGeometry, const FPointerEvent& InGestureEvent );
    UMG_API virtual FReply NativeOnTouchStarted( const FGeometry& InGeometry, const FPointerEvent& InGestureEvent );
    UMG_API virtual FReply NativeOnTouchMoved( const FGeometry& InGeometry, const FPointerEvent& InGestureEvent );
    UMG_API virtual FReply NativeOnTouchEnded( const FGeometry& InGeometry, const FPointerEvent& InGestureEvent );
    UMG_API virtual FReply NativeOnMotionDetected( const FGeometry& InGeometry, const FMotionEvent& InMotionEvent );
    UMG_API virtual FReply NativeOnTouchForceChanged(const FGeometry& MyGeometry, const FPointerEvent& TouchEvent);
    UMG_API virtual FReply NativeOnTouchFirstMove(const FGeometry& MyGeometry, const FPointerEvent& TouchEvent);
    UMG_API virtual FCursorReply NativeOnCursorQuery( const FGeometry& InGeometry, const FPointerEvent& InCursorEvent );
    UMG_API virtual FNavigationReply NativeOnNavigation(const FGeometry& InGeometry, const FNavigationEvent& InNavigationEvent);
    UMG_API virtual void NativeOnMouseCaptureLost(const FCaptureLostEvent& CaptureLostEvent);
    virtual void NativeOnFinishedPointerInput() {}
 
protected:
 
    UMG_API void TickActionsAndAnimation(float InDeltaTime);
 
    UE_DEPRECATED(5.6, "This method isn't needed anymore")
    void PostTickActionsAndAnimation(float InDeltaTime) {}
 
    UMG_API void RemoveObsoleteBindings(const TArray<FName>& NamedSlots);
 
    UMG_API TSharedPtr<const FWidgetAnimationState> GetAnimationState(const UWidgetAnimation* InAnimation) const;
    UMG_API TSharedPtr<FWidgetAnimationState> GetAnimationState(const UWidgetAnimation* InAnimation);
    UMG_API TSharedPtr<FWidgetAnimationState> GetOrAddAnimationState(UWidgetAnimation* InAnimation);
 
    UMG_API void ExecuteQueuedAnimationTransitions();
 
    UMG_API void ConditionalTearDownAnimations();
 
    UMG_API void TearDownAnimations();
 
    UMG_API void DisableAnimations();
 
    UMG_API void Invalidate(EInvalidateWidgetReason InvalidateReason);
    
    UFUNCTION( BlueprintCallable, Category = "Input", meta = ( BlueprintProtected = "true" ) )
    UMG_API void ListenForInputAction( FName ActionName, TEnumAsByte< EInputEvent > EventType, bool bConsume, FOnInputAction Callback );
 
    UFUNCTION( BlueprintCallable, Category = "Input", meta = ( BlueprintProtected = "true" ) )
    UMG_API void StopListeningForInputAction( FName ActionName, TEnumAsByte< EInputEvent > EventType );
 
    UFUNCTION( BlueprintCallable, Category = "Input", meta = ( BlueprintProtected = "true" ) )
    UMG_API void StopListeningForAllInputActions();
 
    UFUNCTION(BlueprintCallable, Category = "Input", meta = ( BlueprintProtected = "true" ))
    UMG_API void RegisterInputComponent();
 
    UFUNCTION(BlueprintCallable, Category = "Input", meta = ( BlueprintProtected = "true" ))
    UMG_API void UnregisterInputComponent();
 
    UFUNCTION( BlueprintCallable, Category = "Input", meta = ( BlueprintProtected = "true" ) )
    UMG_API bool IsListeningForInputAction( FName ActionName ) const;
 
    UFUNCTION( BlueprintCallable, Category = "Input", meta = ( BlueprintProtected = "true" ) )
    UMG_API void SetInputActionPriority( int32 NewPriority );
 
    UFUNCTION( BlueprintCallable, Category = "Input", meta = ( BlueprintProtected = "true" ) )
    UMG_API void SetInputActionBlocking( bool bShouldBlock );
 
    UMG_API void OnInputAction( FOnInputAction Callback );
 
    UE_DEPRECATED(5.7, "InitializeInputComponent is deprecated. bAutomaticallyRegisterInputOnConstruction will be set on compilation of this widget and automatically create the input component instead.")
    UMG_API virtual void InitializeInputComponent() final;
 
private:
    FVector2D MinimumDesiredSize;
 
private:
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Performance", meta=(AllowPrivateAccess="true"))
    EWidgetTickFrequency TickFrequency;
 
    UPROPERTY(EditDefaultsOnly, Category = "Interaction", meta = (AllowPrivateAccess = "true"))
    FWidgetChild DesiredFocusWidget;
 
protected:
    
    UMG_API virtual void CreateInputComponent();
 
    UMG_API virtual void StartProcessingInputScriptDelegates();
 
    UMG_API virtual void StopProcessingInputScriptDelegates();
 
    UMG_API virtual void DestroyInputComponent();
    
    UPROPERTY(Transient, DuplicateTransient)
    TObjectPtr<class UInputComponent> InputComponent;
 
    void HandleOwningLocalPlayerControllerChanged(APlayerController* NewPlayerController);
    void StartListeningForPlayerControllerChanges();
    void StopListeningForPlayerControllerChanges();
 
protected:
    UPROPERTY(Transient, DuplicateTransient)
    TArray<FAnimationEventBinding> AnimationCallbacks;
 
private:
    static UMG_API void OnLatentActionsChanged(UObject* ObjectWhichChanged, ELatentActionChangeType ChangeType);
 
    FLocalPlayerContext PlayerContext;
 
    mutable TWeakObjectPtr<UWorld> CachedWorld;
 
    static UMG_API uint32& GetInitializingFromWidgetTree();
 
protected:
 
    PROPERTY_BINDING_IMPLEMENTATION(FLinearColor, ColorAndOpacity);
    PROPERTY_BINDING_IMPLEMENTATION(FSlateColor, ForegroundColor);
 
    friend UUMGSequencePlayer;
    friend FWidgetAnimationState;
    friend FWidgetAnimationHandle;
 
    friend UUMGSequenceTickManager;
 
    friend class FWidgetBlueprintCompilerContext;
};
 
#define LOCTEXT_NAMESPACE "UMG"
 
namespace CreateWidgetHelpers
{
    UMG_API bool ValidateUserWidgetClass(const UClass* UserWidgetClass);
}
 
DECLARE_CYCLE_STAT(TEXT("UserWidget Create"), STAT_CreateWidget, STATGROUP_Slate);
 
template <typename WidgetT = UUserWidget, typename OwnerType = UObject>
WidgetT* CreateWidget(OwnerType OwningObject, TSubclassOf<UUserWidget> UserWidgetClass = WidgetT::StaticClass(), FName WidgetName = NAME_None)
{
    static_assert(TIsDerivedFrom<WidgetT, UUserWidget>::IsDerived, "CreateWidget can only be used to create UserWidget instances. If creating a UWidget, use WidgetTree::ConstructWidget.");
    
    static_assert(TIsDerivedFrom<TPointedToType<OwnerType>, UWidget>::IsDerived
        || TIsDerivedFrom<TPointedToType<OwnerType>, UWidgetTree>::IsDerived
        || TIsDerivedFrom<TPointedToType<OwnerType>, APlayerController>::IsDerived
        || TIsDerivedFrom<TPointedToType<OwnerType>, UGameInstance>::IsDerived
        || TIsDerivedFrom<TPointedToType<OwnerType>, UWorld>::IsDerived, "The given OwningObject is not of a supported type for use with CreateWidget.");
 
    SCOPE_CYCLE_COUNTER(STAT_CreateWidget);
    FScopeCycleCounterUObject WidgetObjectCycleCounter(UserWidgetClass, GET_STATID(STAT_CreateWidget));
 
    if (OwningObject)
    {
        return Cast<WidgetT>(UUserWidget::CreateWidgetInstance(*OwningObject, UserWidgetClass, WidgetName));
    }
    return nullptr;
}
 
#undef LOCTEXT_NAMESPACE