Events.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Class.h"
#include "InputCoreTypes.h"
#include "Types/SlateEnums.h"
#include "GenericPlatform/GenericApplication.h"
#include "GenericPlatform/GenericPlatformInputDeviceMapper.h"
#include "Layout/Geometry.h"
#include "Types/SlateVector2.h"
#include "Events.generated.h"
 
class FWidgetPath;
class SWidget;
class SWindow;
 
UENUM()
enum class EFocusCause : uint8
{
    Mouse,
 
    Navigation,
 
    SetDirectly,
 
    Cleared,
 
    OtherWidgetLostFocus,
 
    WindowActivate,
};
 
USTRUCT(BlueprintType)
struct FFocusEvent
{
    GENERATED_USTRUCT_BODY()
 
public:
 
    FFocusEvent()
        : Cause(EFocusCause::SetDirectly)
        , UserIndex(0)
    { }
 
    FFocusEvent(const EFocusCause InCause, uint32 InUserIndex)
        : Cause(InCause)
        , UserIndex(InUserIndex)
    { }
 
    EFocusCause GetCause() const
    {
        return Cause;
    }
 
    uint32 GetUser() const
    {
        return UserIndex;
    }
 
private:
 
    EFocusCause Cause;
 
    uint32 UserIndex;
};
 
 
USTRUCT(BlueprintType)
struct FCaptureLostEvent
{
    GENERATED_USTRUCT_BODY()
 
public:
    FCaptureLostEvent()
        : UserIndex(0)
        , PointerIndex(0)
    { }
 
    FCaptureLostEvent(int32 InUserIndex, int32 InPointerIndex)
        : UserIndex(InUserIndex)
        , PointerIndex(InPointerIndex)
    { }
 
    int32 UserIndex;
    
    int32 PointerIndex;
};
 
 
struct FVirtualPointerPosition
{
    FVirtualPointerPosition()
        : CurrentCursorPosition(FVector2f::ZeroVector)
        , LastCursorPosition(FVector2f::ZeroVector)
    {}
 
    FVirtualPointerPosition(const UE::Slate::FDeprecateVector2DParameter& InCurrentCursorPosition, const UE::Slate::FDeprecateVector2DParameter& InLastCursorPosition)
        : CurrentCursorPosition(InCurrentCursorPosition)
        , LastCursorPosition(InLastCursorPosition)
    {}
 
    UE::Slate::FDeprecateVector2DResult CurrentCursorPosition;
    UE::Slate::FDeprecateVector2DResult LastCursorPosition;
};
 
USTRUCT(BlueprintType)
struct FInputEvent
{
    GENERATED_USTRUCT_BODY()
 
public:
 
    FInputEvent()
        : ModifierKeys(FModifierKeysState())
        , bIsRepeat(false)
        , UserIndex(0)
        , InputDeviceId(INPUTDEVICEID_NONE)
        , EventPath(nullptr)
        , EventTimestamp(FPlatformTime::Cycles64()) /* Initalize the timestamp of event input event to the current CPU cycle */
    { }
 
    FInputEvent(const FModifierKeysState& InModifierKeys, const int32 InUserIndex, const bool bInIsRepeat)
        : ModifierKeys(InModifierKeys)
        , bIsRepeat(bInIsRepeat)
        , UserIndex(InUserIndex)
        , InputDeviceId(FInputDeviceId::CreateFromInternalId(InUserIndex))
        , EventPath(nullptr)
        , EventTimestamp(FPlatformTime::Cycles64()) /* Initalize the timestamp of event input event to the current CPU cycle */
    { }
 
    FInputEvent(const FModifierKeysState& InModifierKeys, const FInputDeviceId InDeviceId, const bool bInIsRepeat)
        : ModifierKeys(InModifierKeys)
        , bIsRepeat(bInIsRepeat)
        , InputDeviceId(InDeviceId)
        , EventPath(nullptr)
        , EventTimestamp(FPlatformTime::Cycles64()) /* Initalize the timestamp of event input event to the current CPU cycle */
    {
        // Set the User Index to the PlatformUser ID by default for backwards compatibility
        UserIndex = GetPlatformUserId().GetInternalId();
    }
 
