Widget.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Binding/States/WidgetStateBitfield.h"
#include "UObject/ObjectMacros.h"
#include "FieldNotificationDeclaration.h"
#include "INotifyFieldValueChanged.h"
#include "Misc/Attribute.h"
#include "Templates/SubclassOf.h"
#include "UObject/ScriptMacros.h"
#include "Styling/SlateColor.h"
#include "Layout/Visibility.h"
#include "Layout/Geometry.h"
#include "Widgets/SWidget.h"
#include "Types/SlateStructs.h"
#include "Components/Visual.h"
#include "Styling/SlateBrush.h"
#include "UObject/TextProperty.h"
#include "Components/SlateWrapperTypes.h"
#include "Slate/WidgetTransform.h"
#include "UObject/UObjectThreadContext.h"
#include "GameFramework/PlayerController.h"
#include "Blueprint/WidgetNavigation.h"
#include "Widgets/WidgetPixelSnapping.h"
 
#include "Widget.generated.h"
 
#ifndef UE_HAS_WIDGET_GENERATED_BY_CLASS
  #define UE_HAS_WIDGET_GENERATED_BY_CLASS (!UE_BUILD_SHIPPING || WITH_EDITOR)
#endif
 
#ifndef WIDGET_INCLUDE_RELFECTION_METADATA
#define WIDGET_INCLUDE_RELFECTION_METADATA  (!UE_BUILD_SHIPPING || WITH_EDITOR)
#endif
 
class ULocalPlayer;
class SObjectWidget;
class UGameViewportSubsystem;
class UPanelSlot;
class UPropertyBinding;
class UUserWidget;
struct FDynamicPropertyPath;
struct FNavigationMethod;
enum class ECheckBoxState : uint8;
 
namespace UMWidget
{
    // valid keywords for the UCLASS macro
    enum
    {
        // [ClassMetadata] [PropertyMetadata] Specifies the base class by which to filter available entry classes within DynamicEntryBox and any ListViewBase.
        EntryClass,
 
        // [ClassMetadata] [PropertyMetadata] Specifies the base class by which to filter available entry classes within DynamicEntryBox and any ListViewBase.
        EntryInterface,
    };
 
    // valid metadata keywords for the UPROPERTY macro
    enum
    {
        // [PropertyMetadata] This property if changed will rebuild the widget designer preview.  Use sparingly, try to update most properties by
        // setting them in the SynchronizeProperties function.
        // UPROPERTY(meta=(DesignerRebuild))
        DesignerRebuild,
 
        // [PropertyMetadata] This property requires a widget be bound to it in the designer.  Allows easy native access to designer defined controls.
        // UPROPERTY(meta=(BindWidget))
        BindWidget,
 
        // [PropertyMetadata] This property optionally allows a widget be bound to it in the designer.  Allows easy native access to designer defined controls.
        // UPROPERTY(meta=(BindWidgetOptional))
        BindWidgetOptional,
 
        // [PropertyMetadata] This property optionally allows a widget be bound to it in the designer.  Allows easy native access to designer defined controls.
        // UPROPERTY(meta=(BindWidget, OptionalWidget=true))
        OptionalWidget,
 
        // [PropertyMetadata] This property requires a widget animation be bound to it in the designer.  Allows easy native access to designer defined animations.
        // UPROPERTY(meta=(BindWidgetAnim))
        BindWidgetAnim,
 
        // [PropertyMetadata] This property optionally allows a animation widget be bound to it in the designer.  Allows easy native access to designer defined animation.
        // UPROPERTY(meta=(BindWidgetAnimOptional))
        BindWidgetAnimOptional,
 
        // [PropertyMetadata] Exposes a dynamic delegate property in the details panel for the widget.
        // UPROPERTY(meta=(IsBindableEvent))
        IsBindableEvent,
 
        // [ClassMetadata] [PropertyMetadata] Specifies the base class by which to filter available entry classes within DynamicEntryBox and any ListViewBase.
        // EntryClass, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the property section)
 
        // [ClassMetadata] [PropertyMetadata] Specifies the base class by which to filter available entry classes within DynamicEntryBox and any ListViewBase.
        //EntryInterface, (Commented out so as to avoid duplicate name with version in the Class section, but still show in the property section)
    };
}
 
 
 
 
#if WITH_EDITOR
 
