SWindow.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/CoreDelegates.h"
#include "Misc/Attribute.h"
#include "Layout/Margin.h"
#include "Styling/SlateColor.h"
#include "Layout/SlateRect.h"
#include "Layout/Visibility.h"
#include "Rendering/SlateLayoutTransform.h"
#include "Layout/Geometry.h"
#include "Input/CursorReply.h"
#include "GenericPlatform/GenericApplicationMessageHandler.h"
#include "GenericPlatform/GenericWindowDefinition.h"
#include "GenericPlatform/GenericWindow.h"
#include "Input/Reply.h"
#include "Rendering/RenderingCommon.h"
#include "Types/SlateStructs.h"
#include "Animation/CurveSequence.h"
#include "Styling/SlateWidgetStyleAsset.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "SlotBase.h"
#include "Widgets/SWidget.h"
#include "Widgets/SCompoundWidget.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/SOverlay.h"
#include "Styling/SlateTypes.h"
#include "Styling/CoreStyle.h"
#include "FastUpdate/SlateInvalidationRoot.h"
 
class FActiveTimerHandle;
class FHittestGrid;
class FPaintArgs;
class FSlateWindowElementList;
class FWidgetPath;
class IWindowTitleBar;
class SPopupLayer;
class SWindow;
class SImage;
 
enum class EUpdateFastPathReason : uint8;
 
DECLARE_DELEGATE( FOnWindowActivated );
DECLARE_MULTICAST_DELEGATE( FOnWindowActivatedEvent );
 
DECLARE_DELEGATE( FOnWindowDeactivated );
DECLARE_MULTICAST_DELEGATE( FOnWindowDeactivatedEvent );
 
DECLARE_DELEGATE_OneParam( FOnWindowClosed, const TSharedRef<SWindow>& );
DECLARE_MULTICAST_DELEGATE_OneParam( FOnWindowClosedEvent, const TSharedRef<SWindow>& );
 
DECLARE_DELEGATE_OneParam( FOnWindowMoved, const TSharedRef<SWindow>& );
 
DECLARE_DELEGATE_OneParam( FRequestDestroyWindowOverride, const TSharedRef<SWindow>& );
 
DECLARE_DELEGATE_RetVal_OneParam( int32, FOnSwitchWorldHack, int32 );
 
 
enum class EAutoCenter : uint8
{
    None,
 
    PrimaryWorkArea,
 
    PreferredWorkArea,
};
 
 
enum class ESizingRule : uint8
{
    /* The windows size fixed and cannot be resized **/
    FixedSize,
 
    Autosized,
 
    UserSized,
};
 
namespace SWindowDefs
{
    inline constexpr float DefaultTitleBarSize = 34.0f;
}
 
struct FWindowTransparency
{
    FWindowTransparency(EWindowTransparency In) : Value(In) {}
    
    EWindowTransparency Value;
};
 
class FOverlayPopupLayer : public FPopupLayer
{
public:
    FOverlayPopupLayer(const TSharedRef<SWindow>& InitHostWindow, const TSharedRef<SWidget>& InitPopupContent, TSharedPtr<SOverlay> InitOverlay);
 
    virtual void Remove() override;
    virtual FSlateRect GetAbsoluteClientRect() override;
 
private:
    TSharedPtr<SWindow> HostWindow;
    TSharedPtr<SOverlay> Overlay;
};
 
 
struct FPopupLayerSlot : public TSlotBase<FPopupLayerSlot>
{
public:
    FPopupLayerSlot()
        : TSlotBase<FPopupLayerSlot>()
        , DesktopPosition_Attribute(FVector2D::ZeroVector)
        , WidthOverride_Attribute()
        , HeightOverride_Attribute()
        , Scale_Attribute(1.0f)
        , Clamp_Attribute(false)
        , ClampBuffer_Attribute(FVector2D::ZeroVector)
    {}
 
    SLATE_SLOT_BEGIN_ARGS(FPopupLayerSlot, TSlotBase<FPopupLayerSlot>)
        SLATE_ATTRIBUTE(FVector2D, DesktopPosition)
        SLATE_ATTRIBUTE(float, WidthOverride)
        SLATE_ATTRIBUTE(float, HeightOverride)
        SLATE_ATTRIBUTE(float, Scale)
        SLATE_ATTRIBUTE(bool, ClampToWindow)
        SLATE_ATTRIBUTE(FVector2D, ClampBuffer)
    SLATE_SLOT_END_ARGS()
 