    SLATECORE_API virtual ~FInputEvent();
 
public:
 
    bool IsRepeat() const
    {
        return bIsRepeat;
    }
 
    bool IsShiftDown() const
    {
        return ModifierKeys.IsShiftDown();
    }
 
    bool IsLeftShiftDown() const
    {
        return ModifierKeys.IsLeftShiftDown();
    }
 
    bool IsRightShiftDown() const
    {
        return ModifierKeys.IsRightShiftDown();
    }
 
    bool IsControlDown() const
    {
        return ModifierKeys.IsControlDown();
    }
 
    bool IsLeftControlDown() const
    {
        return ModifierKeys.IsLeftControlDown();
    }
 
    bool IsRightControlDown() const
    {
        return ModifierKeys.IsRightControlDown();
    }
 
    bool IsAltDown() const
    {
        return ModifierKeys.IsAltDown();
    }
 
    bool IsLeftAltDown() const
    {
        return ModifierKeys.IsLeftAltDown();
    }
 
    bool IsRightAltDown() const
    {
        return ModifierKeys.IsRightAltDown();
    }
 
    bool IsCommandDown() const
    {
        return ModifierKeys.IsCommandDown();
    }
 
    bool IsLeftCommandDown() const
    {
        return ModifierKeys.IsLeftCommandDown();
    }
 
    bool IsRightCommandDown() const
    {
        return ModifierKeys.IsRightCommandDown();
    }
 
    bool AreCapsLocked() const
    {
        return ModifierKeys.AreCapsLocked();
    }
 
    const FModifierKeysState& GetModifierKeys() const
    {
        return ModifierKeys;
    }
 
    uint32 GetUserIndex() const
    {
        return UserIndex;
    }
 
    FInputDeviceId GetInputDeviceId() const
    {
        return InputDeviceId;
    }
 
    FPlatformUserId GetPlatformUserId() const
    {
        return IPlatformInputDeviceMapper::Get().GetUserForInputDevice(InputDeviceId);
    }
 
    uint64 GetEventTimestamp() const
    {
        return EventTimestamp;
    }
 
    double GetMillisecondsSinceEvent() const
    {
        return FPlatformTime::ToMilliseconds64(FPlatformTime::Cycles64() - EventTimestamp);
    }
 
    SLATECORE_API FGeometry FindGeometry(const TSharedRef<SWidget>& WidgetToFind) const;
 
    SLATECORE_API TSharedRef<SWindow> GetWindow() const;
 
    void SetEventPath( const FWidgetPath& InEventPath )
    {
        EventPath = &InEventPath;
    }
 
    const FWidgetPath* GetEventPath() const
    {
        return EventPath;
    }
 
    SLATECORE_API virtual FText ToText() const;
    
    SLATECORE_API virtual bool IsPointerEvent() const;
 
    SLATECORE_API virtual bool IsKeyEvent() const;
 
protected:
 
    // State of modifier keys when this event happened.
    FModifierKeysState ModifierKeys;
 
    // True if this key was auto-repeated.
    bool bIsRepeat;
 
    // The index of the user that caused the event.
    uint32 UserIndex;
    
    // The ID of the input device that caused this event.
    FInputDeviceId InputDeviceId;
 
    // Events are sent along paths. See (GetEventPath).
    const FWidgetPath* EventPath;
 
    // The timestamp of when this input event was recorded. This is the
    // cycle at which this event was recorded, populated by FPlatformTime::Cycles64()
    // at the time of construction.
    uint64 EventTimestamp;
};
 
template<>
struct TStructOpsTypeTraits<FInputEvent> : public TStructOpsTypeTraitsBase2<FInputEvent>
{
    enum
    {
        WithCopy = true,
    };
};
 
