/work/Engine/Source/Runtime/UMG/Public/Components/Widget.h

Gets the underlying slate widget or constructs it if it doesn't exist.

Parameters

ConstructMethod

allows the caller to specify a custom constructor that will be provided the default parameters we use to construct the slate widget, this allows the caller to construct derived types of SObjectWidget in cases where additional functionality at the slate level is desirable.

class SObjectWidgetCustom : public SObjectWidget, public IMixinBehavior { }

Widget->TakeDerivedWidget<SObjectWidgetCustom>( []( UUserWidget* Widget, TSharedRef<SWidget> Content ) { return SNew( SObjectWidgetCustom, Widget ) [ Content ]; });

// 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
};