SlateApplicationBase.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Styling/SlateColor.h"
#include "GenericPlatform/GenericApplication.h"
#include "Layout/Visibility.h"
#include "Layout/SlateRect.h"
#include "Rendering/SlateRenderer.h"
#include "Misc/CoreDelegates.h"
#include "Async/TaskGraphInterfaces.h"
#include "Types/SlateVector2.h"
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnDebugSafeZoneChanged, const FMargin&, bool);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnConstrainedAspectRatioChanged, const float&);
 
 
class FActiveTimerHandle;
#if WITH_ACCESSIBILITY
class FSlateAccessibleMessageHandler;
#endif
class FSlateApplicationBase;
class FWidgetPath;
class IToolTip;
class SWidget;
class SWindow;
class SImage;
enum class EInvalidateWidgetReason : uint8;
 
template< typename ObjectType > class TAttribute;
 
struct FWindowTitleBarArgs
{
    FWindowTitleBarArgs(const TSharedRef<SWindow>& InWindow)
        : Window(InWindow)
        , CenterContentAlignment(HAlign_Fill)
    {}
 
    TSharedRef<SWindow> Window;
    
    TSharedPtr<SWidget> CenterContent;
 
    EHorizontalAlignment CenterContentAlignment;
 
    TAttribute<FText> CloseButtonToolTipText;
};
 
class IWindowTitleBar
{
public:
    virtual void Flash( ) = 0;
    virtual void UpdateWindowMenu(TSharedPtr<SWidget> MenuContent) = 0;
    virtual void UpdateBackgroundContent(TSharedPtr<SWidget> BackgroundContent) = 0;
    virtual void SetAllowMenuBar(bool bInAllowMenuBar) = 0;
};
 
class FSlateApplicationBase;
 
 
class FHitTesting
{
public:
    FHitTesting(FSlateApplicationBase* InSlateApplication)
        : SlateApp(InSlateApplication)
    {
    }
 
private:
    // SWindow must be able to test which part of the window is being moused-over
    friend class SWindow;
    
private:    
    FSlateApplicationBase* SlateApp;
    // @see FSlateApplicationBase::LocateWidgetInWindow
    FWidgetPath LocateWidgetInWindow(FVector2f ScreenspaceMouseCoordinate, const TSharedRef<SWindow>& Window, bool bIgnoreEnabledStatus, int32 UserIndex) const;
};
 
namespace SlateApplicationDefs
{
    static const int32 MaxHardwareUsers = 8;
}
 
enum class EPopupCursorOverlapMode : uint8
{
    PreventOverlap = 0,
    AllowOverlap
};
 
class FSlateApplicationBase
{
    friend class SWidget;
public:
 
    SLATECORE_API FSlateApplicationBase();
    virtual ~FSlateApplicationBase() { }
 
    virtual bool IsActive() const = 0;
 
    inline FSlateRenderer* GetRenderer() const
    {
        return Renderer.Get();
    }
 
public:
 
    virtual TSharedRef<SWindow> AddWindow( TSharedRef<SWindow> InSlateWindow, const bool bShowImmediately = true ) = 0;
 
    virtual void ArrangeWindowToFrontVirtual( TArray<TSharedRef<SWindow>>& Windows, const TSharedRef<SWindow>& WindowToBringToFront ) = 0;
 
    virtual bool FindPathToWidget( TSharedRef<const SWidget> InWidget, FWidgetPath& OutWidgetPath, EVisibility VisibilityFilter = EVisibility::Visible ) = 0;
 
    virtual TSharedPtr<SWindow> FindWidgetWindow(TSharedRef<const SWidget> InWidget) const = 0;
 
    virtual TSharedPtr<SWindow> GetActiveTopLevelWindow() const = 0;
 
    virtual TSharedPtr<SWindow> GetActiveTopLevelRegularWindow() const = 0;
 
    virtual const TArray<TSharedRef<SWindow>> GetTopLevelWindows() const = 0;
 
    virtual const FSlateBrush* GetAppIcon( ) const = 0;
    virtual const FSlateBrush* GetAppIconSmall() const = 0;
 
    virtual float GetApplicationScale( ) const = 0;
 
    virtual const double GetCurrentTime( ) const = 0;
 
    virtual UE::Slate::FDeprecateVector2DResult GetCursorPos( ) const = 0;
 
    virtual UE::Slate::FDeprecateVector2DResult GetLastCursorPos( ) const = 0;
 
    virtual UE::Slate::FDeprecateVector2DResult GetCursorSize( ) const = 0;
 
    virtual bool GetSoftwareCursorAvailable( ) const = 0;
 
    virtual EVisibility GetSoftwareCursorVis( ) const = 0;
 
    SLATECORE_API void GetDisplayMetrics(FDisplayMetrics& OutDisplayMetrics);
 
    SLATECORE_API void GetCachedDisplayMetrics(FDisplayMetrics& OutDisplayMetrics) const;
 
    SLATECORE_API void GetSafeZoneSize(FMargin& SafeZone, const UE::Slate::FDeprecateVector2DParameter& OverrideSize);
 