USTRUCT(BlueprintType)
struct FKeyEvent : public FInputEvent
{
    GENERATED_USTRUCT_BODY()
 
public:
    SLATECORE_API FKeyEvent();
 
    SLATECORE_API FKeyEvent(const FKey InKey,
        const FModifierKeysState& InModifierKeys,
        const uint32 InUserIndex,
        const bool bInIsRepeat,
        const uint32 InCharacterCode,
        const uint32 InKeyCode
    );
    
    SLATECORE_API FKeyEvent(const FKey InKey,
        const FModifierKeysState& InModifierKeys,
        const FInputDeviceId InDeviceId,
        const bool bInIsRepeat,
        const uint32 InCharacterCode,
        const uint32 InKeyCode,
        const TOptional<int32> InOptionalSlateUserIndex = TOptional<int32>()
    );
 
    SLATECORE_API virtual ~FKeyEvent();
 
    FKey GetKey() const
    {
        return Key;
    }
 
    uint32 GetCharacter() const
    {
        return CharacterCode;
    }
 
    uint32 GetKeyCode() const
    {
        return KeyCode;
    }
 
    SLATECORE_API virtual FText ToText() const override;
 
    SLATECORE_API virtual bool IsKeyEvent() const override;
 
private:
    // Name of the key that was pressed.
    FKey Key;
 
    // The character code of the key that was pressed.  Only applicable to typed character keys, 0 otherwise.
    uint32 CharacterCode;
 
    // Original key code received from hardware before any conversion/mapping
    uint32 KeyCode;
};
 
template<>
struct TStructOpsTypeTraits<FKeyEvent> : public TStructOpsTypeTraitsBase2<FKeyEvent>
{
    enum
    {
        WithCopy = true,
    };
};
 
 
USTRUCT(BlueprintType)
struct FAnalogInputEvent
    : public FKeyEvent
{
    GENERATED_USTRUCT_BODY()
 
public:
    FAnalogInputEvent()
        : FKeyEvent(FKey(), FModifierKeysState(), false, 0, 0, 0)
        , AnalogValue(0.0f)
    {
    }
 
    FAnalogInputEvent(const FKey InKey,
        const FModifierKeysState& InModifierKeys,
        const uint32 InUserIndex,
        const bool bInIsRepeat,
        const uint32 InCharacterCode,
        const uint32 InKeyCode,
        const float InAnalogValue
        )
        : FKeyEvent(InKey, InModifierKeys, InUserIndex, bInIsRepeat, InCharacterCode, InKeyCode)
        , AnalogValue(InAnalogValue)
    { }
 
    FAnalogInputEvent(const FKey InKey,
        const FModifierKeysState& InModifierKeys,
        const FInputDeviceId InDeviceId,
        const bool bInIsRepeat,
        const uint32 InCharacterCode,
        const uint32 InKeyCode,
        const float InAnalogValue,
        const TOptional<int32> InOptionalSlateUserIndex = TOptional<int32>()
    )
        : FKeyEvent(InKey, InModifierKeys, InDeviceId, bInIsRepeat, InCharacterCode, InKeyCode, InOptionalSlateUserIndex)
        , AnalogValue(InAnalogValue)
    { }
 
    SLATECORE_API virtual ~FAnalogInputEvent();
 
    float GetAnalogValue() const { return AnalogValue; }
 
    SLATECORE_API virtual FText ToText() const override;
 
private:
    //  Analog value between 0 and 1 (0 being not pressed at all, 1 being fully pressed).
    float AnalogValue;
};
 
template<>
struct TStructOpsTypeTraits<FAnalogInputEvent> : public TStructOpsTypeTraitsBase2<FAnalogInputEvent>
{
    enum
    {
        WithCopy = true,
    };
};
 
