GenericApplication.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "HAL/PlatformCrt.h"
#include "Math/IntPoint.h"
#include "Math/MathFwd.h"
#include "Math/Vector2D.h"
#include "Math/Vector4.h"
#include "Templates/SharedPointer.h"
#include "GenericPlatform/GenericApplicationMessageHandler.h"
#include "GenericPlatform/GenericWindow.h"
#include "GenericPlatform/GenericWindowDefinition.h"
 
class FGenericAccessibleMessageHandler;
class FSlateApplication;
class IAnalyticsProvider;
class ICursor;
class IInputInterface;
class ITextInputMethodSystem;
 
namespace EModifierKey
{
    typedef uint8 Type;
 
    inline const Type None  = 0;
 
    inline const Type Control = 1 << 0;
 
    inline const Type Alt = 1 << 1;
 
    inline const Type Shift = 1 << 2;
 
    inline const Type Command = 1 << 3;
 
    inline EModifierKey::Type FromBools(const bool bControl, const bool bAlt, const bool bShift, const bool bCommand)
    {
        EModifierKey::Type ModifierMask = EModifierKey::None;
        if (bControl)   ModifierMask |= EModifierKey::Control;
        if (bAlt)       ModifierMask |= EModifierKey::Alt;
        if (bShift)     ModifierMask |= EModifierKey::Shift;
        if (bCommand)   ModifierMask |= EModifierKey::Command;
 
        return ModifierMask;
    }
};
 
 
namespace EPopUpOrientation
{
    enum Type
    {
        Horizontal,
        Vertical,
    };
}
 
 
class FModifierKeysState
{
 
public:
 
    FModifierKeysState( const bool bInIsLeftShiftDown,
                        const bool bInIsRightShiftDown,
                        const bool bInIsLeftControlDown,
                        const bool bInIsRightControlDown,
                        const bool bInIsLeftAltDown,
                        const bool bInIsRightAltDown,
                        const bool bInIsLeftCommandDown,
                        const bool bInIsRightCommandDown,
                        const bool bInAreCapsLocked)
        : bIsLeftShiftDown( bInIsLeftShiftDown ),
          bIsRightShiftDown( bInIsRightShiftDown ),
          bIsLeftControlDown( bInIsLeftControlDown ),
          bIsRightControlDown( bInIsRightControlDown ),
          bIsLeftAltDown( bInIsLeftAltDown ),
          bIsRightAltDown( bInIsRightAltDown ),
          bIsLeftCommandDown( bInIsLeftCommandDown ),
          bIsRightCommandDown( bInIsRightCommandDown ),
          bAreCapsLocked( bInAreCapsLocked )
    {
    }
 
    FModifierKeysState()
        : bIsLeftShiftDown(false),
          bIsRightShiftDown(false),
          bIsLeftControlDown(false),
          bIsRightControlDown(false),
          bIsLeftAltDown(false),
          bIsRightAltDown(false),
          bIsLeftCommandDown(false),
          bIsRightCommandDown(false),
          bAreCapsLocked(false)
    {
    }
    
    bool IsShiftDown() const
    {
        return bIsLeftShiftDown || bIsRightShiftDown;
    }
 
    bool IsLeftShiftDown() const
    {
        return bIsLeftShiftDown;
    }
 
    bool IsRightShiftDown() const
    {
        return bIsRightShiftDown;
    }
 
    bool IsControlDown() const
    {
        return bIsLeftControlDown || bIsRightControlDown;
    }
 
    bool IsLeftControlDown() const
    {
        return bIsLeftControlDown;
    }
 
    bool IsRightControlDown() const
    {
        return bIsRightControlDown;
    }
 
    bool IsAltDown() const
    {
        return bIsLeftAltDown || bIsRightAltDown;
    }
 
    bool IsLeftAltDown() const
    {
        return bIsLeftAltDown;
    }
 
    bool IsRightAltDown() const
    {
        return bIsRightAltDown;
    }
    
    bool IsCommandDown() const
    {
        return bIsLeftCommandDown || bIsRightCommandDown;
    }
    
    bool IsLeftCommandDown() const
    {
        return bIsLeftCommandDown;
    }
    
    bool IsRightCommandDown() const
    {
        return bIsRightCommandDown;
    }
 
 
    bool AreCapsLocked() const
    {
        return bAreCapsLocked;
    }
 
    bool AreModifersDown(EModifierKey::Type ModiferKeys) const
    {
        bool AllModifersDown = true;
 
        if ( (ModiferKeys & EModifierKey::Shift) == EModifierKey::Shift )
        {
            AllModifersDown &= IsShiftDown();
        }
        if ( (ModiferKeys & EModifierKey::Command) == EModifierKey::Command )
        {
            AllModifersDown &= IsCommandDown();
        }
        if ( (ModiferKeys & EModifierKey::Control) == EModifierKey::Control )
        {
            AllModifersDown &= IsControlDown();
        }
        if ( (ModiferKeys & EModifierKey::Alt) == EModifierKey::Alt )
        {
            AllModifersDown &= IsAltDown();
        }
 
        return AllModifersDown;
    }
 