    virtual EWindowTransparency GetWindowTransparencySupport() const = 0;
 
    virtual TSharedPtr< SWidget > GetKeyboardFocusedWidget( ) const = 0;
 
    virtual EUINavigation GetNavigationDirectionFromKey( const FKeyEvent& InKeyEvent ) const = 0;
    virtual EUINavigation GetNavigationDirectionFromAnalog(const FAnalogInputEvent& InAnalogEvent) = 0;
    virtual EUINavigationAction GetNavigationActionFromKey(const FKeyEvent& InKeyEvent) const = 0;
    virtual EUINavigationAction GetNavigationActionForKey(const FKey& InKey) const = 0;
 
    virtual bool AnyMenusVisible() const = 0;
 
#if WITH_ACCESSIBILITY
    TSharedRef<FSlateAccessibleMessageHandler> GetAccessibleMessageHandler() const { return AccessibleMessageHandler; }
#endif
protected:
    virtual TSharedPtr< SWidget > GetMouseCaptorImpl() const = 0;
 
    SLATECORE_API void GetSafeZoneRatio(FMargin& SafeZoneRatio);
 
public:
    virtual bool HasAnyMouseCaptor( ) const = 0;
 
    virtual bool HasUserMouseCapture(int32 UserIndex) const = 0;
 
    virtual const TSharedPtr<GenericApplication> GetPlatformApplication ( ) const
    {
        return PlatformApplication;
    }
 
    virtual FSlateRect GetPreferredWorkArea( ) const = 0;
 
    virtual bool HasUserFocusedDescendants(const TSharedRef< const SWidget >& Widget, int32 UserIndex) const = 0;
 
    virtual bool HasFocusedDescendants( const TSharedRef< const SWidget >& Widget ) const = 0;
 
    virtual bool IsExternalUIOpened( ) = 0;
 
    friend class FHitTesting;
    SLATECORE_API const FHitTesting& GetHitTesting() const;
 
    virtual FWidgetPath LocateWindowUnderMouse( UE::Slate::FDeprecateVector2DParameter ScreenspaceMouseCoordinate, const TArray< TSharedRef<SWindow > >& Windows, bool bIgnoreEnabledStatus = false, int32 UserIndex = INDEX_NONE) = 0;
 
    virtual UE::Slate::FDeprecateVector2DResult CalculateTooltipWindowPosition(const FSlateRect& InAnchorRect, const UE::Slate::FDeprecateVector2DParameter& InSize, bool bAutoAdjustForDPIScale, EPopupCursorOverlapMode CursorOverlapMode = EPopupCursorOverlapMode::PreventOverlap) const = 0;
 
    virtual bool IsWindowHousingInteractiveTooltip(const TSharedRef<const SWindow>& WindowToTest) const = 0;
 
    virtual TSharedRef<SImage> MakeImage( const TAttribute<const FSlateBrush*>& Image, const TAttribute<FSlateColor>& Color, const TAttribute<EVisibility>& Visibility ) const = 0;
 
    virtual TSharedRef<IToolTip> MakeToolTip(const TAttribute<FText>& ToolTipText) = 0;
 
    virtual TSharedRef<IToolTip> MakeToolTip( const FText& ToolTipText ) = 0;
 
    virtual TSharedRef<SWidget> MakeWindowTitleBar( const FWindowTitleBarArgs& InArgs, TSharedPtr<IWindowTitleBar>& OutTitleBar ) const = 0;
 
    virtual void RequestDestroyWindow( TSharedRef<SWindow> WindowToDestroy ) = 0;
 
    virtual bool SetKeyboardFocus( const FWidgetPath& InFocusPath, const EFocusCause InCause ) = 0;
 
    virtual bool SetUserFocus(const uint32 InUserIndex, const FWidgetPath& InFocusPath, const EFocusCause InCause) = 0;
 
    virtual bool SetUserFocusAllowingDescendantFocus(const uint32 InUserIndex, const FWidgetPath& InFocusPath, const EFocusCause InCause) = 0;
 
    virtual void SetAllUserFocus(const FWidgetPath& InFocusPath, const EFocusCause InCause) = 0;
 
    virtual void SetAllUserFocusAllowingDescendantFocus(const FWidgetPath& InFocusPath, const EFocusCause InCause) = 0;
 
    virtual TSharedPtr<SWidget> GetUserFocusedWidget(uint32 UserIndex) const = 0;
 
    virtual TSharedPtr<SWidget> GetCurrentDebugContextWidget() const = 0;
 
    DECLARE_EVENT_OneParam(FSlateApplicationBase, FOnInvalidateAllWidgets, bool);
    FOnInvalidateAllWidgets& OnInvalidateAllWidgets() { return OnInvalidateAllWidgetsEvent; }
 
    DECLARE_EVENT_OneParam(FSlateApplicationBase, FOnGlobalInvalidationToggled, bool);
    FOnGlobalInvalidationToggled& OnGlobalInvalidationToggled() { return OnGlobalInvalidationToggledEvent; }
 