    void Construct(const FChildren& SlotOwner, FSlotArguments&& InArgs)
    {
        if (InArgs._DesktopPosition.IsSet())
        {
            SetDesktopPosition(MoveTemp(InArgs._DesktopPosition));
        }
        if (InArgs._WidthOverride.IsSet())
        {
            SetWidthOverride(MoveTemp(InArgs._WidthOverride));
        }
        if (InArgs._HeightOverride.IsSet())
        {
            SetHeightOverride(MoveTemp(InArgs._HeightOverride));
        }
        if (InArgs._Scale.IsSet())
        {
            SetScale(MoveTemp(InArgs._Scale));
        }
        if (InArgs._ClampToWindow.IsSet())
        {
            SetClampToWindow(MoveTemp(InArgs._ClampToWindow));
        }
        if (InArgs._ClampBuffer.IsSet())
        {
            SetClampBuffer(MoveTemp(InArgs._ClampBuffer));
        }
        TSlotBase<FPopupLayerSlot>::Construct(SlotOwner, MoveTemp(InArgs));
    }
 
    void SetDesktopPosition(TAttribute<FVector2D> InDesktopPosition)
    {
        DesktopPosition_Attribute = MoveTemp(InDesktopPosition);
    }
 
    void SetWidthOverride(TAttribute<float> InWidthOverride)
    {
        WidthOverride_Attribute = MoveTemp(InWidthOverride);
    }
 
    void SetHeightOverride(TAttribute<float> InHeightOverride)
    {
        HeightOverride_Attribute = MoveTemp(InHeightOverride);
    }
 
    void SetScale(TAttribute<float> InScale)
    {
        Scale_Attribute = MoveTemp(InScale);
    }
 
    void SetClampToWindow(TAttribute<bool> InClamp_Attribute)
    {
        Clamp_Attribute = MoveTemp(InClamp_Attribute);
    }
 
    void SetClampBuffer(TAttribute<FVector2D> InClampBuffer_Attribute)
    {
        ClampBuffer_Attribute = MoveTemp(InClampBuffer_Attribute);
    }
 
private:
    friend class SPopupLayer;
    friend class TPanelChildren<FPopupLayerSlot>;
 
