WindowsApplication.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
 
#include "Math/Color.h"
#include "HAL/IConsoleManager.h"
#include "GenericPlatform/GenericApplication.h"
#include "GenericPlatform/IInputInterface.h"
#include "Tasks/Task.h"
#include "Windows/AllowWindowsPlatformTypes.h"
    #include <Ole2.h>
    #include <oleidl.h>
    #include <ShObjIdl.h>
#include "Windows/HideWindowsPlatformTypes.h"
#include "Windows/WindowsTextInputMethodSystem.h"
 
class FGenericWindow;
enum class EWindowTransparency;
class ITextInputMethodSystem;
enum class FForceFeedbackChannelType;
struct FForceFeedbackValues;
struct FHapticFeedbackValues;
class IModularFeature;
 
DECLARE_LOG_CATEGORY_EXTERN(LogWindowsDesktop, Log, All);
 
class FWindowsWindow;
class FGenericApplicationMessageHandler;
 
DECLARE_MULTICAST_DELEGATE_OneParam(FWindowsApplication_OnWindowCreated, HWND);
 
namespace ETaskbarProgressState
{
    enum Type
    {
        //Stops displaying progress and returns the button to its normal state.
        NoProgress = 0x0,
 
        //The progress indicator does not grow in size, but cycles repeatedly along the 
        //length of the task bar button. This indicates activity without specifying what 
        //proportion of the progress is complete. Progress is taking place, but there is 
        //no prediction as to how long the operation will take.
        Indeterminate = 0x1,
 
        //The progress indicator grows in size from left to right in proportion to the 
        //estimated amount of the operation completed. This is a determinate progress 
        //indicator; a prediction is being made as to the duration of the operation.
        Normal = 0x2,
 
        //The progress indicator turns red to show that an error has occurred in one of 
        //the windows that is broadcasting progress. This is a determinate state. If the 
        //progress indicator is in the indeterminate state, it switches to a red determinate 
        //display of a generic percentage not indicative of actual progress.
        Error = 0x4,
 
        //The progress indicator turns yellow to show that progress is currently stopped in 
        //one of the windows but can be resumed by the user. No error condition exists and 
        //nothing is preventing the progress from continuing. This is a determinate state. 
        //If the progress indicator is in the indeterminate state, it switches to a yellow 
        //determinate display of a generic percentage not indicative of actual progress.
        Paused = 0x8,
    };
}
 
 
class FTaskbarList
{
public:
 
    static APPLICATIONCORE_API TSharedRef<FTaskbarList> Create();
 
    APPLICATIONCORE_API void SetOverlayIcon(HWND WindowHandle, HICON Icon, FText Description);
 
    APPLICATIONCORE_API void SetProgressState(HWND WindowHandle, ETaskbarProgressState::Type State);
 
    APPLICATIONCORE_API void SetProgressValue(HWND WindowHandle, uint64 Current, uint64 Total);
 
    APPLICATIONCORE_API ~FTaskbarList();
 
private:
 
    FTaskbarList();
 
    void Initialize();
 
private:
 
    ITaskbarList3* TaskBarList3;
};
 
 
struct FDeferredWindowsMessage
{
    FDeferredWindowsMessage( const TSharedPtr<FWindowsWindow>& InNativeWindow, HWND InHWnd, uint32 InMessage, WPARAM InWParam, LPARAM InLParam, int32 InX=0, int32 InY=0, uint32 InRawInputFlags = 0 )
        : NativeWindow( InNativeWindow )
        , hWND( InHWnd )
        , Message( InMessage )
        , wParam( InWParam )
        , lParam( InLParam )
        , X( InX )
        , Y( InY )
        , RawInputFlags( InRawInputFlags )
    { }
 
    TWeakPtr<FWindowsWindow> NativeWindow;
 
    HWND hWND;
 
    uint32 Message;
 
    WPARAM wParam;
    LPARAM lParam;
 
    int32 X;
    int32 Y;
    uint32 RawInputFlags;
};
 
 
namespace EWindowsDragDropOperationType
{
    enum Type
    {
        DragEnter,
        DragOver,
        DragLeave,
        Drop
    };
}
 
 
struct FDragDropOLEData
{
    enum EWindowsOLEDataType
    {
        None = 0,
        Text = 1<<0,
        Files = 1<<1,
    };
 
    FDragDropOLEData()
        : Type(None)
    { }
 
