LinuxApplication.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "HAL/UnrealMemory.h"
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "Containers/Map.h"
#include "Math/Vector2D.h"
#include "Templates/SharedPointer.h"
#include "Misc/CoreMisc.h"
#include "GenericPlatform/GenericWindow.h"
#include "GenericPlatform/GenericApplicationMessageHandler.h"
#include "GenericPlatform/GenericWindowDefinition.h"
#include "GenericPlatform/GenericApplication.h"
#include "GenericPlatform/IInputInterface.h"
#include "Linux/LinuxWindow.h"
#include "Linux/LinuxCursor.h"
 
class IInputDevice;
class IModularFeature;
 
class FLinuxApplication : public GenericApplication, public FSelfRegisteringExec, public IInputInterface
{
public:
    struct FWindowProperties
    {
        FVector2D Location;
 
        FVector2D Size;
    };
 
    static FLinuxApplication* CreateLinuxApplication();
 
    enum UserDefinedEvents
    {
        CheckForDeactivation
    };
 
public: 
    virtual ~FLinuxApplication();
    
    virtual void DestroyApplication() override;
 
    // FSelfRegisteringExec
    virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar) override;
 
public:
    virtual void SetMessageHandler( const TSharedRef< class FGenericApplicationMessageHandler >& InMessageHandler ) override;
 
    virtual void PollGameDeviceState( const float TimeDelta ) override;
 
    virtual void PumpMessages( const float TimeDelta ) override;
 
    virtual void ProcessDeferredEvents( const float TimeDelta ) override;
 
    virtual TSharedRef< FGenericWindow > MakeWindow() override;
 
    virtual void InitializeWindow( const TSharedRef< FGenericWindow >& Window, const TSharedRef< FGenericWindowDefinition >& InDefinition, const TSharedPtr< FGenericWindow >& InParent, const bool bShowImmediately ) override;
 
    virtual void SetCapture( const TSharedPtr< FGenericWindow >& InWindow ) override;
 
    virtual void* GetCapture( void ) const override;
 
    virtual void SetHighPrecisionMouseMode( const bool Enable, const TSharedPtr< FGenericWindow >& InWindow ) override;
 
    virtual bool IsUsingHighPrecisionMouseMode() const override { return bUsingHighPrecisionMouseInput; }
 
    virtual bool IsGamepadAttached() const override;
    
    virtual FModifierKeysState GetModifierKeys() const override;
 
    virtual FPlatformRect GetWorkArea( const FPlatformRect& CurrentWindow ) const override;
 
    virtual EWindowTransparency GetWindowTransparencySupport() const override
    {
        return EWindowTransparency::PerWindow;
    }
 
    void AddPendingEvent( SDL_Event event );
 
    void RemoveEventWindow(SDL_HWindow Window);
 
    void RemoveRevertFocusWindow(SDL_HWindow HWnd);
 
    void RaiseNotificationWindows( const TSharedPtr< FLinuxWindow >& ParentWindow);
 
    void RemoveNotificationWindow(SDL_HWindow HWnd);
 
    void CheckIfApplicatioNeedsDeactivation();
 
    EWindowZone::Type WindowHitTest( const TSharedPtr< FLinuxWindow > &window, int x, int y );
 
    TSharedPtr< FLinuxWindow > FindWindowBySDLWindow( SDL_Window *win );
 
    virtual bool IsCursorDirectlyOverSlateWindow() const override;
 
    virtual TSharedPtr<FGenericWindow> GetWindowUnderCursor() override;
 
    inline bool IsForeground()
    {
        // if there are no windows, consider ourselves foreground so servers and commandlets aren't impacted
        return (Windows.Num() > 0) ? bActivateApp : true;
    }
 
    void SaveWindowPropertiesForEventLoop(void);
 
    void ClearWindowPropertiesAfterEventLoop(void);
 
    void GetWindowPropertiesInEventLoop(SDL_HWindow NativeWindow, FWindowProperties& Properties);
 
    virtual bool IsMouseAttached() const override;
 
    TSharedPtr< FLinuxWindow > GetCurrentActiveWindow() 
    {
        return CurrentlyActiveWindow;
    }
 
    TSharedPtr< FLinuxWindow > GetCurrentFocusWindow() 
    {
        return CurrentFocusWindow;
    }
 