    TAttribute<FVector2D> DesktopPosition_Attribute;
    TAttribute<float> WidthOverride_Attribute;
    TAttribute<float> HeightOverride_Attribute;
    TAttribute<float> Scale_Attribute;
    TAttribute<bool> Clamp_Attribute;
    TAttribute<FVector2D> ClampBuffer_Attribute;
};
 
 
class SWindow
    : public SCompoundWidget
    , public FSlateInvalidationRoot
{
 
public:
 
    SLATE_BEGIN_ARGS( SWindow )
        : _Type( EWindowType::Normal )
        , _Style( &FCoreStyle::Get().GetWidgetStyle<FWindowStyle>("Window") )
        , _Title()
        , _bDragAnywhere( false )
        , _AutoCenter( EAutoCenter::PreferredWorkArea )
        , _ScreenPosition( FVector2f::ZeroVector )
        , _ClientSize( FVector2f::ZeroVector )
        , _AdjustInitialSizeAndPositionForDPIScale(true)
        , _SupportsTransparency( EWindowTransparency::None )
        , _InitialOpacity( 1.0f )
        , _IsInitiallyMaximized( false )
        , _IsInitiallyMinimized(false)
        , _SizingRule( ESizingRule::UserSized )
        , _IsPopupWindow( false )
        , _IsTopmostWindow( false )
        , _FocusWhenFirstShown(true)
        , _FocusUserIndex( INDEX_NONE )
        , _ActivationPolicy( EWindowActivationPolicy::Always )
        , _UseOSWindowBorder( false )
        , _HasCloseButton( true )
        , _SupportsMaximize( true )
        , _SupportsMinimize( true )
        , _ShouldPreserveAspectRatio( false )
        , _CreateTitleBar( true )
        , _SaneWindowPlacement( true )
        , _LayoutBorder( _Style->BorderPadding )
        , _UserResizeBorder(FMargin(5, 5, 5, 5))
        , _bManualManageDPI( false )
        , _CloseButtonToolTipText(NSLOCTEXT("SWindow", "Window_DefaultCloseButtonToolTip", "Close"))
    {
    }
 
        SLATE_ARGUMENT( EWindowType, Type )
 
        
        SLATE_STYLE_ARGUMENT( FWindowStyle, Style )
 
        
        SLATE_ATTRIBUTE( FText, Title )
 
        
        SLATE_ARGUMENT( bool, bDragAnywhere )
 
        
        SLATE_ARGUMENT( EAutoCenter, AutoCenter )
 
        
        SLATE_ARGUMENT( UE::Slate::FDeprecateVector2DParameter, ScreenPosition )
 
        
        SLATE_ARGUMENT( UE::Slate::FDeprecateVector2DParameter, ClientSize )
 
        
        SLATE_ARGUMENT( bool, AdjustInitialSizeAndPositionForDPIScale )
 
        
        SLATE_ARGUMENT( FWindowTransparency, SupportsTransparency )
 
        
        SLATE_ARGUMENT( float, InitialOpacity )
 
        
        SLATE_ARGUMENT( bool, IsInitiallyMaximized )
        
        
        SLATE_ARGUMENT(bool, IsInitiallyMinimized)
 
        
        SLATE_ARGUMENT( ESizingRule, SizingRule )
 
        
        SLATE_ARGUMENT( bool, IsPopupWindow )
 
        
        SLATE_ARGUMENT(bool, IsTopmostWindow)
 
        
        SLATE_ARGUMENT( bool, FocusWhenFirstShown )
 
        
        SLATE_ARGUMENT( int32, FocusUserIndex )
 
        
        SLATE_ARGUMENT( EWindowActivationPolicy, ActivationPolicy )
 
        
        SLATE_ARGUMENT( bool, UseOSWindowBorder )
 
        
        SLATE_ARGUMENT( bool, HasCloseButton )
 
        
        SLATE_ARGUMENT( bool, SupportsMaximize )
        
        
        SLATE_ARGUMENT( bool, SupportsMinimize )
 
        
        SLATE_ARGUMENT( bool, ShouldPreserveAspectRatio )
 
        
        SLATE_ARGUMENT( TOptional<float>, MinWidth )
        
        
        SLATE_ARGUMENT( TOptional<float>, MinHeight )
        
        
        SLATE_ARGUMENT( TOptional<float>, MaxWidth )
 
        
        SLATE_ARGUMENT( TOptional<float>, MaxHeight )
 
        
        SLATE_ARGUMENT( bool, CreateTitleBar )
 
        
        SLATE_ARGUMENT( bool, SaneWindowPlacement )
 
        
        SLATE_ARGUMENT(FMargin, LayoutBorder)
 
        
        SLATE_ARGUMENT(FMargin, UserResizeBorder)
 
        
        SLATE_ARGUMENT(bool, bManualManageDPI)
 
        SLATE_DEFAULT_SLOT( FArguments, Content )
 
        
        SLATE_ATTRIBUTE(FText, CloseButtonToolTipText)
 
        SLATE_END_ARGS()
 
    
    SLATECORE_API SWindow();
    SLATECORE_API ~SWindow();
 
public:
 
    SLATECORE_API void Construct(const FArguments& InArgs);
 
    static SLATECORE_API TSharedRef<SWindow> MakeToolTipWindow();
 
    static SLATECORE_API TSharedRef<SWindow> MakeCursorDecorator();
 
    static SLATECORE_API TSharedRef<SWindow> MakeStyledCursorDecorator(const FWindowStyle& InStyle);
 
    static SLATECORE_API TSharedRef<SWindow> MakeNotificationWindow();
 
    static SLATECORE_API UE::Slate::FDeprecateVector2DResult ComputeWindowSizeForContent( UE::Slate::FDeprecateVector2DParameter ContentSize );
 
    EWindowType GetType() const
    {
        return Type;
    }
 
    FText GetTitle() const
    {
        return Title.Get();
    }
 
    void SetTitle( const FText& InTitle )
    {
        Title = InTitle;
        if (NativeWindow.IsValid())
        {
            NativeWindow->SetText( *InTitle.ToString() );
        }
    }
 
    SLATECORE_API int32 PaintWindow( double CurrentTime, float DeltaTime, FSlateWindowElementList& OutDrawElements, const FWidgetStyle& InWidgetStyle, bool bParentEnabled );
 
    SLATECORE_API FOptionalSize GetTitleBarSize() const;
 
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetDesiredSizeDesktopPixels() const;
 
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetInitialDesiredSizeInScreen() const;
 
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetInitialDesiredPositionInScreen() const;
 
    SLATECORE_API FGeometry GetWindowGeometryInScreen() const;
 
    SLATECORE_API FGeometry GetWindowGeometryInWindow() const;
 
    SLATECORE_API FSlateLayoutTransform GetLocalToScreenTransform() const;
 
    SLATECORE_API FSlateLayoutTransform GetLocalToWindowTransform() const;
 
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetPositionInScreen() const;
 
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetSizeInScreen() const;
 
    SLATECORE_API FSlateRect GetNonMaximizedRectInScreen() const;
 
    SLATECORE_API FSlateRect GetRectInScreen() const;
 
    SLATECORE_API FSlateRect GetClientRectInScreen() const;
 
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetClientSizeInScreen() const;
 
    SLATECORE_API FSlateRect GetClippingRectangleInWindow() const;
 
    SLATECORE_API FMargin GetWindowBorderSize( bool bIncTitleBar = false ) const;
 
    SLATECORE_API FMargin GetNonMaximizedWindowBorderSize() const;
 
    SLATECORE_API void MoveWindowTo( UE::Slate::FDeprecateVector2DParameter NewPosition );
    SLATECORE_API void ReshapeWindow( UE::Slate::FDeprecateVector2DParameter NewPosition, UE::Slate::FDeprecateVector2DParameter NewSize );
    SLATECORE_API void ReshapeWindow( const FSlateRect& InNewShape );
    SLATECORE_API void Resize( UE::Slate::FDeprecateVector2DParameter NewClientSize );
 
    SLATECORE_API FSlateRect GetFullScreenInfo() const;
 
    SLATECORE_API bool IsMorphing() const;
    SLATECORE_API bool IsMorphingSize() const;
    SLATECORE_API void MorphToPosition( const FCurveSequence& Sequence, const float TargetOpacity, const UE::Slate::FDeprecateVector2DParameter& TargetPosition );
    SLATECORE_API void MorphToShape( const FCurveSequence& Sequence, const float TargetOpacity, const FSlateRect& TargetShape );
    SLATECORE_API void UpdateMorphTargetShape( const FSlateRect& TargetShape );
    SLATECORE_API void UpdateMorphTargetPosition( const UE::Slate::FDeprecateVector2DParameter& TargetPosition );
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetMorphTargetPosition() const;
    SLATECORE_API FSlateRect GetMorphTargetShape() const;
 
    SLATECORE_API void FlashWindow();
 
    SLATECORE_API void DrawAttention(const FWindowDrawAttentionParameters& Parameters);
 
    SLATECORE_API void BringToFront( bool bForce = false );
 
    SLATECORE_API void HACK_ForceToFront();
 
    SLATECORE_API void SetCachedScreenPosition(UE::Slate::FDeprecateVector2DParameter NewPosition);
 
    SLATECORE_API void SetCachedSize(UE::Slate::FDeprecateVector2DParameter NewSize);
 
    SLATECORE_API TSharedPtr<FGenericWindow> GetNativeWindow();
    SLATECORE_API TSharedPtr<const FGenericWindow> GetNativeWindow() const ;
 
    SLATECORE_API float GetDPIScaleFactor() const;
 
    SLATECORE_API void SetDPIScaleFactor(const float Factor);
 
    SLATECORE_API void SetManualManageDPIChanges(const bool bManualDPI);
 
    bool IsManualManageDPIChanges() const
    {
        return bManualManageDPI;
    }
 
    SLATECORE_API bool IsDescendantOf( const TSharedPtr<SWindow>& ParentWindow ) const;
 
    SLATECORE_API void SetNativeWindow( TSharedRef<FGenericWindow> InNativeWindow );
    
    SLATECORE_API void SetContent( TSharedRef<SWidget> InContent );
 
    SLATECORE_API TSharedRef<SWidget> GetContent();
 
    SLATECORE_API bool HasOverlay() const;
 
    SLATECORE_API SOverlay::FScopedWidgetSlotArguments AddOverlaySlot( const int32 ZOrder = INDEX_NONE );
 
    SLATECORE_API bool RemoveOverlaySlot(const TSharedRef<SWidget>& InContent);
 
    SLATECORE_API virtual TSharedPtr<FPopupLayer> OnVisualizePopup(const TSharedRef<SWidget>& PopupContent) override;
 
    using FScopedWidgetSlotArguments = TPanelChildren<FPopupLayerSlot>::FScopedWidgetSlotArguments;
    SLATECORE_API FScopedWidgetSlotArguments AddPopupLayerSlot();
 
    SLATECORE_API void RemovePopupLayerSlot( const TSharedRef<SWidget>& WidgetToRemove );
 
    SLATECORE_API void SetFullWindowOverlayContent( TSharedPtr<SWidget> InContent );
 
    SLATECORE_API void BeginFullWindowOverlayTransition();
 
    SLATECORE_API void EndFullWindowOverlayTransition();
 
    SLATECORE_API bool HasFullWindowOverlayContent() const;
 
    SLATECORE_API void SetNativeWindowButtonsVisibility(bool bVisible);
 
    SLATECORE_API bool AppearsInTaskbar() const;
 
    FOnWindowActivatedEvent& GetOnWindowActivatedEvent() { return WindowActivatedEvent; }
 
    FOnWindowDeactivatedEvent& GetOnWindowDeactivatedEvent() { return WindowDeactivatedEvent; }
 
    SLATECORE_API void SetOnWindowClosed( const FOnWindowClosed& InDelegate );
 
    FOnWindowClosedEvent& GetOnWindowClosedEvent() { return WindowClosedEvent; }
 
    SLATECORE_API void SetOnWindowMoved( const FOnWindowMoved& InDelegate);
 
    SLATECORE_API void SetRequestDestroyWindowOverride( const FRequestDestroyWindowOverride& InDelegate );
 
    SLATECORE_API void RequestDestroyWindow();
 
    SLATECORE_API void DestroyWindowImmediately();
 
    SLATECORE_API void NotifyWindowBeingDestroyed();
 
    SLATECORE_API void ShowWindow();
 
    SLATECORE_API void HideWindow();
 
    SLATECORE_API void EnableWindow( bool bEnable );
 
    SLATECORE_API void SetWindowMode( EWindowMode::Type WindowMode );
 
    EWindowMode::Type GetWindowMode() const { return NativeWindow->GetWindowMode(); }
 
    SLATECORE_API bool IsVisible() const;
 
    SLATECORE_API bool IsWindowMaximized() const;
 
    SLATECORE_API bool IsWindowMinimized() const;
 
    SLATECORE_API void InitialMaximize();
 
    SLATECORE_API void InitialMinimize();
 
    SLATECORE_API void SetOpacity( const float InOpacity );
 
    SLATECORE_API float GetOpacity() const;
 
    SLATECORE_API EWindowTransparency GetTransparencySupport() const;
 
    SLATECORE_API virtual FString ToString() const override;
 
    void SetWidgetToFocusOnActivate( TSharedPtr< SWidget > InWidget )
    {
        WidgetToFocusOnActivate = InWidget;
    }
 
    TWeakPtr<SWidget> GetWidgetFocusedOnDeactivate()
    {
        return WidgetFocusedOnDeactivate;
    }
 
    SLATECORE_API EWindowActivationPolicy ActivationPolicy() const;
 
    SLATECORE_API bool AcceptsInput() const;
 
    void SetAcceptsInput(bool bEnabled) { bAcceptsInput = bEnabled; }
 
    SLATECORE_API bool IsUserSized() const;
 
    SLATECORE_API bool IsAutosized() const;
 
    SLATECORE_API void SetSizingRule( ESizingRule InSizingRule );
 
    SLATECORE_API bool IsRegularWindow() const;
 
    SLATECORE_API bool IsTopmostWindow() const;
 
    bool SizeWillChangeOften() const
    {
        return bSizeWillChangeOften;
    }
 
    bool ShouldPreserveAspectRatio() const
    {
        return bShouldPreserveAspectRatio;
    }
 
    int32 GetExpectedMaxWidth() const
    {
        return ExpectedMaxWidth;
    }
 
    int32 GetExpectedMaxHeight() const
    {
        return ExpectedMaxHeight;
    }
 
    bool HasOSWindowBorder() const { return bHasOSWindowBorder; }
 
    SLATECORE_API bool IsScreenspaceMouseWithin(UE::Slate::FDeprecateVector2DParameter ScreenspaceMouseCoordinate) const;
 
    SLATECORE_API bool HasSizingFrame() const;
 
    SLATECORE_API bool HasCloseBox() const;
 
    SLATECORE_API bool HasMaximizeBox() const;
 
    SLATECORE_API bool HasMinimizeBox() const;
 
    void SetAsModalWindow()
    {
        bIsModalWindow = true;
        bHasMaximizeButton = false;
        bHasMinimizeButton = false;
    }
 
    bool IsModalWindow()
    {
        return bIsModalWindow;
    }
 
    void SetMirrorWindow(bool bSetMirrorWindow)
    {
        bIsMirrorWindow = bSetMirrorWindow;
    }
    
    void SetIsHDR(bool bHDR)
    {
        bIsHDR = bHDR;
    }
 
    bool GetIsHDR() const { return bIsHDR; }
 
    void SetViewportScaleUIOverride(float InViewportScaleUIOverride)
    {
        ViewportScaleUIOverride = InViewportScaleUIOverride;
    }
 
    void ResetViewportScaleUIOverride()
    {
        ViewportScaleUIOverride = -1.0f;
    }
 
    float GetViewportScaleUIOverride() const { return ViewportScaleUIOverride; }
 
    bool IsVirtualWindow() const { return bVirtualWindow; }
 
    bool IsMirrorWindow()
    {
        return bIsMirrorWindow;
    }
 
    void SetTitleBar( const TSharedPtr<IWindowTitleBar> InTitleBar )
    {
        TitleBar = InTitleBar;
    }
 
    TSharedPtr<IWindowTitleBar> GetTitleBar() const
    {
        return TitleBar;
    }
 
    // Events
    SLATECORE_API virtual FCursorReply OnCursorQuery( const FGeometry& MyGeometry, const FPointerEvent& CursorEvent ) const override;
 
    SLATECORE_API virtual bool OnIsActiveChanged( const FWindowActivateEvent& ActivateEvent );
    
    SLATECORE_API void Maximize();
    SLATECORE_API void Restore();
    SLATECORE_API void Minimize();
 
    SLATECORE_API EWindowZone::Type GetCurrentWindowZone(UE::Slate::FDeprecateVector2DParameter LocalMousePosition);
 
    EWindowZone::Type MoveResizeZone;
    UE::Slate::FDeprecateVector2DResult MoveResizeStart;
    FSlateRect MoveResizeRect;
 
    SLATECORE_API int32 GetCornerRadius();
 
    SLATECORE_API virtual bool SupportsKeyboardFocus() const override;
 
    bool IsDrawingEnabled() const { return bIsDrawingEnabled; }
 
    virtual bool Advanced_IsWindow() const override { return true; }
    SLATECORE_API virtual bool Advanced_IsInvalidationRoot() const override;
    SLATECORE_API virtual const FSlateInvalidationRoot* Advanced_AsInvalidationRoot() const override;
 
#if WITH_ACCESSIBILITY
    SLATECORE_API virtual TSharedRef<FSlateAccessibleWidget> CreateAccessibleWidget() override;
    SLATECORE_API virtual TOptional<FText> GetDefaultAccessibleText(EAccessibleType AccessibleType = EAccessibleType::Main) const override;
#endif
private:
    SLATECORE_API virtual FReply OnFocusReceived( const FGeometry& MyGeometry, const FFocusEvent& InFocusEvent ) override;
    SLATECORE_API virtual FReply OnMouseButtonDown( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATECORE_API virtual FReply OnMouseButtonUp( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
    SLATECORE_API virtual FReply OnMouseMove( const FGeometry& MyGeometry, const FPointerEvent& MouseEvent ) override;
 
    SLATECORE_API virtual int32 OnPaint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyCullingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const override;
 
    SLATECORE_API virtual FVector2D ComputeDesiredSize(float) const override;
    SLATECORE_API virtual bool ComputeVolatility() const override;
 
    SLATECORE_API void ResizeWindowSize( FVector2f NewWindowSize );
 
    SLATECORE_API void OnGlobalInvalidationToggled(bool bGlobalInvalidationEnabled);
public:
    SLATECORE_API UE::Slate::FDeprecateVector2DResult GetWindowSizeFromClientSize(UE::Slate::FDeprecateVector2DParameter InClientSize, TOptional<float> DPIScale = TOptional<float>());
 
    inline bool IsFocusedInitially() const
    {
        return bFocusWhenFirstShown;
    }
 
    SLATECORE_API const TArray< TSharedRef<SWindow> >& GetChildWindows() const;
    
    SLATECORE_API TArray< TSharedRef<SWindow> >& GetChildWindows();
 
    SLATECORE_API void AddChildWindow( const TSharedRef<SWindow>& ChildWindow );
 
    SLATECORE_API TSharedPtr<SWindow> GetParentWindow() const;
 
    SLATECORE_API TSharedPtr<SWindow> GetTopmostAncestor();
 
    SLATECORE_API bool RemoveDescendantWindow( const TSharedRef<SWindow>& DescendantToRemove );
 
    SLATECORE_API void SetOnWorldSwitchHack( FOnSwitchWorldHack& InOnWorldSwitchHack );
 
    SLATECORE_API int32 SwitchWorlds( int32 WorldId ) const;
 
    SLATECORE_API bool IsActive() const;
 
    SLATECORE_API bool HasActiveChildren() const;
 
    SLATECORE_API bool HasActiveParent() const;
 
    inline void SetViewportSizeDrivenByWindow(bool bDrivenByWindow)
    {
        if (bDrivenByWindow)
        {
            ViewportSize = FVector2f::ZeroVector;
        }
        else
        {
            ViewportSize = Size;
        }
    }
    
    inline bool IsViewportSizeDrivenByWindow() const
    {
        return (ViewportSize.X == 0);
    }
 
    inline UE::Slate::FDeprecateVector2DResult GetViewportSize() const
    {
        return (ViewportSize.X != 0) ? ViewportSize : Size;
    }
    
    inline void SetIndependentViewportSize(const UE::Slate::FDeprecateVector2DParameter& VP) 
    {
        ViewportSize = VP;
    }
 
    void SetViewport(TSharedRef<ISlateViewport> ViewportRef)
    {
        Viewport = ViewportRef;
    }
 
    void UnsetViewport(TSharedRef<ISlateViewport> ViewportRef)
    {
        if (ensure(Viewport == ViewportRef))
        {
            Viewport.Reset();
        }
    }
 
    TSharedPtr<ISlateViewport> GetViewport()
    {
        return Viewport.Pin();
    }
 
    SLATECORE_API FHittestGrid& GetHittestGrid();
 
    SLATECORE_API FWindowSizeLimits GetSizeLimits() const;
 
    SLATECORE_API void SetSizeLimits(const FWindowSizeLimits& InSizeLimits);
 
    SLATECORE_API void SetAllowFastUpdate(bool bInAllowFastUpdate);
public:
 
    //~ SWidget overrides
    SLATECORE_API virtual void Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime ) override;
 
    SLATECORE_API EVisibility GetWindowVisibility() const;
 
    SLATECORE_API TAttribute<FText> GetWindowCloseButtonToolTipText() const;
protected:
    SLATECORE_API virtual TSharedRef<SWidget> MakeWindowTitleBar(const TSharedRef<SWindow>& Window, const TSharedPtr<SWidget>& CenterContent, EHorizontalAlignment CenterContentAlignment);
    SLATECORE_API virtual EHorizontalAlignment GetTitleAlignment();
 
    SLATECORE_API void StartMorph();
 
    SLATECORE_API virtual bool CustomPrepass(float LayoutScaleMultiplier) override;
protected:
 
    EWindowType Type;
 
    TAttribute<FText> Title;
 
    TAttribute<FText> CloseButtonToolTipText;
 
    bool bDragAnywhere;
 
    float Opacity;
 
    ESizingRule SizingRule;
 
    EAutoCenter AutoCenterRule;
 
    EWindowTransparency TransparencySupport;
 
    bool bCreateTitleBar : 1;
 
    bool bIsPopupWindow : 1;
 
    bool bIsTopmostWindow : 1;
 
    bool bSizeWillChangeOften : 1;
 
    bool bInitiallyMaximized : 1;
 
    bool bInitiallyMinimized : 1;
 
    bool bHasEverBeenShown : 1;
 
    bool bFocusWhenFirstShown : 1;
 
    bool bHasOSWindowBorder : 1;
 
    bool bVirtualWindow : 1;
 
    bool bHasCloseButton : 1;
 
    bool bHasMinimizeButton : 1;
 
    bool bHasMaximizeButton : 1;
 
    bool bHasSizingFrame : 1;
    
    bool bIsModalWindow : 1;
 
    bool bIsMirrorWindow : 1;
 
    bool bShouldPreserveAspectRatio : 1;
 
    bool bIsHDR : 1;
 
    bool bManualManageDPI : 1;
 
    bool bAllowFastUpdate : 1;
 
    bool bAcceptsInput: 1;
    
    EWindowActivationPolicy WindowActivationPolicy;
 
    UE::Slate::FDeprecateVector2DResult InitialDesiredScreenPosition;
 
    UE::Slate::FDeprecateVector2DResult InitialDesiredSize;
 
    UE::Slate::FDeprecateVector2DResult ScreenPosition;
 
    UE::Slate::FDeprecateVector2DResult PreFullscreenPosition;
 
    UE::Slate::FDeprecateVector2DResult Size;
 
    UE::Slate::FDeprecateVector2DResult ViewportSize;
 
    TWeakPtr<ISlateViewport> Viewport;
 
    float ViewportScaleUIOverride;
 
    float TitleBarSize;
 
    struct FMorpher
    {
        FMorpher()
            : StartingMorphShape( FSlateRect(0,0,100,100) )
            , TargetMorphShape( FSlateRect(0,0,100,100) )
            , bIsActive(false)
            , bIsAnimatingWindowSize(false)
        { }
 
        float StartingOpacity;
        float TargetOpacity;
 
        FSlateRect StartingMorphShape;
        FSlateRect TargetMorphShape;
        
        FCurveSequence Sequence;
 
        bool bIsActive : 1;
 
        bool bIsAnimatingWindowSize : 1;
 
    } Morpher;
 
    EWindowZone::Type WindowZone;
    
 
    TSharedPtr<SWidget> TitleArea;
    SVerticalBox::FSlot* ContentSlot;
 
    TWeakPtr< SWidget > WidgetToFocusOnActivate;
 
    TWeakPtr< SWidget > WidgetFocusedOnDeactivate;
 
private:
    const FWindowStyle* Style;
 
    const FSlateBrush* WindowBackground;
 
    TSharedPtr<SImage> WindowBackgroundImage;
    TSharedPtr<SImage> WindowBorder;
    TSharedPtr<SImage> WindowOutline;
    TSharedPtr<SWidget> ContentAreaVBox;
    EVisibility WindowContentVisibility;
protected:
 
    FWindowSizeLimits SizeLimits;
 
    TSharedPtr<FGenericWindow> NativeWindow;
 
    TUniquePtr<FHittestGrid> HittestGrid;
    
    FOnWindowActivated OnWindowActivated;
    FOnWindowActivatedEvent WindowActivatedEvent;
 
    FOnWindowDeactivated OnWindowDeactivated;
    FOnWindowDeactivatedEvent WindowDeactivatedEvent;
 
    FOnWindowClosed OnWindowClosed;
    FOnWindowClosedEvent WindowClosedEvent;
 
    FOnWindowMoved OnWindowMoved;
 
    FRequestDestroyWindowOverride RequestDestroyWindowOverride;
 
    TSharedPtr<SOverlay> WindowOverlay; 
    
    TSharedPtr<class SPopupLayer> PopupLayer;
 
    TSharedPtr<SWidget> FullWindowOverlayWidget;
 
    TWeakPtr<SWindow> ParentWindowPtr;
 
    TArray< TSharedRef<SWindow> > ChildWindows;
    
    FOnSwitchWorldHack OnWorldSwitchHack;
 
    bool bShouldShowWindowContentDuringOverlay;
 
    int32 ExpectedMaxWidth;
 
    int32 ExpectedMaxHeight;
 
    int32 FocusUserIndex;
 
    // The window title bar.
    TSharedPtr<IWindowTitleBar> TitleBar;
 
    // The padding for between the edges of the window and it's content
    FMargin LayoutBorder;
 
    // The margin around the edges of the window that will be detected as places the user can grab to resize the window. 
    FMargin UserResizeBorder;
 
    // Whether or not drawing is enabled for this window
    bool bIsDrawingEnabled;
 
protected:
    
    SLATECORE_API void ConstructWindowInternals();
 
    SLATECORE_API EActiveTimerReturnType TriggerPlayMorphSequence( double InCurrentTime, float InDeltaTime );
 
    SLATECORE_API void SetWindowBackground(const FSlateBrush* InWindowBackground);
 
    SLATECORE_API void UpdateWindowContentVisibility();
 
    //~ FSlateInvalidationRoot overrides
    SLATECORE_API virtual TSharedRef<SWidget> GetRootWidget() override;
    SLATECORE_API virtual int32 PaintSlowPath(const FSlateInvalidationContext& InvalidationContext) override;
 
public:
 
    SLATECORE_API void ProcessWindowInvalidation();
 
private:
 
    TWeakPtr<FActiveTimerHandle> ActiveTimerHandle;
};
 
#if WITH_EDITOR
 
struct FScopedSwitchWorldHack
{
    SLATECORE_API FScopedSwitchWorldHack( const FWidgetPath& WidgetPath );
 
    FScopedSwitchWorldHack( TSharedPtr<SWindow> InWindow )
        : Window( InWindow )
        , WorldId( -1 )
    {
        if( Window.IsValid() )
        {
            WorldId = Window->SwitchWorlds( WorldId );
        }
    }
 
    ~FScopedSwitchWorldHack()
    {
        if( Window.IsValid() )
        {
            Window->SwitchWorlds( WorldId );
        }
    }
 
private:
 
    // The window to switch worlds for.
    TSharedPtr<SWindow> Window;
 
    // The worldID serves as identification to the user about the world.  It can be anything although -1 is assumed to be always invalid.
    int32 WorldId;
};
 
#else
 
struct FScopedSwitchWorldHack
{
    inline FScopedSwitchWorldHack(const FWidgetPath& WidgetPath) { }
    inline FScopedSwitchWorldHack(TSharedPtr<SWindow> InWindow) { }
    inline ~FScopedSwitchWorldHack() { }
};
 
#endif