USTRUCT(BlueprintType)
struct FCharacterEvent
    : public FInputEvent
{
    GENERATED_USTRUCT_BODY()
 
public:
    FCharacterEvent()
        : FInputEvent(FModifierKeysState(), 0, false)
        , Character(0)
    {
    }
 
    FCharacterEvent(const TCHAR InCharacter, const FModifierKeysState& InModifierKeys, const uint32 InUserIndex, const bool bInIsRepeat)
        : FInputEvent(InModifierKeys, InUserIndex, bInIsRepeat)
        , Character(InCharacter)
    { }
 
    FCharacterEvent(const TCHAR InCharacter, const FModifierKeysState& InModifierKeys, const FInputDeviceId InDeviceId, const bool bInIsRepeat)
        : FInputEvent(InModifierKeys, InDeviceId, bInIsRepeat)
        , Character(InCharacter)
    { }
 
    SLATECORE_API virtual ~FCharacterEvent();
 
    TCHAR GetCharacter() const
    {
        return Character;
    }
 
    SLATECORE_API virtual FText ToText() const override;    
 
private:
 
    // The character that was pressed.
    TCHAR Character;
};
 
 
template<>
struct TStructOpsTypeTraits<FCharacterEvent> : public TStructOpsTypeTraitsBase2<FCharacterEvent>
{
    enum
    {
        WithCopy = true,
    };
};
 
class FTouchKeySet
    : public TSet<FKey>
{
public:
 
    FTouchKeySet(FKey Key)
    {
        this->Add(Key);
    }
 
public:
 
    // The standard set consists of just the left mouse button key.
    SLATECORE_API static const FTouchKeySet StandardSet;
 
    // The empty set contains no valid keys.
    SLATECORE_API static const FTouchKeySet EmptySet;
};
 
 
 