#define PROPERTY_BINDING(ReturnType, MemberName)                    \
    ( MemberName ## Delegate.IsBound() && !IsDesignTime() )         \
    ?                                                               \
        BIND_UOBJECT_ATTRIBUTE(ReturnType, K2_Gate_ ## MemberName)  \
    :                                                               \
        TAttribute< ReturnType >(MemberName)
 
#define BITFIELD_PROPERTY_BINDING(MemberName)                       \
    ( MemberName ## Delegate.IsBound() && !IsDesignTime() )         \
    ?                                                               \
        BIND_UOBJECT_ATTRIBUTE(bool, K2_Gate_ ## MemberName)        \
    :                                                               \
        TAttribute< bool >(MemberName != 0)
 
#define PROPERTY_BINDING_IMPLEMENTATION(ReturnType, MemberName)         \
    ReturnType K2_Cache_ ## MemberName;                                 \
    ReturnType K2_Gate_ ## MemberName()                                 \
    {                                                                   \
        if (CanSafelyRouteEvent())                                      \
        {                                                               \
            K2_Cache_ ## MemberName = TAttribute< ReturnType >::Create(MemberName ## Delegate.GetUObject(), MemberName ## Delegate.GetFunctionName()).Get(); \
        }                                                               \
                                                                        \
        return K2_Cache_ ## MemberName;                                 \
    }
 
#else
 
#define PROPERTY_BINDING(ReturnType, MemberName)                \
    ( MemberName ## Delegate.IsBound() && !IsDesignTime() )     \
    ?                                                           \
        TAttribute< ReturnType >::Create(MemberName ## Delegate.GetUObject(), MemberName ## Delegate.GetFunctionName()) \
    :                                                           \
        TAttribute< ReturnType >(MemberName)
 
#define BITFIELD_PROPERTY_BINDING(MemberName)                   \
    ( MemberName ## Delegate.IsBound() && !IsDesignTime() )     \
    ?                                                           \
        TAttribute< bool >::Create(MemberName ## Delegate.GetUObject(), MemberName ## Delegate.GetFunctionName()) \
    :                                                           \
        TAttribute< bool >(MemberName != 0)
 
#define PROPERTY_BINDING_IMPLEMENTATION(Type, MemberName) 
 
#endif
 
#define GAME_SAFE_OPTIONAL_BINDING(ReturnType, MemberName) PROPERTY_BINDING(ReturnType, MemberName)
#define GAME_SAFE_BINDING_IMPLEMENTATION(ReturnType, MemberName) PROPERTY_BINDING_IMPLEMENTATION(ReturnType, MemberName)
 
#define OPTIONAL_BINDING_CONVERT(ReturnType, MemberName, ConvertedType, ConversionFunction) \
        ( MemberName ## Delegate.IsBound() && !IsDesignTime() )                             \
        ?                                                                                   \
            TAttribute< ConvertedType >::Create(TAttribute< ConvertedType >::FGetter::CreateUObject(this, &ThisClass::ConversionFunction, TAttribute< ReturnType >::Create(MemberName ## Delegate.GetUObject(), MemberName ## Delegate.GetFunctionName()))) \
        :                                                                                   \
            ConversionFunction(TAttribute< ReturnType >(MemberName))
 
 
 
UENUM()
enum class EWidgetDesignFlags : uint8
{
    None                = 0,
    Designing           = 1 << 0,
    ShowOutline         = 1 << 1,
    ExecutePreConstruct = 1 << 2,
    Previewing          = 1 << 3
};
 
ENUM_CLASS_FLAGS(EWidgetDesignFlags);
 
 
#if WITH_EDITOR
 
struct FDesignerChangedEventArgs
{
public:
    FDesignerChangedEventArgs()
        : bScreenPreview(false)
        , Size(0, 0)
        , DpiScale(1.0f)
    {
    }
 
public:
    bool bScreenPreview;
    FVector2D Size;
    float DpiScale;
};
 
#endif
 
 
UCLASS(Abstract, BlueprintType, Blueprintable, CustomFieldNotify, MinimalAPI)
class UWidget : public UVisual, public INotifyFieldValueChanged
{
    GENERATED_UCLASS_BODY()
 
    friend UGameViewportSubsystem;
 
public:
    UE_FIELD_NOTIFICATION_DECLARE_CLASS_DESCRIPTOR_BASE_BEGIN(UMG_API)
        UE_FIELD_NOTIFICATION_DECLARE_FIELD(ToolTipText, UMG_API)
        UE_FIELD_NOTIFICATION_DECLARE_FIELD(Visibility, UMG_API)
        UE_FIELD_NOTIFICATION_DECLARE_FIELD(bIsEnabled, UMG_API)
        UE_FIELD_NOTIFICATION_DECLARE_ENUM_FIELD_BEGIN(ToolTipText)
        UE_FIELD_NOTIFICATION_DECLARE_ENUM_FIELD(Visibility)
        UE_FIELD_NOTIFICATION_DECLARE_ENUM_FIELD(bIsEnabled)
        UE_FIELD_NOTIFICATION_DECLARE_ENUM_FIELD_END()
    UE_FIELD_NOTIFICATION_DECLARE_CLASS_DESCRIPTOR_BASE_END();
 
    // Common Bindings - If you add any new common binding, you must provide a UPropertyBinding for it.
    //                   all primitive binding in UMG goes through native binding evaluators to prevent
    //                   thunking through the VM.
    DECLARE_DYNAMIC_DELEGATE_RetVal(bool, FGetBool);
    DECLARE_DYNAMIC_DELEGATE_RetVal(float, FGetFloat);
    DECLARE_DYNAMIC_DELEGATE_RetVal(int32, FGetInt32);
    DECLARE_DYNAMIC_DELEGATE_RetVal(FText, FGetText);
    DECLARE_DYNAMIC_DELEGATE_RetVal(FSlateColor, FGetSlateColor);
    DECLARE_DYNAMIC_DELEGATE_RetVal(FLinearColor, FGetLinearColor);
    DECLARE_DYNAMIC_DELEGATE_RetVal(FSlateBrush, FGetSlateBrush);
    DECLARE_DYNAMIC_DELEGATE_RetVal(ESlateVisibility, FGetSlateVisibility);
    DECLARE_DYNAMIC_DELEGATE_RetVal(EMouseCursor::Type, FGetMouseCursor);
    DECLARE_DYNAMIC_DELEGATE_RetVal(ECheckBoxState, FGetCheckBoxState);
    DECLARE_DYNAMIC_DELEGATE_RetVal(UWidget*, FGetWidget);
 
    // Events
    DECLARE_DYNAMIC_DELEGATE_RetVal_OneParam(UWidget*, FGenerateWidgetForString, FString, Item);
    DECLARE_DYNAMIC_DELEGATE_RetVal_OneParam(UWidget*, FGenerateWidgetForObject, UObject*, Item);
 
    // Events
    DECLARE_DYNAMIC_DELEGATE_RetVal(FEventReply, FOnReply);
    DECLARE_DYNAMIC_DELEGATE_RetVal_TwoParams(FEventReply, FOnPointerEvent, FGeometry, MyGeometry, const FPointerEvent&, MouseEvent);
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnWidgetStateBroadcast, UWidget* /*InWidget*/, const FWidgetStateBitfield& /*InStateBitfield*/);
 
    typedef TFunctionRef<TSharedPtr<SObjectWidget>( UUserWidget*, TSharedRef<SWidget> )> ConstructMethodType;
 
    UPROPERTY(Instanced, TextExportTransient, EditAnywhere, BlueprintReadOnly, Category=Layout, meta=(ShowOnlyInnerProperties))
    TObjectPtr<UPanelSlot> Slot;
 
    UPROPERTY()
    FGetBool bIsEnabledDelegate;
 
    UPROPERTY()
    FGetText ToolTipTextDelegate;
 
    UE_DEPRECATED(5.1, "Direct access to ToolTipText is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, BlueprintSetter="SetToolTipText", Category="Behavior", meta=(MultiLine=true))
    FText ToolTipText;
 
    UE_DEPRECATED(5.1, "Direct access to ToolTipWidget is deprecated. Please use the getter or setter.")
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Getter="GetToolTip", Setter="SetToolTip", BlueprintSetter="SetToolTip", Category="Behavior", AdvancedDisplay)
    TObjectPtr<UWidget> ToolTipWidget;
 
    UPROPERTY()
    FGetWidget ToolTipWidgetDelegate;
 
 
    UPROPERTY()
    FGetSlateVisibility VisibilityDelegate;;
 
public:
 
    UE_DEPRECATED(5.1, "Direct access to RenderTransform is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, BlueprintSetter="SetRenderTransform", Category="Render Transform", meta = (DisplayName = "Transform"))
    FWidgetTransform RenderTransform;
 
    UE_DEPRECATED(5.1, "Direct access to RenderTransformPivot is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, BlueprintSetter="SetRenderTransformPivot", Category="Render Transform", meta=( DisplayName="Pivot" ))
    FVector2D RenderTransformPivot;
 
    UE_DEPRECATED(5.1, "Direct access to FlowDirectionPreference is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, Category="Localization")
    EFlowDirectionPreference FlowDirectionPreference;
 
    UPROPERTY()
    uint8 bIsVariable:1;
 
    UPROPERTY(Transient)
    uint8 bCreatedByConstructionScript:1;
 
    UE_DEPRECATED(5.1, "Direct access to bIsEnabled is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, FieldNotify, Getter="GetIsEnabled", Setter="SetIsEnabled", BlueprintGetter="GetIsEnabled", BlueprintSetter="SetIsEnabled", Category="Behavior")
    uint8 bIsEnabled:1;
 
    UPROPERTY(EditAnywhere, Category="Behavior", meta=(InlineEditConditionToggle))
    uint8 bOverride_Cursor : 1;
 
#if WITH_EDITORONLY_DATA
    // These editor-only properties exist for two reasons:
    //   1. To make details customization easier to write, specifically in regards to the binding extension widget
    //   2. To allow subclasses to set their default values without having to subclass USlateAccessibleWidgetData
    // Every time one of these properties changes, it's data is propagated to AccessibleWidgetData if it exists.
    // The creations of AccessibleWidgetData is controlled by the details customization through a CheckBox.
    // The reason this is set up like this is to reduce the memory footprint of UWidget since overriding the default
    // accessibility rules for a particular widget will be relatively rare. In a shipped game, if no custom rules
    // are defined, there will only be the memory cost of the UObject pointer.
    //
    // IMPORTANT: Any user-editable variables added to USlateAccessibleWidgetData should be duplicated here as well.
    //            Additionally, its edit condition must be manually assigned in UMGDetailCustomizations.
 
    UPROPERTY(EditAnywhere, Category="Accessibility")
    uint8 bOverrideAccessibleDefaults : 1;
 
    UPROPERTY(EditAnywhere, Category="Accessibility", meta=(EditCondition="bOverrideAccessibleDefaults"))
    uint8 bCanChildrenBeAccessible : 1;
 
    UPROPERTY(EditAnywhere, Category="Accessibility", meta=(EditCondition="bOverrideAccessibleDefaults"))
    ESlateAccessibleBehavior AccessibleBehavior;
 
    UPROPERTY(EditAnywhere, Category="Accessibility", AdvancedDisplay, meta=(EditCondition="bOverrideAccessibleDefaults"))
    ESlateAccessibleBehavior AccessibleSummaryBehavior;
 
    UPROPERTY(EditAnywhere, Category="Accessibility", meta=(MultiLine=true))
    FText AccessibleText;
 
    UPROPERTY()
    USlateAccessibleWidgetData::FGetText AccessibleTextDelegate;
 
    UPROPERTY(EditAnywhere, Category="Accessibility", meta=(MultiLine=true), AdvancedDisplay)
    FText AccessibleSummaryText;
 
    UPROPERTY()
    USlateAccessibleWidgetData::FGetText AccessibleSummaryTextDelegate;
#endif
 
protected:
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Performance")
    uint8 bIsVolatile:1;
 
    uint8 bIsManagedByGameViewportSubsystem:1;
 
    bool bShouldBroadcastState : 1;
 
    bool bWidgetStateInitialized : 1;
 
public:
    UPROPERTY(Transient)
    uint8 bWrappedByComponent : 1;
 
public:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bHiddenInDesigner:1;
 
    UPROPERTY()
    uint8 bExpandedInDesigner:1;
 
    UPROPERTY()
    uint8 bLockedInDesigner:1;
#endif
 
    UE_DEPRECATED(5.1, "Direct access to Cursor is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, BlueprintSetter="SetCursor", Category="Behavior", AdvancedDisplay, meta = (editcondition = "bOverride_Cursor"))
    TEnumAsByte<EMouseCursor::Type> Cursor;
 
    UE_DEPRECATED(5.1, "Direct access to Clipping is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, Category="Rendering")
    EWidgetClipping Clipping;
 
    UE_DEPRECATED(5.1, "Direct access to Visibility is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, FieldNotify, Getter, Setter, BlueprintGetter="GetVisibility", BlueprintSetter="SetVisibility", Category="Behavior")
    ESlateVisibility Visibility;
    
private:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, Category = "Rendering", meta=(AllowPrivateAccess = true))
    EWidgetPixelSnapping PixelSnapping;
 
protected:
 
    UE_DEPRECATED(5.1, "Direct access to RenderOpacity is deprecated. Please use the getter or setter.")
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Getter, Setter, BlueprintGetter="GetRenderOpacity", BlueprintSetter="SetRenderOpacity", Category="Rendering", meta = (UIMin = "0", UIMax = "1"))
    float RenderOpacity;
 
private:
    UPROPERTY(Instanced)
    TObjectPtr<USlateAccessibleWidgetData> AccessibleWidgetData;
 
public:
    UPROPERTY(Instanced, EditAnywhere, BlueprintReadOnly, Category="Navigation")
    TObjectPtr<class UWidgetNavigation> Navigation;
 
#if WITH_EDITORONLY_DATA
 
    TWeakObjectPtr<UObject> WidgetGeneratedBy;
    
#endif
 
public:
 
#if WITH_EDITOR
 
    bool IsLockedInDesigner() const
    {
        return bLockedInDesigner;
    }
 
    virtual void SetLockedInDesigner(bool NewLockedInDesigner)
    {
        bLockedInDesigner = NewLockedInDesigner;
    }
 
#endif
 
#if UE_HAS_WIDGET_GENERATED_BY_CLASS
    TWeakObjectPtr<UClass> WidgetGeneratedByClass;
#endif
 
public:
    UMG_API const FWidgetTransform& GetRenderTransform() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget|Transform")
    UMG_API void SetRenderTransform(FWidgetTransform InTransform);
 
    UFUNCTION(BlueprintCallable, Category="Widget|Transform")
    UMG_API void SetRenderScale(FVector2D Scale);
 
    UFUNCTION(BlueprintCallable, Category="Widget|Transform")
    UMG_API void SetRenderShear(FVector2D Shear);
 
    UFUNCTION(BlueprintCallable, Category="Widget|Transform")
    UMG_API void SetRenderTransformAngle(float Angle);
    
    UFUNCTION(BlueprintCallable, Category = "Widget|Transform")
    UMG_API float GetRenderTransformAngle() const;
    
    UFUNCTION(BlueprintCallable, Category="Widget|Transform")
    UMG_API void SetRenderTranslation(FVector2D Translation);
 
    UMG_API FVector2D GetRenderTransformPivot() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget|Transform")
    UMG_API void SetRenderTransformPivot(FVector2D Pivot);
 
    UMG_API EFlowDirectionPreference GetFlowDirectionPreference() const;
 
    UMG_API void SetFlowDirectionPreference(EFlowDirectionPreference FlowDirection);
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API bool GetIsEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API virtual void SetIsEnabled(bool bInIsEnabled);
 
    /* @return true if the widget was added to the viewport using AddToViewport or AddToPlayerScreen. */
    UFUNCTION(BlueprintPure, BlueprintCosmetic, Category = "Appearance")
    UMG_API bool IsInViewport() const;
 
    UMG_API FText GetToolTipText() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void SetToolTipText(const FText& InToolTipText);
 
    UMG_API UWidget* GetToolTip() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void SetToolTip(UWidget* Widget);
 
    UMG_API EMouseCursor::Type GetCursor() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void SetCursor(EMouseCursor::Type InCursor);
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void ResetCursor();
    
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API bool IsRendered() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API bool IsVisible() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API ESlateVisibility GetVisibility() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API virtual void SetVisibility(ESlateVisibility InVisibility);
 
protected:
    UMG_API void SetVisibilityInternal(ESlateVisibility InVisibility);
 
public:
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API float GetRenderOpacity() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void SetRenderOpacity(float InOpacity);
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API EWidgetClipping GetClipping() const;
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API void SetClipping(EWidgetClipping InClipping);
    
    UMG_API EWidgetPixelSnapping GetPixelSnapping() const;
 
    UMG_API void SetPixelSnapping(EWidgetPixelSnapping InPixelSnapping);
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void ForceVolatile(bool bForce);
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API virtual bool IsHovered() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API bool HasKeyboardFocus() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API bool HasMouseCapture() const;
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API bool HasMouseCaptureByUser(int32 UserIndex, int32 PointerIndex = -1) const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void SetKeyboardFocus();
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API bool HasUserFocus(APlayerController* PlayerController) const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API bool HasAnyUserFocus() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget", meta=(DisplayName="HasAnyUserFocusedDescendants"))
    UMG_API bool HasFocusedDescendants() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API bool HasUserFocusedDescendants(APlayerController* PlayerController) const;
    
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void SetFocus();
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void SetUserFocus(APlayerController* PlayerController);
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void ForceLayoutPrepass();
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API void InvalidateLayoutAndVolatility();
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API FVector2D GetDesiredSize() const;
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API void SetAllNavigationRules(EUINavigationRule Rule, FName WidgetToFocus);
 
    UE_DEPRECATED(4.23, "SetNavigationRule is deprecated. Please use either SetNavigationRuleBase or SetNavigationRuleExplicit or SetNavigationRuleCustom or SetNavigationRuleCustomBoundary.")
    UFUNCTION(BlueprintCallable, Category = "Widget", meta = (DeprecatedFunction, DeprecatedMessage = "Please use either SetNavigationRuleBase or SetNavigationRuleExplicit or SetNavigationRuleCustom or SetNavigationRuleCustomBoundary."))
    UMG_API void SetNavigationRule(EUINavigation Direction, EUINavigationRule Rule, FName WidgetToFocus);
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API void SetNavigationRuleBase(EUINavigation Direction, EUINavigationRule Rule);
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API void SetNavigationRuleExplicit(EUINavigation Direction, UWidget* InWidget);
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API void SetNavigationRuleCustom(EUINavigation Direction, FCustomWidgetNavigationDelegate InCustomDelegate);
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API void SetNavigationRuleCustomBoundary(EUINavigation Direction, FCustomWidgetNavigationDelegate InCustomDelegate);
 
    UMG_API void SetNavigationMethod(const TInstancedStruct<FNavigationMethod>& NavigationMethod);
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API class UPanelWidget* GetParent() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API virtual void RemoveFromParent();
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API const FGeometry& GetCachedGeometry() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API const FGeometry& GetTickSpaceGeometry() const;
 
    UFUNCTION(BlueprintCallable, Category="Widget")
    UMG_API const FGeometry& GetPaintSpaceGeometry() const;
 
    //~ Begin INotifyFieldValueChanged Interface
public:
    UMG_API virtual FDelegateHandle AddFieldValueChangedDelegate(UE::FieldNotification::FFieldId InFieldId, FFieldValueChangedDelegate InNewDelegate) override final;
    UMG_API virtual bool RemoveFieldValueChangedDelegate(UE::FieldNotification::FFieldId InFieldId, FDelegateHandle InHandle) override final;
    UMG_API virtual int32 RemoveAllFieldValueChangedDelegates(FDelegateUserObjectConst InUserObject) override final;
    UMG_API virtual int32 RemoveAllFieldValueChangedDelegates(UE::FieldNotification::FFieldId InFieldId, FDelegateUserObjectConst InUserObject) override final;
    UMG_API virtual void BroadcastFieldValueChanged(UE::FieldNotification::FFieldId InFieldId) override final;
    //~ End INotifyFieldValueChanged Interface
 
    UFUNCTION(BlueprintCallable, Category = "FieldNotify", meta = (DisplayName = "Add Field Value Changed Delegate", ScriptName = "AddFieldValueChangedDelegate"))
    UMG_API void K2_AddFieldValueChangedDelegate(FFieldNotificationId FieldId, FFieldValueChangedDynamicDelegate Delegate);
 
    UFUNCTION(BlueprintCallable, Category = "FieldNotify", meta = (DisplayName = "Remove Field Value Changed Delegate", ScriptName="RemoveFieldValueChangedDelegate"))
    UMG_API void K2_RemoveFieldValueChangedDelegate(FFieldNotificationId FieldId, FFieldValueChangedDynamicDelegate Delegate);
 
protected:
    UFUNCTION(BlueprintCallable, Category="FieldNotify", meta = (DisplayName="Broadcast Field Value Changed", ScriptName="BroadcastFieldValueChanged"))
    UMG_API void K2_BroadcastFieldValueChanged(FFieldNotificationId FieldId);
 
public:
    UMG_API TSharedRef<SWidget> TakeWidget();
 
    template <class WidgetType = SObjectWidget>
    TSharedRef<WidgetType> TakeDerivedWidget(ConstructMethodType ConstructMethod)
    {
        static_assert(TIsDerivedFrom<WidgetType, SObjectWidget>::IsDerived, "TakeDerivedWidget can only be used to create SObjectWidget instances");
        return StaticCastSharedRef<WidgetType>(TakeWidget_Private(ConstructMethod));
    }
    
private:
    UMG_API TSharedRef<SWidget> TakeWidget_Private( ConstructMethodType ConstructMethod );
 
public:
 
    UMG_API TSharedPtr<SWidget> GetCachedWidget() const;
 
    UMG_API TSharedPtr<SWidget> GetCachedWrappedWidget() const;
 
 
    UMG_API bool IsConstructed() const;
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "Widget")
    UMG_API UGameInstance* GetGameInstance() const;
 
    template <class TGameInstance = UGameInstance>
    TGameInstance* GetGameInstance() const
    {
        return Cast<TGameInstance>(GetGameInstance());
    }
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "Widget")
    UMG_API virtual APlayerController* GetOwningPlayer() const;
 
    template <class TPlayerController = APlayerController >
    TPlayerController* GetOwningPlayer() const
    {
        return Cast<TPlayerController>(GetOwningPlayer());
    }
 
    UFUNCTION(BlueprintCallable, BlueprintCosmetic, Category = "Widget")
    UMG_API virtual ULocalPlayer* GetOwningLocalPlayer() const;
    
    template < class T >
    T* GetOwningLocalPlayer() const
    {
        return Cast<T>(GetOwningLocalPlayer());
    }
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API FText GetAccessibleText() const;
 
    UFUNCTION(BlueprintCallable, Category = "Widget")
    UMG_API FText GetAccessibleSummaryText() const;
    
    UMG_API virtual void SynchronizeProperties();
 
    UMG_API void BuildNavigation();
 
#if WITH_EDITOR
    inline bool IsDesignTime() const
    {
        return HasAnyDesignerFlags(EWidgetDesignFlags::Designing);
    }
 
    UMG_API virtual void SetDesignerFlags(EWidgetDesignFlags NewFlags);
 
    inline EWidgetDesignFlags GetDesignerFlags() const
    {
        return static_cast<EWidgetDesignFlags>(DesignerFlags);
    }
 
    inline bool HasAnyDesignerFlags(EWidgetDesignFlags FlagsToCheck) const
    {
        return EnumHasAnyFlags(GetDesignerFlags(), FlagsToCheck);
    }
    
    inline bool IsPreviewTime() const 
    {
        return HasAnyDesignerFlags(EWidgetDesignFlags::Previewing);
    }
 
    const FString& GetDisplayLabel() const
    {
        return DisplayLabel;
    }
 
    UMG_API void SetDisplayLabel(const FString& DisplayLabel);
 
    UMG_API const FString& GetCategoryName() const;
 
    UMG_API void SetCategoryName(const FString& InValue);
 
    virtual void ValidateCompiledDefaults(class IWidgetCompilerLog& CompileLog) const {}
 
    UMG_API virtual bool Modify(bool bAlwaysMarkDirty = true) override;
#else
    inline bool IsDesignTime() const { return false; }
    inline bool IsPreviewTime() const { return false; }
#endif
    
    UMG_API bool IsChildOf(UWidget* PossibleParent);
 
    UMG_API bool AddBinding(FDelegateProperty* DelegateProperty, UObject* SourceObject, const FDynamicPropertyPath& BindingPath);
 
    UMG_API FDelegateHandle RegisterPostStateListener(const FOnWidgetStateBroadcast::FDelegate& ListenerDelegate, bool bBroadcastCurrentState = true);
 
    UMG_API void UnregisterPostStateListener(const FDelegateHandle& ListenerDelegate);
 
    static UMG_API TSubclassOf<UPropertyBinding> FindBinderClassForDestination(FProperty* Property);
 
    //~ Begin UObject
    UMG_API virtual UWorld* GetWorld() const override;
    UMG_API virtual void BeginDestroy() override;
    UMG_API virtual void FinishDestroy() override;
    UMG_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    //~ End UObject
 
    inline bool CanSafelyRouteEvent()
    {
        return !IsDesignTime() && CanSafelyRouteCall();
    }
 
    inline bool CanSafelyRoutePaint()
    {
        return CanSafelyRouteCall();
    }
 
protected:
    inline bool CanSafelyRouteCall() { return !(GIntraFrameDebuggingGameThread || IsUnreachable() || FUObjectThreadContext::Get().IsRoutingPostLoad); }
 
public:
 
#if WITH_EDITOR
 
    UMG_API bool IsGeneratedName() const;
 
    UMG_API virtual FString GetLabelMetadata() const;
 
    UMG_API FText GetLabelText() const;
 
    UMG_API FText GetLabelTextWithMetadata() const;
 
    UMG_API virtual const FText GetPaletteCategory();
 
    UMG_API void CreatedFromPalette();
 
    virtual void OnCreationFromPalette() { }
 
    virtual void ConnectEditorData() { }
 
    // UObject interface
    UMG_API virtual void PostEditChangeProperty(struct FPropertyChangedEvent& PropertyChangedEvent) override;
    // End of UObject interface
 
    UMG_API bool IsVisibleInDesigner() const;
 
    // Begin Designer contextual events
    UMG_API void SelectByDesigner();
    UMG_API void DeselectByDesigner();
 
    virtual void OnDesignerChanged(const FDesignerChangedEventArgs& EventArgs) { }
 
    virtual void OnSelectedByDesigner() { }
    virtual void OnDeselectedByDesigner() { }
 
    virtual void OnDescendantSelectedByDesigner(UWidget* DescendantWidget) { }
    virtual void OnDescendantDeselectedByDesigner(UWidget* DescendantWidget) { }
 
    virtual void OnBeginEditByDesigner() { }
    virtual void OnEndEditByDesigner() { }
    // End Designer contextual events
#endif
 
    // Utility methods
    //@TODO UMG: Should move elsewhere
    static UMG_API EVisibility ConvertSerializedVisibilityToRuntime(ESlateVisibility Input);
    static UMG_API ESlateVisibility ConvertRuntimeToSerializedVisibility(const EVisibility& Input);
 
    static UMG_API FSizeParam ConvertSerializedSizeParamToRuntime(const FSlateChildSize& Input);
 
    static UMG_API UWidget* FindChildContainingDescendant(UWidget* Root, UWidget* Descendant);
 
    static UMG_API FString GetDefaultFontName();
 
protected:
#if WITH_EDITOR
    // This is an implementation detail that allows us to show and hide the widget in the designer
    // regardless of the actual visibility state set by the user.
    UMG_API EVisibility GetVisibilityInDesigner() const;
 
    UMG_API bool IsEditorWidget() const;
#endif
 
    UMG_API virtual void OnBindingChanged(const FName& Property);
 
    UMG_API void BroadcastBinaryPostStateChange(const FWidgetStateBitfield& StateChange, bool bInValue);
 
    UE_DEPRECATED(5.5, "FWidgetStateBitfield currently no longer supports enum states")
    UMG_API void BroadcastEnumPostStateChange(const FWidgetStateBitfield& StateChange);
 
protected:
    UMG_API UObject* GetSourceAssetOrClass() const;
 
    UMG_API virtual TSharedRef<SWidget> RebuildWidget();
 
    UMG_API virtual void OnWidgetRebuilt();
    
#if WITH_EDITOR
    UMG_API virtual TSharedRef<SWidget> RebuildDesignWidget(TSharedRef<SWidget> Content);
 
    UMG_API TSharedRef<SWidget> CreateDesignerOutline(TSharedRef<SWidget> Content) const;
 
    UMG_API FText GetDisplayNameBase() const;
#endif
 
    UMG_API void UpdateRenderTransform();
 
    UMG_API void SynchronizeAccessibleData();
 
protected:
    //TODO UMG Consider moving conversion functions into another class.
    // Conversion functions
    EVisibility ConvertVisibility(TAttribute<ESlateVisibility> SerializedType) const
    {
        ESlateVisibility SlateVisibility = SerializedType.Get();
        return ConvertSerializedVisibilityToRuntime(SlateVisibility);
    }
 
    TOptional<float> ConvertFloatToOptionalFloat(TAttribute<float> InFloat) const
    {
        return InFloat.Get();
    }
 
    FSlateColor ConvertLinearColorToSlateColor(TAttribute<FLinearColor> InLinearColor) const
    {
        return FSlateColor(InLinearColor.Get());
    }
 
    UMG_API void SetNavigationRuleInternal(EUINavigation Direction, EUINavigationRule Rule, FName WidgetToFocus = NAME_None, UWidget* InWidget = nullptr, FCustomWidgetNavigationDelegate InCustomDelegate = FCustomWidgetNavigationDelegate());
 
#if WITH_ACCESSIBILITY
    UMG_API virtual TSharedPtr<SWidget> GetAccessibleWidget() const;
#endif
 
protected:
    TWeakPtr<SWidget> MyWidget;
 
    TWeakPtr<SWidget> ComponentWrapperWidget;
    
    TWeakPtr<SObjectWidget> MyGCWidget;
 
    FWidgetStateBitfield MyWidgetStateBitfield;
 
    FOnWidgetStateBroadcast PostWidgetStateChanged;
 
    UPROPERTY(Transient)
    TArray<TObjectPtr<UPropertyBinding>> NativeBindings;
 
    static UMG_API TArray<TSubclassOf<UPropertyBinding>> BinderClasses;
 
private:
    TBitArray<> EnabledFieldNotifications;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient)
    uint8 DesignerFlags;
 
    UPROPERTY()
    FString DisplayLabel;
 
    TWeakPtr<SWidget> DesignWrapperWidget;
 
    UPROPERTY()
    FString CategoryName;
#endif
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
    UMG_API void VerifySynchronizeProperties();
 
    bool bRoutedSynchronizeProperties;
 
#else
    inline void VerifySynchronizeProperties() { }
#endif
 
private:
    PROPERTY_BINDING_IMPLEMENTATION(FText, ToolTipText);
    PROPERTY_BINDING_IMPLEMENTATION(bool, bIsEnabled);
#if WITH_EDITORONLY_DATA
    PROPERTY_BINDING_IMPLEMENTATION(FText, AccessibleText);
    PROPERTY_BINDING_IMPLEMENTATION(FText, AccessibleSummaryText);
#endif
};