    FString OperationText;
    TArray<FString> OperationFilenames;
    uint8 Type;
};
 
 
struct FDeferredWindowsDragDropOperation
{
private:
 
    // Private constructor. Use the factory functions below.
    FDeferredWindowsDragDropOperation()
        : HWnd(NULL)
        , KeyState(0)
    {
        CursorPosition.x = 0;
        CursorPosition.y = 0;
    }
 
public:
 
    static FDeferredWindowsDragDropOperation MakeDragEnter(HWND InHwnd, const FDragDropOLEData& InOLEData, ::DWORD InKeyState, POINTL InCursorPosition)
    {
        FDeferredWindowsDragDropOperation NewOperation;
        NewOperation.OperationType = EWindowsDragDropOperationType::DragEnter;
        NewOperation.HWnd = InHwnd;
        NewOperation.OLEData = InOLEData;
        NewOperation.KeyState = InKeyState;
        NewOperation.CursorPosition = InCursorPosition;
        return NewOperation;
    }
 
    static FDeferredWindowsDragDropOperation MakeDragOver(HWND InHwnd, ::DWORD InKeyState, POINTL InCursorPosition)
    {
        FDeferredWindowsDragDropOperation NewOperation;
        NewOperation.OperationType = EWindowsDragDropOperationType::DragOver;
        NewOperation.HWnd = InHwnd;
        NewOperation.KeyState = InKeyState;
        NewOperation.CursorPosition = InCursorPosition;
        return NewOperation;
    }
 
    static FDeferredWindowsDragDropOperation MakeDragLeave(HWND InHwnd)
    {
        FDeferredWindowsDragDropOperation NewOperation;
        NewOperation.OperationType = EWindowsDragDropOperationType::DragLeave;
        NewOperation.HWnd = InHwnd;
        return NewOperation;
    }
 
    static FDeferredWindowsDragDropOperation MakeDrop(HWND InHwnd, const FDragDropOLEData& InOLEData, ::DWORD InKeyState, POINTL InCursorPosition)
    {
        FDeferredWindowsDragDropOperation NewOperation;
        NewOperation.OperationType = EWindowsDragDropOperationType::Drop;
        NewOperation.HWnd = InHwnd;
        NewOperation.OLEData = InOLEData;
        NewOperation.KeyState = InKeyState;
        NewOperation.CursorPosition = InCursorPosition;
        return NewOperation;
    }
 
    EWindowsDragDropOperationType::Type OperationType;
 
    HWND HWnd;
    FDragDropOLEData OLEData;
    ::DWORD KeyState;
    POINTL CursorPosition;
};
 
//disable warnings from overriding the deprecated force feedback.  
//calls to the deprecated function will still generate warnings.
PRAGMA_DISABLE_DEPRECATION_WARNINGS
 
class IWindowsMessageHandler
{
public:
 