USTRUCT(BlueprintType)
struct FPointerEvent
    : public FInputEvent
{
    GENERATED_USTRUCT_BODY()
public:
 
    FPointerEvent()
        : ScreenSpacePosition(FVector2f(0.f, 0.f))
        , LastScreenSpacePosition(FVector2f(0.f, 0.f))
        , CursorDelta(FVector2f(0.f, 0.f))
        , PressedButtons(&FTouchKeySet::EmptySet)
        , EffectingButton()
        , PointerIndex(0)
        , TouchpadIndex(0)
        , Force(1.0f)
        , bIsTouchEvent(false)
        , GestureType(EGestureEvent::None)
        , WheelOrGestureDelta(0.0f, 0)
        , bIsDirectionInvertedFromDevice(false)
        , bIsTouchForceChanged(false)
        , bIsTouchFirstMove(false)
    { }
 
    FPointerEvent(
        uint32 InPointerIndex,
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition,
        const TSet<FKey>& InPressedButtons,
        FKey InEffectingButton,
        float InWheelDelta,
        const FModifierKeysState& InModifierKeys
    )
        : FInputEvent(InModifierKeys, 0, false)
        , ScreenSpacePosition(InScreenSpacePosition)
        , LastScreenSpacePosition(InLastScreenSpacePosition)
        , CursorDelta(FVector2f(InScreenSpacePosition) - FVector2f(InLastScreenSpacePosition))
        , PressedButtons(&InPressedButtons)
        , EffectingButton(InEffectingButton)
        , PointerIndex(InPointerIndex)
        , TouchpadIndex(0)
        , Force(1.0f)
        , bIsTouchEvent(false)
        , GestureType(EGestureEvent::None)
        , WheelOrGestureDelta(0.0f, InWheelDelta)
        , bIsDirectionInvertedFromDevice(false)
        , bIsTouchForceChanged(false)
        , bIsTouchFirstMove(false)
    { }
 
    FPointerEvent(
        uint32 InUserIndex,
        uint32 InPointerIndex,
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition,
        const TSet<FKey>& InPressedButtons,
        FKey InEffectingButton,
        float InWheelDelta,
        const FModifierKeysState& InModifierKeys
    )
        : FInputEvent(InModifierKeys, InUserIndex, false)
        , ScreenSpacePosition(InScreenSpacePosition)
        , LastScreenSpacePosition(InLastScreenSpacePosition)
        , CursorDelta(FVector2f(InScreenSpacePosition) - FVector2f(InLastScreenSpacePosition))
        , PressedButtons(&InPressedButtons)
        , EffectingButton(InEffectingButton)
        , PointerIndex(InPointerIndex)
        , TouchpadIndex(0)
        , Force(1.0f)
        , bIsTouchEvent(false)
        , GestureType(EGestureEvent::None)
        , WheelOrGestureDelta(0.0f, InWheelDelta)
        , bIsDirectionInvertedFromDevice(false)
        , bIsTouchForceChanged(false)
        , bIsTouchFirstMove(false)
    { }
 
    FPointerEvent(
        FInputDeviceId InDeviceId,
        uint32 InPointerIndex,
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition,
        const TSet<FKey>& InPressedButtons,
        FKey InEffectingButton,
        float InWheelDelta,
        const FModifierKeysState& InModifierKeys,
        const TOptional<int32> InOptionalSlateUserIndex = TOptional<int32>()
    )
        : FInputEvent(InModifierKeys, InDeviceId, false)
        , ScreenSpacePosition(InScreenSpacePosition)
        , LastScreenSpacePosition(InLastScreenSpacePosition)
        , CursorDelta(FVector2f(InScreenSpacePosition) - FVector2f(InLastScreenSpacePosition))
        , PressedButtons(&InPressedButtons)
        , EffectingButton(InEffectingButton)
        , PointerIndex(InPointerIndex)
        , TouchpadIndex(0)
        , Force(1.0f)
        , bIsTouchEvent(false)
        , GestureType(EGestureEvent::None)
        , WheelOrGestureDelta(0.0f, InWheelDelta)
        , bIsDirectionInvertedFromDevice(false)
        , bIsTouchForceChanged(false)
        , bIsTouchFirstMove(false)
    {
        if (InOptionalSlateUserIndex.IsSet())
        {
            UserIndex = InOptionalSlateUserIndex.GetValue();
        }
    }
 
    FPointerEvent(
        uint32 InUserIndex,
        uint32 InPointerIndex,
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InDelta,
        const TSet<FKey>& InPressedButtons,
        const FModifierKeysState& InModifierKeys
    )
        : FInputEvent(InModifierKeys, InUserIndex, false)
        , ScreenSpacePosition(InScreenSpacePosition)
        , LastScreenSpacePosition(InLastScreenSpacePosition)
        , CursorDelta(InDelta)
        , PressedButtons(&InPressedButtons)
        , PointerIndex(InPointerIndex)
        , TouchpadIndex(0)
        , Force(1.0f)
        , bIsTouchEvent(false)
        , GestureType(EGestureEvent::None)
        , WheelOrGestureDelta(0.0f, 0.0f)
        , bIsDirectionInvertedFromDevice(false)
        , bIsTouchForceChanged(false)
        , bIsTouchFirstMove(false)
    { }
 
    FPointerEvent(
        uint32 InPointerIndex,
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InDelta,
        const TSet<FKey>& InPressedButtons,
        const FModifierKeysState& InModifierKeys
    )
        : FInputEvent(InModifierKeys, 0, false)
        , ScreenSpacePosition(InScreenSpacePosition)
        , LastScreenSpacePosition(InLastScreenSpacePosition)
        , CursorDelta(InDelta)
        , PressedButtons(&InPressedButtons)
        , PointerIndex(InPointerIndex)
        , TouchpadIndex(0)
        , Force(1.0f)
        , bIsTouchEvent(false)
        , GestureType(EGestureEvent::None)
        , WheelOrGestureDelta(0.0f, 0.0f)
        , bIsDirectionInvertedFromDevice(false)
        , bIsTouchForceChanged(false)
        , bIsTouchFirstMove(false)
    { }
 
    FPointerEvent(
        uint32 InUserIndex,
        uint32 InPointerIndex,
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition,
        float InForce,
        bool bPressLeftMouseButton,
        bool bInIsForceChanged = false,
        bool bInIsFirstMove = false,
        const FModifierKeysState& InModifierKeys = FModifierKeysState(),
        uint32 InTouchpadIndex=0
        )
    : FInputEvent(InModifierKeys, InUserIndex, false)
        , ScreenSpacePosition(InScreenSpacePosition)
        , LastScreenSpacePosition(InLastScreenSpacePosition)
        , CursorDelta(FVector2f(InScreenSpacePosition) - FVector2f(InLastScreenSpacePosition))
        , PressedButtons(bPressLeftMouseButton ? &FTouchKeySet::StandardSet : &FTouchKeySet::EmptySet)
        , EffectingButton(EKeys::LeftMouseButton)
        , PointerIndex(InPointerIndex)
        , TouchpadIndex(InTouchpadIndex)
        , Force(InForce)
        , bIsTouchEvent(true)
        , GestureType(EGestureEvent::None)
        , WheelOrGestureDelta(0.0f, 0.0f)
        , bIsDirectionInvertedFromDevice(false)
        , bIsTouchForceChanged(bInIsForceChanged)
        , bIsTouchFirstMove(bInIsFirstMove)
    { }
    
    FPointerEvent(
        FInputDeviceId InDeviceId,
        uint32 InPointerIndex,
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition,
        float InForce,
        bool bPressLeftMouseButton,
        bool bInIsForceChanged = false,
        bool bInIsFirstMove = false,
        const FModifierKeysState& InModifierKeys = FModifierKeysState(),
        uint32 InTouchpadIndex=0,
        const TOptional<int32> InOptionalSlateUserIndex = TOptional<int32>()
    )
    : FInputEvent(InModifierKeys, InDeviceId, false)
        , ScreenSpacePosition(InScreenSpacePosition)
        , LastScreenSpacePosition(InLastScreenSpacePosition)
        , CursorDelta(FVector2f(InScreenSpacePosition) - FVector2f(InLastScreenSpacePosition))
        , PressedButtons(bPressLeftMouseButton ? &FTouchKeySet::StandardSet : &FTouchKeySet::EmptySet)
        , EffectingButton(EKeys::LeftMouseButton)
        , PointerIndex(InPointerIndex)
        , TouchpadIndex(InTouchpadIndex)
        , Force(InForce)
        , bIsTouchEvent(true)
        , GestureType(EGestureEvent::None)
        , WheelOrGestureDelta(0.0f, 0.0f)
        , bIsDirectionInvertedFromDevice(false)
        , bIsTouchForceChanged(bInIsForceChanged)
        , bIsTouchFirstMove(bInIsFirstMove)
    {
        if (InOptionalSlateUserIndex.IsSet())
        {
            UserIndex = InOptionalSlateUserIndex.GetValue();
        }
    }
 
    FPointerEvent(
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition,
        const TSet<FKey>& InPressedButtons,
        const FModifierKeysState& InModifierKeys,
        EGestureEvent InGestureType,
        const UE::Slate::FDeprecateVector2DParameter& InGestureDelta,
        bool bInIsDirectionInvertedFromDevice
    )
        : FInputEvent(InModifierKeys, 0, false)
        , ScreenSpacePosition(InScreenSpacePosition)
        , LastScreenSpacePosition(InLastScreenSpacePosition)
        , CursorDelta(FVector2f(LastScreenSpacePosition) - FVector2f(ScreenSpacePosition))
        , PressedButtons(&InPressedButtons)
        , PointerIndex(0)
        , TouchpadIndex(0)
        , Force(1.0f)
        , bIsTouchEvent(InGestureType != EGestureEvent::None)
        , GestureType(InGestureType)
        , WheelOrGestureDelta(InGestureDelta)
        , bIsDirectionInvertedFromDevice(bInIsDirectionInvertedFromDevice)
        , bIsTouchForceChanged(false)
        , bIsTouchFirstMove(false)
    { }
 
    FPointerEvent(
        const FPointerEvent& Other,
        const UE::Slate::FDeprecateVector2DParameter& InScreenSpacePosition,
        const UE::Slate::FDeprecateVector2DParameter& InLastScreenSpacePosition)
    {
        *this = Other;
        ScreenSpacePosition = InScreenSpacePosition;
        LastScreenSpacePosition = InLastScreenSpacePosition;
    }
 
    SLATECORE_API virtual ~FPointerEvent();
 
public:
 
    const UE::Slate::FDeprecateVector2DResult& GetScreenSpacePosition() const { return ScreenSpacePosition; }
 
    const UE::Slate::FDeprecateVector2DResult& GetLastScreenSpacePosition() const { return LastScreenSpacePosition; }
 
    const UE::Slate::FDeprecateVector2DResult& GetCursorDelta() const { return CursorDelta; }
 
    bool IsMouseButtonDown( FKey MouseButton ) const { return PressedButtons->Contains( MouseButton ); }
 
    FKey GetEffectingButton() const { return EffectingButton; }
    
    float GetWheelDelta() const { return UE_REAL_TO_FLOAT(WheelOrGestureDelta.Y); }
 
    uint32 GetPointerIndex() const { return PointerIndex; }
 
    uint32 GetTouchpadIndex() const { return TouchpadIndex; }
 
    float GetTouchForce() const { return Force; }
 
    bool IsTouchEvent() const { return bIsTouchEvent; }
 
    bool IsTouchForceChangedEvent() const { return bIsTouchForceChanged; }
 
    bool IsTouchFirstMoveEvent() const { return bIsTouchFirstMove; }
 
    EGestureEvent GetGestureType() const { return GestureType; }
 
    const UE::Slate::FDeprecateVector2DResult& GetGestureDelta() const { return WheelOrGestureDelta; }
 
    bool IsDirectionInvertedFromDevice() const { return bIsDirectionInvertedFromDevice; }
 
    const TSet<FKey>& GetPressedButtons() const { return *PressedButtons; }
 
    SLATECORE_API virtual FText ToText() const override;
 
    SLATECORE_API virtual bool IsPointerEvent() const override;
 
    template<typename PointerEventType>
    static PointerEventType MakeTranslatedEvent( const PointerEventType& InPointerEvent, const FVirtualPointerPosition& VirtualPosition )
    {
        PointerEventType NewEvent = InPointerEvent;
        NewEvent.ScreenSpacePosition = VirtualPosition.CurrentCursorPosition;
        NewEvent.LastScreenSpacePosition = VirtualPosition.LastCursorPosition;
        //NewEvent.CursorDelta = VirtualPosition.GetDelta();
        return NewEvent;
    }
 
private:
 
    UE::Slate::FDeprecateVector2DResult ScreenSpacePosition;
    UE::Slate::FDeprecateVector2DResult LastScreenSpacePosition;
    UE::Slate::FDeprecateVector2DResult CursorDelta;
    const TSet<FKey>* PressedButtons;
    FKey EffectingButton;
    uint32 PointerIndex;
    uint32 TouchpadIndex;
    float Force;
    bool bIsTouchEvent;
    EGestureEvent GestureType;
    UE::Slate::FDeprecateVector2DResult WheelOrGestureDelta;
    bool bIsDirectionInvertedFromDevice;
    bool bIsTouchForceChanged;
    bool bIsTouchFirstMove;
    // NOTE: If you add a new member, make sure you add it to the assignment operator.
};
 
 
template<>
struct TStructOpsTypeTraits<FPointerEvent> : public TStructOpsTypeTraitsBase2<FPointerEvent>
{
    enum
    {
        WithCopy = true,
    };
};
 
 
USTRUCT(BlueprintType)
struct FMotionEvent
    : public FInputEvent
{
    GENERATED_USTRUCT_BODY()
 
public:
    FMotionEvent()
        : Tilt(FVector(0, 0, 0))
        , RotationRate(FVector(0, 0, 0))
        , Gravity(FVector(0, 0, 0))
        , Acceleration(FVector(0, 0, 0))
    { }
 
    FMotionEvent(
        uint32 InUserIndex,
        const FVector& InTilt, 
        const FVector& InRotationRate, 
        const FVector& InGravity, 
        const FVector& InAcceleration
    )
        : FInputEvent(FModifierKeysState(), InUserIndex, false)
        , Tilt(InTilt)
        , RotationRate(InRotationRate)
        , Gravity(InGravity)
        , Acceleration(InAcceleration)
    { }
 
    FMotionEvent(
        const FInputDeviceId InDeviceId,
        const FVector& InTilt, 
        const FVector& InRotationRate, 
        const FVector& InGravity, 
        const FVector& InAcceleration
    )
        : FInputEvent(FModifierKeysState(), InDeviceId, false)
        , Tilt(InTilt)
        , RotationRate(InRotationRate)
        , Gravity(InGravity)
        , Acceleration(InAcceleration)
    { }
 
public:
 
    const FVector& GetTilt() const { return Tilt; }
 
    const FVector& GetRotationRate() const { return RotationRate; }
 
    const FVector& GetGravity() const { return Gravity; }
 
    const FVector& GetAcceleration() const { return Acceleration; }
 
private:
 
    // The current tilt of the device/controller.
    FVector Tilt;
 
    // The rotation speed.
    FVector RotationRate;
 
    // The gravity vector (pointing down into the ground).
    FVector Gravity;
 
    // The 3D acceleration of the device.
    FVector Acceleration;
};
 
 
template<>
struct TStructOpsTypeTraits<FMotionEvent> : public TStructOpsTypeTraitsBase2<FMotionEvent>
{
    enum
    {
        WithCopy = true,
    };
};
 