    bool AnyModifiersDown() const
    {
        return IsControlDown() || IsCommandDown() || IsShiftDown() || IsAltDown();
    }
 
private:
 
    uint16 bIsLeftShiftDown:1;
 
    uint16 bIsRightShiftDown:1;
 
    uint16 bIsLeftControlDown:1;
 
    uint16 bIsRightControlDown:1;
 
    uint16 bIsLeftAltDown:1;
 
    uint16 bIsRightAltDown:1;
    
    uint16 bIsLeftCommandDown:1;
    
    uint16 bIsRightCommandDown:1;
 
    uint16 bAreCapsLocked:1;
};
 
 
struct FPlatformRect
{
    int32 Left;
    int32 Top;
    int32 Right;
    int32 Bottom;
 
    FPlatformRect() : Left(0), Top(0), Right(0), Bottom(0) {}
    FPlatformRect(int32 InLeft, int32 InTop, int32 InRight, int32 InBottom) : Left(InLeft), Top(InTop), Right(InRight), Bottom(InBottom) {}
 
    bool operator==(const FPlatformRect& Other) const
    {
        return Left == Other.Left && Top == Other.Top && Right == Other.Right && Bottom == Other.Bottom;
    }
};
 
 
struct FMonitorInfo
{
    FString Name;
    FString ID;
    int32 NativeWidth = 0;
    int32 NativeHeight = 0;
    FIntPoint MaxResolution = FIntPoint(ForceInitToZero);
    FPlatformRect DisplayRect;
    FPlatformRect WorkArea;
    bool bIsPrimary = false;
    int32 DPI = 0;
};
 
 
struct FDisplayMetrics
{
    FDisplayMetrics()
        : TitleSafePaddingSize(0, 0, 0, 0)
        , ActionSafePaddingSize(0, 0, 0, 0)
    {
    }
 
    int32 PrimaryDisplayWidth;
 
    int32 PrimaryDisplayHeight;
 
    TArray<FMonitorInfo> MonitorInfo;
 
    FPlatformRect PrimaryDisplayWorkAreaRect;
 
    FPlatformRect VirtualDisplayRect;
 
    FVector4 TitleSafePaddingSize;
 
    FVector4 ActionSafePaddingSize;
 
    UE_DEPRECATED(4.21, "Please use RebuildDisplayMetrics - it is functionally the same but is clearer about the function cost")
    static void GetDisplayMetrics(struct FDisplayMetrics& OutDisplayMetrics) { RebuildDisplayMetrics(OutDisplayMetrics); };
 
    APPLICATIONCORE_API static void RebuildDisplayMetrics(struct FDisplayMetrics& OutDisplayMetrics);
 
    APPLICATIONCORE_API FPlatformRect GetMonitorWorkAreaFromPoint(const FVector2D& Point) const;
 
    APPLICATIONCORE_API void PrintToLog() const;
 
    // The title safe zone ratio that will be returned by FDisplayMetrics::GetDisplayMetrics on platforms that don't have a defined safe zone
    APPLICATIONCORE_API static float GetDebugTitleSafeZoneRatio();
protected:
    // Fills the InOutTitleSafePaddingSize with CVar overwrites (Sets padding to 0 for values that are not set).
    bool TryGetTitleSafeZoneOverwrite(FVector4& InOutTitleSafePaddingSize);
 
    // The action safe zone ratio that will be returned by FDisplayMetrics::GetDisplayMetrics on platforms that don't have a defined safe zone
    static float GetDebugActionSafeZoneRatio();
 
    // Apply the debug/default safe zones
    void ApplyDefaultSafeZones();
};
 
 
namespace EWindowTitleAlignment
{
    enum Type
    {
        Left,
        Center,
        Right
    };
}
 
 
class GenericApplication 
{
public:
 
    DECLARE_MULTICAST_DELEGATE_OneParam( FOnConsoleCommandAdded, const FString& /*Command*/ );
    typedef FOnConsoleCommandAdded::FDelegate FOnConsoleCommandListener;
 
    APPLICATIONCORE_API GenericApplication(const TSharedPtr< ICursor >& InCursor);
    APPLICATIONCORE_API virtual ~GenericApplication();
 
    virtual void SetMessageHandler( const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler ) { MessageHandler = InMessageHandler; }
 
    TSharedRef< FGenericApplicationMessageHandler > GetMessageHandler() { return MessageHandler; }
 
#if WITH_ACCESSIBILITY
    APPLICATIONCORE_API virtual void SetAccessibleMessageHandler(const TSharedRef<FGenericAccessibleMessageHandler>& InAccessibleMessageHandler);
    APPLICATIONCORE_API TSharedRef<FGenericAccessibleMessageHandler> GetAccessibleMessageHandler() const;
#endif
 
    virtual void PollGameDeviceState( const float TimeDelta ) { }
 
    virtual void PumpMessages( const float TimeDelta ) { }
 
    virtual void ProcessDeferredEvents( const float TimeDelta ) { }
 
    virtual void Tick ( const float TimeDelta ) { }
 
    virtual TSharedRef< FGenericWindow > MakeWindow() { return MakeShareable( new FGenericWindow() ); }
 