    virtual bool ProcessMessage(HWND hwnd, uint32 msg, WPARAM wParam, LPARAM lParam, int32& OutResult) = 0;
};
 
 
class FWindowsApplication
    : public GenericApplication
    , public IInputInterface
{
public:
 
    static APPLICATIONCORE_API FWindowsApplication* CreateWindowsApplication( const HINSTANCE InstanceHandle, const HICON IconHandle );
 
    static void StaticPostPumpMessages();
 
    void PostPumpMessages();
 
    struct RawMouseInputResult
    {
        bool bIsAbsoluteInput;
        bool bSimulateRelativeMovement;
        int32 DeltaX;
        int32 DeltaY;
    };
 
    void ProcessRawMouseInput(const RAWMOUSE& Mouse, RawMouseInputResult& OutResult);
 
    void ProcessWorkerInputs();
 
    void CacheCursorInfo();
 
    APPLICATIONCORE_API virtual ~FWindowsApplication();
 
public: 
 
    APPLICATIONCORE_API void DeferDragDropOperation( const FDeferredWindowsDragDropOperation& DeferredDragDropOperation );
 
    APPLICATIONCORE_API TSharedPtr<FTaskbarList> GetTaskbarList();
 
    APPLICATIONCORE_API HRESULT OnOLEDragEnter( const HWND HWnd, const FDragDropOLEData& OLEData, ::DWORD KeyState, POINTL CursorPosition, ::DWORD *CursorEffect);
 
    APPLICATIONCORE_API HRESULT OnOLEDragOver( const HWND HWnd, ::DWORD KeyState, POINTL CursorPosition, ::DWORD *CursorEffect);
 
    APPLICATIONCORE_API HRESULT OnOLEDragOut( const HWND HWnd );
 
    APPLICATIONCORE_API HRESULT OnOLEDrop( const HWND HWnd, const FDragDropOLEData& OLEData, ::DWORD KeyState, POINTL CursorPosition, ::DWORD *CursorEffect);
 
    APPLICATIONCORE_API virtual void AddMessageHandler(IWindowsMessageHandler& InMessageHandler);
 
    APPLICATIONCORE_API virtual void RemoveMessageHandler(IWindowsMessageHandler& InMessageHandler);
 
public:
 
    // GenericApplication overrides
 
    APPLICATIONCORE_API virtual void SetMessageHandler( const TSharedRef< class FGenericApplicationMessageHandler >& InMessageHandler ) override;
#if WITH_ACCESSIBILITY
    APPLICATIONCORE_API virtual void SetAccessibleMessageHandler(const TSharedRef<FGenericAccessibleMessageHandler>& InAccessibleMessageHandler) override;
#endif
    APPLICATIONCORE_API virtual void PollGameDeviceState( const float TimeDelta ) override;
    APPLICATIONCORE_API virtual void PumpMessages( const float TimeDelta ) override;
    APPLICATIONCORE_API virtual void ProcessDeferredEvents( const float TimeDelta ) override;
    APPLICATIONCORE_API virtual TSharedRef< FGenericWindow > MakeWindow() override;
    APPLICATIONCORE_API virtual void InitializeWindow( const TSharedRef< FGenericWindow >& Window, const TSharedRef< FGenericWindowDefinition >& InDefinition, const TSharedPtr< FGenericWindow >& InParent, const bool bShowImmediately ) override;
    APPLICATIONCORE_API virtual void SetCapture( const TSharedPtr< FGenericWindow >& InWindow ) override;
    APPLICATIONCORE_API virtual void* GetCapture( void ) const override;
    virtual bool IsMinimized() const override { return bMinimized; }
    APPLICATIONCORE_API virtual void SetHighPrecisionMouseMode( const bool Enable, const TSharedPtr< FGenericWindow >& InWindow ) override;
    void UpdateHighPrecisionMouseMode();
    virtual bool IsUsingHighPrecisionMouseMode() const override { return bUsingHighPrecisionMouseInput; }
    virtual bool IsMouseAttached() const override { return bIsMouseAttached; }
    APPLICATIONCORE_API virtual bool IsGamepadAttached() const override;
    APPLICATIONCORE_API virtual FModifierKeysState GetModifierKeys() const override;
    APPLICATIONCORE_API virtual bool IsCursorDirectlyOverSlateWindow() const override;
    static bool StaticGetCursorPosition(POINT& OutSursorPos);
    bool GetCursorPosition(POINT& OutSursorPos);
    static void StaticForceUpdateAsyncCursor();
    void ForceUpdateAsyncCursor();
    APPLICATIONCORE_API virtual FPlatformRect GetWorkArea( const FPlatformRect& CurrentWindow ) const override;
    APPLICATIONCORE_API virtual void GetInitialDisplayMetrics( FDisplayMetrics& OutDisplayMetrics ) const override;
    APPLICATIONCORE_API virtual EWindowTitleAlignment::Type GetWindowTitleAlignment() const override;
    APPLICATIONCORE_API virtual EWindowTransparency GetWindowTransparencySupport() const override;
    APPLICATIONCORE_API virtual void DestroyApplication() override;
 
    virtual IInputInterface* GetInputInterface() override
    {
        return this;
    }
 
    virtual ITextInputMethodSystem *GetTextInputMethodSystem() override
    {
        return TextInputMethodSystem.Get();
    }
 
    APPLICATIONCORE_API virtual void AddExternalInputDevice(TSharedPtr<class IInputDevice> InputDevice);
 
    APPLICATIONCORE_API virtual void FinishedInputThisFrame() override;
public:
 
    // IInputInterface overrides
 
    APPLICATIONCORE_API virtual void SetForceFeedbackChannelValue (int32 ControllerId, FForceFeedbackChannelType ChannelType, float Value) override;
    APPLICATIONCORE_API virtual void SetForceFeedbackChannelValues(int32 ControllerId, const FForceFeedbackValues &Values) override;
    APPLICATIONCORE_API virtual void SetHapticFeedbackValues(int32 ControllerId, int32 Hand, const FHapticFeedbackValues& Values) override;
    virtual void SetLightColor(int32 ControllerId, FColor Color) override { }
    virtual void ResetLightColor(int32 ControllerId) override { }
    APPLICATIONCORE_API virtual void SetDeviceProperty(int32 ControllerId, const FInputDeviceProperty* Property) override;
 
    // Touchpad Sensitivity
    enum class EForceMaxTouchpadSensitivityAsyncBehavior : uint8
    {
        AllowAsynchronous, // This function may defer the system call that actually changes the setting in order to avoid blocking for a long time.
        RequireBlocking // This function will not return until the system call returns.
    };
    APPLICATIONCORE_API bool SupportsForceMaxTouchpadSensitivity();
    APPLICATIONCORE_API void ApplyForceMaxTouchpadSensitivity();
    APPLICATIONCORE_API void RemoveForceMaxTouchpadSensitivity();
 
    enum class EForceMaxTouchpadSensitivityRestorationValues : int32
    {
        SystemCallFailed = -2, // Indicates we are in a mode where restoration is desirable, but the system call failed.  Most likely callers should do nothing.
        RestorationNotNeeded = -1,  // Indicates restoration is unnecessary (either the system setting was already MostSensitive, we can't change the setting, or the system is fully capable of restoring itself.)
        TOUCHPAD_SENSITIVITY_LEVEL_MOST_SENSITIVE = 0x00000000,  // These values one would restore with ::SystemParametersInfo(SPI_SETTOUCHPADPARAMETERS, ...
        TOUCHPAD_SENSITIVITY_LEVEL_HIGH_SENSITIVITY = 0x00000001,
        TOUCHPAD_SENSITIVITY_LEVEL_MEDIUM_SENSITIVITY = 0x00000002,
        TOUCHPAD_SENSITIVITY_LEVEL_LOW_SENSITIVITY = 0x00000003,
        TOUCHPAD_SENSITIVITY_LEVEL_LEAST_SENSITIVE = 0x00000004,
    };
    APPLICATIONCORE_API EForceMaxTouchpadSensitivityRestorationValues GetForceMaxTouchpadSensitivityRestorationValue();
 
protected:
    friend LRESULT WindowsApplication_WndProc(HWND hwnd, uint32 msg, WPARAM wParam, LPARAM lParam);
 
    static APPLICATIONCORE_API LRESULT CALLBACK AppWndProc(HWND hwnd, uint32 msg, WPARAM wParam, LPARAM lParam);
 
    APPLICATIONCORE_API int32 ProcessMessage( HWND hwnd, uint32 msg, WPARAM wParam, LPARAM lParam );
 
    void ProcessMouseButton(double CurrentTime, const TSharedPtr< FGenericWindow >& Window, USHORT ButtonFlags, USHORT DownFlag, USHORT UpFlag, EMouseButtons::Type MouseButton, FVector2D CursorPos);
 
    APPLICATIONCORE_API int32 ProcessDeferredMessage( const FDeferredWindowsMessage& DeferredMessage );
 
    APPLICATIONCORE_API void ProcessDeferredDragDropOperation(const FDeferredWindowsDragDropOperation& Op);
 
    APPLICATIONCORE_API FWindowsApplication( const HINSTANCE HInstance, const HICON IconHandle );
 
    APPLICATIONCORE_API void ApplyLowLevelMouseFilter();
    APPLICATIONCORE_API void RemoveLowLevelMouseFilter();
 
    static APPLICATIONCORE_API LRESULT CALLBACK HandleLowLevelMouseFilterHook(int nCode, WPARAM wParam, LPARAM lParam);
 
    HHOOK LowLevelMouseFilterHook;
    bool bLowLevelMouseFilterIsApplied = false;
 
private:
 
    static APPLICATIONCORE_API bool RegisterClass( const HINSTANCE HInstance, const HICON HIcon );
 
    static APPLICATIONCORE_API bool IsKeyboardInputMessage( uint32 msg );
 
    static APPLICATIONCORE_API bool IsMouseInputMessage( uint32 msg );
 
    static APPLICATIONCORE_API bool IsFakeMouseInputMessage(uint32 msg);
 
    static APPLICATIONCORE_API bool IsInputMessage( uint32 msg );
 
    APPLICATIONCORE_API void DeferMessage( TSharedPtr<FWindowsWindow>& NativeWindow, HWND InHWnd, uint32 InMessage, WPARAM InWParam, LPARAM InLParam, int32 MouseX = 0, int32 MouseY = 0, uint32 RawInputFlags = 0 );
 
    APPLICATIONCORE_API void CheckForShiftUpEvents(const int32 KeyCode);
 
    APPLICATIONCORE_API void ShutDownAfterError();
 
    APPLICATIONCORE_API void AllowAccessibilityShortcutKeys(const bool bAllowKeys);
 
    APPLICATIONCORE_API void QueryConnectedMice();
 
    APPLICATIONCORE_API uint32 GetTouchIndexForID(int32 TouchID);
 
    APPLICATIONCORE_API uint32 GetFirstFreeTouchIndex();
 
    APPLICATIONCORE_API void UpdateAllModifierKeyStates();
 
    APPLICATIONCORE_API FPlatformRect GetWorkAreaFromOS(const FPlatformRect& CurrentWindow) const;
 
    void RegisterHighPrecisionMouseMode();
 
    void UnregisterHighPrecisionMouseMode();
 
    void OnInputDeviceModuleRegistered(const FName& Type, IModularFeature* ModularFeature);
 
private:
 
    static APPLICATIONCORE_API const FIntPoint MinimizedWindowPosition;
 
    HINSTANCE InstanceHandle;
 
    bool bMinimized;
 
    bool bUsingHighPrecisionMouseInput;
    bool bCachedUseWorkerThreadForRawInput;
    HWND HighPrecisionMouseInputWindowHandle;
    HWND CaptureWindowHandle;
 
    UE::FEventCount AsyncCursorEventCount;
    std::atomic<bool> bAsyncCursorTaskActive = false;
    UE::Tasks::FTask AsyncCursorTask;
    mutable FRWLock AsyncCursorRWLock;
    BOOL bAsyncCursorPosValid{};
    POINT AsyncCursorPos{};
    HWND AsyncCursorWindowHandle = NULL;
 
    bool bIsMouseAttached;
 
    bool bForceActivateByMouse;
 
    bool bForceNoGamepads;
 
    bool bConsumeAltSpace;
 
    TArray<FDeferredWindowsMessage> DeferredMessages;
 
    TArray<FDeferredWindowsDragDropOperation> DeferredDragDropOperations;
 
    TArray<IWindowsMessageHandler*> MessageHandlers;
 
    TArray<TSharedRef<FWindowsWindow>> Windows;
 
    TArray<TSharedPtr<class IInputDevice>> ExternalInputDevices;
    bool bHasLoadedInputPlugins;
 
    struct EModifierKey
    {
        enum Type
        {
            LeftShift,      // VK_LSHIFT
            RightShift,     // VK_RSHIFT
            LeftControl,    // VK_LCONTROL
            RightControl,   // VK_RCONTROL
            LeftAlt,        // VK_LMENU
            RightAlt,       // VK_RMENU
            CapsLock,       // VK_CAPITAL
            Count,
        };
    };
    bool ModifierKeyState[EModifierKey::Count];
 
    int32 bAllowedToDeferMessageProcessing;
    
    FAutoConsoleVariableRef CVarDeferMessageProcessing;
    
    bool bInModalSizeLoop;
 
    FDisplayMetrics InitialDisplayMetrics;
 
    TSharedPtr<FWindowsTextInputMethodSystem> TextInputMethodSystem;
 
    TSharedPtr<FTaskbarList> TaskbarList;
 
#if WITH_ACCESSIBILITY && UE_WINDOWS_USING_UIA
    TUniquePtr<class FWindowsUIAManager> UIAManager;
#endif
 
    // Accessibility shortcut keys
    STICKYKEYS                          StartupStickyKeys;
    TOGGLEKEYS                          StartupToggleKeys;
    FILTERKEYS                          StartupFilterKeys;
 
    struct TouchInfo
    {
        bool HasMoved;
        FVector2D PreviousLocation;
        TOptional<int32> TouchID;
 
        TouchInfo()
            : HasMoved(false)
            , PreviousLocation(0.f, 0.f)
        { }
    };
    TArray<TouchInfo> TouchInfoArray;
 
    bool bSimulatingHighPrecisionMouseInputForRDP;
 
    FIntPoint LastCursorPoint;
    FIntPoint LastCursorPointPreWrap;
    int32 NumPreWrapMsgsToRespect;
    RECT ClipCursorRect;
    DWORD CachedDragAndDropKeyState;
 
    double RepeatTime[EMouseButtons::Invalid];
};
 
 
PRAGMA_ENABLE_DEPRECATION_WARNINGS