private:
 
    FLinuxApplication();
 
    TSharedPtr< FLinuxWindow > FindEventWindow(SDL_Event *Event, bool& bOutWindowlessEvent);
 
    void UpdateMouseCaptureWindow( SDL_HWindow TargetWindow );
 
    void ProcessDeferredMessage( SDL_Event Event );
 
    static bool GeneratesKeyCharMessage(const SDL_KeyboardEvent & KeyDownEvent);
 
    void ActivateApplication();
 
    void DeactivateApplication();
 
    void ActivateWindow(const TSharedPtr< FLinuxWindow >& Window);
 
    void ActivateRootWindow(const TSharedPtr< FLinuxWindow >& Window);
 
    TSharedPtr< FLinuxWindow > GetRootWindow(const TSharedPtr< FLinuxWindow >& Window);
 
    bool HandleCursorCommand(const TCHAR* Cmd, FOutputDevice& Ar);
 
    bool HandleWindowCommand(const TCHAR* Cmd, FOutputDevice& Ar);
 
private:
 
    void RefreshDisplayCache();
 
    FVector2D GetTouchEventLocation(SDL_HWindow NativeWindow, SDL_Event TouchEvent);
 
    int GetFirstFreeTouchId();
 
public:
    virtual IInputInterface* GetInputInterface() override
    {
        return this;
    }
    // IInputInterface overrides
    virtual void SetForceFeedbackChannelValue (int32 ControllerId, FForceFeedbackChannelType ChannelType, float Value) override;
    virtual void SetForceFeedbackChannelValues(int32 ControllerId, const FForceFeedbackValues &Values) override;
    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 { }
 
private:
    void AddGameController(SDL_JoystickID Id);
    void RemoveGameController(SDL_JoystickID Id);
 
    void OnInputDeviceModuleRegistered(const FName& Type, IModularFeature* ModularFeature);
 
    struct FTouchContext
    {
        int TouchIndex;
 
        SDL_TouchID DeviceId;
 
        FVector2D Location;
    };
 
    TMap<uint64, FTouchContext> Touches;
 
    TArray<TOptional<uint64>> TouchIds;
 
    struct SDLControllerState
    {
        SDL_Gamepad* Controller;
 
        bool AnalogOverThreshold[10];
 
        FInputDeviceId DeviceId;
 
        TMap<FGamepadKeyNames::Type, float> AxisEvents;
 
        SDL_Haptic* Haptic;
        int EffectId;
        bool bEffectRunning;
        FForceFeedbackValues ForceFeedbackValues;
 
        SDLControllerState()
            :   Controller(nullptr)
            ,   DeviceId(INPUTDEVICEID_NONE)
            ,   Haptic(nullptr)
            ,   EffectId(-1)
            ,   bEffectRunning(false)
        {
            FMemory::Memzero(AnalogOverThreshold);
        }
 
        void UpdateHapticEffect();
    };
 
    TArray< SDL_Event > PendingEvents;
 
    TArray< TSharedRef< FLinuxWindow > > Windows;
 
    TArray< TSharedRef< FLinuxWindow > > NotificationWindows;
 
    TArray< TSharedRef< FLinuxWindow > > RevertFocusStack;
 
    TMap<SDL_HWindow, FWindowProperties> SavedWindowPropertiesForEventLoop;
 
    int32 bAllowedToDeferMessageProcessing;
 
    bool bUsingHighPrecisionMouseInput;
 
    bool bIsMouseCursorLocked;
 
    bool bIsMouseCaptureEnabled;
 
    bool bFirstFrameOfWindowMove = false;
 
    TSharedPtr< FLinuxWindow > CurrentlyActiveWindow;
    TSharedPtr< FLinuxWindow > CurrentFocusWindow;
    TSharedPtr< FLinuxWindow > CurrentClipWindow;
    TSharedPtr< FLinuxWindow > CurrentUnderCursorWindow;
 
    TArray<FString> DragAndDropQueue;
 
    TArray<FString> DragAndDropTextQueue;
 
    TSharedPtr< FLinuxWindow > PreviousActiveWindow;
 
    SDL_HWindow MouseCaptureWindow;
 
    TMap<SDL_JoystickID, SDLControllerState> ControllerStates;
 
    float fMouseWheelScrollAccel;
 
    TArray< TSharedPtr<class IInputDevice> > ExternalInputDevices;
 
    bool bHasLoadedInputPlugins;
 
    bool bInsideOwnWindow;
 
    bool bIsDragWindowButtonPressed;
 
    bool bActivateApp;
 
    double FocusOutDeactivationTime;
 
    mutable TArray<SDL_Rect>    CachedDisplays;
 
    mutable double          LastTimeCachedDisplays;
};
 
extern FLinuxApplication* LinuxApplication;