    virtual void InitializeWindow( const TSharedRef< FGenericWindow >& Window, const TSharedRef< FGenericWindowDefinition >& InDefinition, const TSharedPtr< FGenericWindow >& InParent, const bool bShowImmediately ) { }
 
    virtual void SetCapture( const TSharedPtr< FGenericWindow >& InWindow ) { }
 
    virtual void* GetCapture( void ) const { return NULL; }
 
    virtual FModifierKeysState GetModifierKeys() const  { return FModifierKeysState(); }
 
    virtual bool IsCursorDirectlyOverSlateWindow() const { return true; }
 
    virtual TSharedPtr< FGenericWindow > GetWindowUnderCursor() { return TSharedPtr< FGenericWindow >( nullptr ); }
 
    virtual bool IsMinimized() const { return false; }
 
    virtual void SetHighPrecisionMouseMode( const bool Enable, const TSharedPtr< FGenericWindow >& InWindow ) { };
 
    virtual bool IsUsingHighPrecisionMouseMode() const { return false; }
    
    virtual bool IsUsingTrackpad() const { return false; }
 
    virtual bool IsMouseAttached() const { return true; }
 
    virtual bool IsGamepadAttached() const { return false; }
 
    virtual void RegisterConsoleCommandListener(const FOnConsoleCommandListener& InListener) {}
 
    virtual void AddPendingConsoleCommand(const FString& InCommand) {}
 
    virtual FPlatformRect GetWorkArea( const FPlatformRect& CurrentWindow ) const
    {
        FPlatformRect OutRect;
        OutRect.Left = 0;
        OutRect.Top = 0;
        OutRect.Right = 0;
        OutRect.Bottom = 0;
 
        return OutRect;
    }
 
    virtual bool TryCalculatePopupWindowPosition( const FPlatformRect& InAnchor, const FVector2D& InSize, const FVector2D& ProposedPlacement, const EPopUpOrientation::Type Orientation, /*OUT*/ FVector2D* const CalculatedPopUpPosition ) const { return false; }
 
    DECLARE_EVENT_OneParam(GenericApplication, FOnDisplayMetricsChanged, const FDisplayMetrics&);
    
    FOnDisplayMetricsChanged& OnDisplayMetricsChanged(){ return OnDisplayMetricsChangedEvent; }
 
    virtual void GetInitialDisplayMetrics( FDisplayMetrics& OutDisplayMetrics ) const { FDisplayMetrics::RebuildDisplayMetrics(OutDisplayMetrics); }
 
    
    DECLARE_EVENT_OneParam(FSlateApplication, FVirtualKeyboardShownEvent, FPlatformRect);
    FVirtualKeyboardShownEvent& OnVirtualKeyboardShown()  { return VirtualKeyboardShownEvent; }
    
    DECLARE_EVENT(FSlateApplication, FVirtualKeyboardHiddenEvent);
    FVirtualKeyboardHiddenEvent& OnVirtualKeyboardHidden()  { return VirtualKeyboardHiddenEvent; }
    
    DECLARE_EVENT(FSlateApplication, FOnClipboardContentChanged);
    FOnClipboardContentChanged& OnClipboardContentChanged()  { return OnClipboardContentChangedEvent; }
    
    virtual EWindowTitleAlignment::Type GetWindowTitleAlignment() const
    {
        return EWindowTitleAlignment::Left;
    }
 
    virtual EWindowTransparency GetWindowTransparencySupport() const
    {
        return EWindowTransparency::None;
    }
 
    virtual void DestroyApplication() { }
 
    virtual IInputInterface* GetInputInterface() { return nullptr; }    
 
    virtual ITextInputMethodSystem *GetTextInputMethodSystem() { return NULL; }
    
    virtual void SendAnalytics(IAnalyticsProvider* Provider) { }
 
    virtual bool SupportsSystemHelp() const { return false; }
 
    virtual void ShowSystemHelp() {}
 
    virtual bool ApplicationLicenseValid(FPlatformUserId PlatformUser = PLATFORMUSERID_NONE) { return true; }
 
    virtual bool IsAllowedToRender() const { return true; }
 
    virtual void FinishedInputThisFrame() {}
public:
 
    const TSharedPtr< ICursor > Cursor;
 
protected:
 
    TSharedRef< class FGenericApplicationMessageHandler > MessageHandler;
 
#if WITH_ACCESSIBILITY
    TSharedRef<FGenericAccessibleMessageHandler> AccessibleMessageHandler;
#endif
 
    
    void BroadcastDisplayMetricsChanged( const FDisplayMetrics& InMetrics ){ OnDisplayMetricsChangedEvent.Broadcast( InMetrics ); }
    
    // Notifies subscribers when any of the display metrics change: e.g. resolution changes or monitor sare re-arranged.
    FOnDisplayMetricsChanged OnDisplayMetricsChangedEvent;
 
    FVirtualKeyboardShownEvent VirtualKeyboardShownEvent;
    
    FVirtualKeyboardHiddenEvent VirtualKeyboardHiddenEvent;
    
    FOnClipboardContentChanged OnClipboardContentChangedEvent;
};