USTRUCT(BlueprintType)
struct FNavigationEvent
    : public FInputEvent
{
    GENERATED_USTRUCT_BODY()
 
public:
    FNavigationEvent()
        : NavigationType(EUINavigation::Invalid)
        , NavigationGenesis(ENavigationGenesis::User)
    { }
 
    FNavigationEvent(const FModifierKeysState& InModifierKeys, const int32 InUserIndex, EUINavigation InNavigationType, ENavigationGenesis InNavigationGenesis)
        : FInputEvent(InModifierKeys, InUserIndex, false)
        , NavigationType(InNavigationType)
        , NavigationGenesis(InNavigationGenesis)
    { }
 
    FNavigationEvent(const FModifierKeysState& InModifierKeys, const FInputDeviceId InDeviceId, EUINavigation InNavigationType, ENavigationGenesis InNavigationGenesis)
        : FInputEvent(InModifierKeys, InDeviceId, false)
        , NavigationType(InNavigationType)
        , NavigationGenesis(InNavigationGenesis)
    { }
 
public:
 
    EUINavigation GetNavigationType() const { return NavigationType; }
 
    ENavigationGenesis GetNavigationGenesis() const { return NavigationGenesis; }
 
private:
 
    // The navigation type
    EUINavigation NavigationType;
 
    // The navigation genesis
    ENavigationGenesis NavigationGenesis;
};
 
 
template<>
struct TStructOpsTypeTraits<FNavigationEvent> : public TStructOpsTypeTraitsBase2<FNavigationEvent>
{
    enum
    {
        WithCopy = true,
    };
};
 
class FWindowActivateEvent
{
public:
 
    enum EActivationType
    {
        EA_Activate,
        EA_ActivateByMouse,
        EA_Deactivate
    };
 
    FWindowActivateEvent( EActivationType InActivationType, TSharedRef<SWindow> InAffectedWindow )
        : ActivationType(InActivationType)
        , AffectedWindow(InAffectedWindow)
    { }
 
public:
 
    EActivationType GetActivationType() const
    {
        return ActivationType;
    }
 
    void SetActivationType(EActivationType InActivationType)
    {
        ActivationType = InActivationType;
    }
 
    TSharedRef<SWindow> GetAffectedWindow() const
    {
        return AffectedWindow;
    }
 
private:
 
    EActivationType ActivationType;
    TSharedRef<SWindow> AffectedWindow;
};