    SLATECORE_API void ToggleGlobalInvalidation(bool bIsGlobalInvalidationEnabled);
 
    SLATECORE_API void InvalidateAllWidgets(bool bClearResourcesImmediately) const;
private:
    SLATECORE_API void RegisterActiveTimer( const TSharedRef<FActiveTimerHandle>& ActiveTimerHandle );
 
    SLATECORE_API void UnRegisterActiveTimer( const TSharedRef<FActiveTimerHandle>& ActiveTimerHandle );
 
    TSet<TWeakPtr<FActiveTimerHandle>> ActiveTimerHandles;
 
protected:
    enum class ECustomSafeZoneState : uint8
    {
        Unset,
        Set,
        Debug
    };
 
    SLATECORE_API void UpdateAnyActiveTimersArePending();
 
public:
    SLATECORE_API const static uint32 CursorPointerIndex;
    SLATECORE_API const static uint32 CursorUserIndex;
 
    SLATECORE_API const static FPlatformUserId SlateAppPrimaryPlatformUser;
 
    static FSlateApplicationBase& Get( )
    {
        check(CurrentBaseApplication.IsValid());
        checkSlow(IsThreadSafeForSlateRendering());
        return *CurrentBaseApplication;
    }
 
    static bool IsInitialized( )
    {
        return CurrentBaseApplication.IsValid();
    }
 
protected:
 
    virtual bool DoesWidgetHaveMouseCapture(const TSharedPtr<const SWidget> Widget) const = 0;
 
    virtual bool DoesWidgetHaveMouseCaptureByUser(const TSharedPtr<const SWidget> Widget, int32 UserIndex, TOptional<int32> PointerIndex) const = 0;
 
    virtual TOptional<EFocusCause> HasUserFocus(const TSharedPtr<const SWidget> Widget, int32 UserIndex) const = 0;
 
    virtual TOptional<EFocusCause> HasAnyUserFocus(const TSharedPtr<const SWidget> Widget) const = 0;
 
    virtual bool IsWidgetDirectlyHovered(const TSharedPtr<const SWidget> Widget) const = 0;
 
    virtual bool ShowUserFocus(const TSharedPtr<const SWidget> Widget) const = 0;
 
    virtual FWidgetPath LocateWidgetInWindow(UE::Slate::FDeprecateVector2DParameter ScreenspaceMouseCoordinate, const TSharedRef<SWindow>& Window, bool bIgnoreEnabledStatus, int32 UserIndex) const = 0;
    
    SLATECORE_API void UpdateCustomSafeZone(const FMargin& NewSafeZoneRatio, bool bShouldRecacheMetrics);
#if WITH_EDITOR
    SLATECORE_API void SwapSafeZoneTypes();
#endif
 
protected:
 
    // Holds the Slate renderer used to render this application.
    TSharedPtr<FSlateRenderer> Renderer;
 
    // Private interface for select entities that are allowed to perform hittesting
    FHitTesting HitTesting;
 
protected:
 
    // Holds a pointer to the current application.
    static SLATECORE_API TSharedPtr<FSlateApplicationBase> CurrentBaseApplication;
 
    // Holds a pointer to the platform application.
    static SLATECORE_API TSharedPtr<class GenericApplication> PlatformApplication;
 
    // Caches the application's display metrics
    FDisplayMetrics CachedDisplayMetrics;
 
    // Caches the previous debug safe zone ratio
    float CachedDebugTitleSafeRatio;
public:
 
    SLATECORE_API bool IsSlateAsleep();
 
    TSharedPtr<ICursor> GetPlatformCursor()
    {
        return PlatformApplication->Cursor;
    }
 
    TSharedPtr<class GenericApplication> GetPlatformApplication()
    {
        return PlatformApplication;
    }
 
    SLATECORE_API void ResetCustomSafeZone();
    SLATECORE_API bool IsCustomSafeZoneSet() const;
    SLATECORE_API void SetCustomSafeZone(const FMargin& InSafeZone);
    const FMargin& GetCustomSafeZone() const { return CustomSafeZoneRatio; }
 
#if WITH_EDITORONLY_DATA
    FOnDebugSafeZoneChanged OnDebugSafeZoneChanged;
#endif
#if WITH_EDITOR
    FOnConstrainedAspectRatioChanged OnConstrainedAspectRatioChanged;
#endif
protected:
#if WITH_ACCESSIBILITY
    TSharedRef<FSlateAccessibleMessageHandler> AccessibleMessageHandler;
#endif
 
    FOnInvalidateAllWidgets OnInvalidateAllWidgetsEvent;
    FOnGlobalInvalidationToggled OnGlobalInvalidationToggledEvent;
 
    FCriticalSection ActiveTimerCS;
 
    // Gets set when Slate goes to sleep and cleared when active.
    bool bIsSlateAsleep;
 
    ECustomSafeZoneState CustomSafeZoneState;
 
    FMargin CustomSafeZoneRatio;
 
    bool bAnyActiveTimersPending = false;
};