SlateUser.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "SlateScope.h"
#include "Layout/WidgetPath.h"
#include "GestureDetector.h"
 
class SWidget;
class SWindow;
class ICursor;
class FDragDropOperation;
class FMenuStack;
class FNavigationConfig;
 
class FSlateVirtualUserHandle
{
public:
    SLATE_API virtual ~FSlateVirtualUserHandle();
 
    inline int32 GetUserIndex() const { return UserIndex; }
    inline int32 GetVirtualUserIndex() const { return VirtualUserIndex; }
 
SLATE_SCOPE:
    FSlateVirtualUserHandle(int32 InUserIndex, int32 InVirtualUserIndex);
 
private:
    int32 UserIndex;
 
    int32 VirtualUserIndex;
};
 
class FSlateUser : public TSharedFromThis<FSlateUser>
{
public:
    SLATE_API virtual ~FSlateUser();
 
    inline int32 GetUserIndex() const { return UserIndex; }
    inline FPlatformUserId GetPlatformUserId() const { return PlatformUser; }
    inline bool IsVirtualUser() const { return !Cursor.IsValid(); }
 
    SLATE_API TSharedPtr<SWidget> GetFocusedWidget() const;
    SLATE_API bool ShouldShowFocus(TSharedPtr<const SWidget> Widget) const;
    SLATE_API bool SetFocus(const TSharedRef<SWidget>& WidgetToFocus, EFocusCause ReasonFocusIsChanging = EFocusCause::SetDirectly);
    SLATE_API void ClearFocus(EFocusCause ReasonFocusIsChanging = EFocusCause::SetDirectly);
 
    SLATE_API TOptional<EFocusCause> HasFocus(TSharedPtr<const SWidget> Widget) const;
 
    SLATE_API bool HasFocusedDescendants(TSharedRef<const SWidget> Widget) const;
 
    SLATE_API bool IsWidgetInFocusPath(TSharedPtr<const SWidget> Widget) const;
    
    SLATE_API bool HasAnyCapture() const;
    SLATE_API bool HasCursorCapture() const;
    SLATE_API bool HasCapture(uint32 PointerIndex) const;
    
    SLATE_API bool DoesWidgetHaveAnyCapture(TSharedPtr<const SWidget> Widget) const;
    SLATE_API bool DoesWidgetHaveCursorCapture(TSharedPtr<const SWidget> Widget) const;
    SLATE_API bool DoesWidgetHaveCapture(TSharedPtr<const SWidget> Widget, uint32 PointerIndex) const;
    
    SLATE_API bool SetCursorCaptor(TSharedRef<const SWidget> Widget, const FWidgetPath& EventPath);
    SLATE_API bool SetPointerCaptor(uint32 PointerIndex, TSharedRef<const SWidget> Widget, const FWidgetPath& EventPath);
    
    SLATE_API void ReleaseAllCapture();
    SLATE_API void ReleaseCursorCapture();
    SLATE_API void ReleaseCapture(uint32 PointerIndex);
 
    SLATE_API TArray<FWidgetPath> GetCaptorPaths();
    SLATE_API FWidgetPath GetCursorCaptorPath(FWeakWidgetPath::EInterruptedPathHandling::Type InterruptedPathHandling = FWeakWidgetPath::EInterruptedPathHandling::Truncate, const FPointerEvent* PointerEvent = nullptr);
    SLATE_API FWidgetPath GetCaptorPath(uint32 PointerIndex, FWeakWidgetPath::EInterruptedPathHandling::Type InterruptedPathHandling = FWeakWidgetPath::EInterruptedPathHandling::Truncate, const FPointerEvent* PointerEvent = nullptr);
 
    SLATE_API FWeakWidgetPath GetWeakCursorCapturePath() const;
    SLATE_API FWeakWidgetPath GetWeakCapturePath(uint32 PointerIndex) const;
 
    SLATE_API TArray<TSharedRef<SWidget>> GetCaptorWidgets() const;
    SLATE_API TSharedPtr<SWidget> GetCursorCaptor() const;
    SLATE_API TSharedPtr<SWidget> GetPointerCaptor(uint32 PointerIndex) const;
 
    SLATE_API void SetCursorVisibility(bool bDrawCursor);
    SLATE_API bool IsCursorVisible() const;
 
    SLATE_API void SetCursorPosition(int32 PosX, int32 PosY);
    SLATE_API void SetCursorPosition(const UE::Slate::FDeprecateVector2DParameter& NewCursorPos);
    SLATE_API void SetPointerPosition(uint32 PointerIndex, int32 PosX, int32 PosY);
    SLATE_API void SetPointerPosition(uint32 PointerIndex, const UE::Slate::FDeprecateVector2DParameter& NewPointerPos);
    
    SLATE_API UE::Slate::FDeprecateVector2DResult GetCursorPosition() const;
    SLATE_API UE::Slate::FDeprecateVector2DResult GetPreviousCursorPosition() const;
    
    SLATE_API UE::Slate::FDeprecateVector2DResult GetPointerPosition(uint32 PointerIndex) const;
    SLATE_API UE::Slate::FDeprecateVector2DResult GetPreviousPointerPosition(uint32 PointerIndex) const;
 
    SLATE_API bool IsWidgetUnderCursor(TSharedPtr<const SWidget> Widget) const;
    SLATE_API bool IsWidgetUnderPointer(TSharedPtr<const SWidget> Widget, uint32 PointerIndex) const;
    SLATE_API bool IsWidgetUnderAnyPointer(TSharedPtr<const SWidget> Widget) const;
 
    SLATE_API bool IsWidgetDirectlyUnderCursor(TSharedPtr<const SWidget> Widget) const;
    SLATE_API bool IsWidgetDirectlyUnderPointer(TSharedPtr<const SWidget> Widget, uint32 PointerIndex) const;
    SLATE_API bool IsWidgetDirectlyUnderAnyPointer(TSharedPtr<const SWidget> Widget) const;
 
    SLATE_API FWeakWidgetPath GetLastWidgetsUnderCursor() const;
    SLATE_API FWeakWidgetPath GetLastWidgetsUnderPointer(uint32 PointerIndex) const;
    const TMap<uint32, FWeakWidgetPath>& GetWidgetsUnderPointerLastEventByIndex() const { return WidgetsUnderPointerLastEventByIndex; }
 
    TSharedPtr<FDragDropOperation> GetDragDropContent() const { return DragDropContent; }
    SLATE_API bool IsDragDropping() const;
    SLATE_API bool IsDragDroppingAffected(const FPointerEvent& InPointerEvent) const;
    SLATE_API void CancelDragDrop();
    
    SLATE_API void ShowTooltip(const TSharedRef<IToolTip>& InTooltip, const UE::Slate::FDeprecateVector2DParameter& InSpawnLocation);
    SLATE_API void CloseTooltip();
    SLATE_API FVector2f GetTooltipPosition() const;
 
    const FGestureDetector& GetGestureDetector() const { return GestureDetector; }
 
    SLATE_API void SetUserNavigationConfig(TSharedPtr<FNavigationConfig> InNavigationConfig);
    TSharedPtr<FNavigationConfig> GetUserNavigationConfig() const { return UserNavigationConfig; }
 
SLATE_SCOPE:
    static TSharedRef<FSlateUser> Create(int32 InUserIndex, TSharedPtr<ICursor> InCursor);
    static SLATE_API TSharedRef<FSlateUser> Create(FPlatformUserId InPlatformUserId, TSharedPtr<ICursor> InCursor);
    
    inline bool HasValidFocusPath() const { return WeakFocusPath.IsValid(); }
    inline const FWeakWidgetPath& GetWeakFocusPath() const { return WeakFocusPath; }
    
    inline TSharedRef<FWidgetPath> GetFocusPath() const
    {
        if (!StrongFocusPath.IsValid())
        {
            StrongFocusPath = WeakFocusPath.ToWidgetPathRef();
        }
        return StrongFocusPath.ToSharedRef();
    }
 
    SLATE_API void DrawWindowlessDragDropContent(const TSharedRef<SWindow>& WindowToDraw, FSlateWindowElementList& WindowElementList, int32& MaxLayerId);
    SLATE_API void DrawCursor(const TSharedRef<SWindow>& WindowToDraw, FSlateWindowElementList& WindowElementList, int32& MaxLayerId);
 
    SLATE_API void QueueSyntheticCursorMove();
    SLATE_API bool SynthesizeCursorMoveIfNeeded();
 
    TSharedPtr<ICursor> GetCursor() const { return Cursor; }
    SLATE_API void LockCursor(const TSharedRef<SWidget>& Widget);
    SLATE_API void UnlockCursor();
    SLATE_API void UpdateCursor();
    SLATE_API void ProcessCursorReply(const FCursorReply& CursorReply);
    void RequestCursorQuery() { bQueryCursorRequested = true; }
    SLATE_API void QueryCursor();
    void OverrideCursor(const TSharedPtr<ICursor> InCursor) { Cursor = InCursor; }
    
    SLATE_API void SetFocusPath(const FWidgetPath& NewFocusPath, EFocusCause InFocusCause, bool bInShowFocus);
    
    SLATE_API void FinishFrame();
    SLATE_API void NotifyWindowDestroyed(TSharedRef<SWindow> DestroyedWindow);
 
    SLATE_API bool IsTouchPointerActive(int32 TouchPointerIndex) const;
 
    SLATE_API void NotifyTouchStarted(const FPointerEvent& TouchEvent);
    SLATE_API void NotifyPointerMoveBegin(const FPointerEvent& PointerEvent);
    SLATE_API void NotifyPointerMoveComplete(const FPointerEvent& PointerEvent, const FWidgetPath& WidgetsUnderPointer);
    SLATE_API void NotifyPointerReleased(const FPointerEvent& PointerEvent, const FWidgetPath& WidgetsUnderCursor, TSharedPtr<FDragDropOperation> DroppedContent, bool bWasHandled);
    SLATE_API void UpdatePointerPosition(const FPointerEvent& PointerEvent);
 
    SLATE_API void StartDragDetection(const FWidgetPath& PathToWidget, int32 PointerIndex, FKey DragButton, UE::Slate::FDeprecateVector2DParameter StartLocation);
    SLATE_API FWidgetPath DetectDrag(const FPointerEvent& PointerEvent, float DragTriggerDistance);
    SLATE_API bool IsDetectingDrag(uint32 PointerIndex) const;
    SLATE_API void ResetDragDetection();
 
    SLATE_API void SetDragDropContent(TSharedRef<FDragDropOperation> InDragDropContent);
    SLATE_API void ResetDragDropContent();
 
    int32 GetFocusVersion() const { return FocusVersion; }
    void IncrementFocusVersion() { FocusVersion++; }
 
    SLATE_API void UpdateTooltip(const FMenuStack& MenuStack, bool bCanSpawnNewTooltip);
    SLATE_API void ResetTooltipWindow();
    SLATE_API bool IsWindowHousingInteractiveTooltip(const TSharedRef<const SWindow>& WindowToTest) const;
 
    FGestureDetector& GetGestureDetector() { return GestureDetector; }
 
#if PLATFORM_MAC
    // Unclear why from existing code, but Mac seems to need to cache & restore all mouse captor paths when activating the top level window
    const TMap<uint32, FWeakWidgetPath> GetCaptorPathsByIndex() const { return PointerCaptorPathsByIndex; }
    void RestoreCaptorPathsByIndex(const TMap<uint32, FWeakWidgetPath>& InPointerCaptorPathsByIndex) { PointerCaptorPathsByIndex = InPointerCaptorPathsByIndex; }
#endif
 
private:
    SLATE_API FSlateUser(int32 InUserIndex, TSharedPtr<ICursor> InCursor);
    
    SLATE_API FSlateUser(FPlatformUserId InPlatformUser, TSharedPtr<ICursor> InCursor);
    SLATE_API void UpdatePointerPosition(uint32 PointerIndex, const FVector2f& Position);
    SLATE_API void LockCursorInternal(const FWidgetPath& WidgetPath);
    SLATE_API TSharedRef<SWindow> GetOrCreateTooltipWindow();
 
    int32 UserIndex = INDEX_NONE;
 
    FPlatformUserId PlatformUser = PLATFORMUSERID_NONE;
 
    TSharedPtr<ICursor> Cursor;
 
    double LastCursorSignificantMoveTime = 0.0;
 
    TSharedPtr<FNavigationConfig> UserNavigationConfig;
 
    bool bCanDrawCursor = true;
 
    bool bNeedQueryForVisibleCursor = true;
 
    bool bQueryCursorRequested = false;
 
    int32 NumPendingSyntheticCursorMoves = 0;
 
    TWeakPtr<SWindow> CursorWindowPtr;
    TWeakPtr<SWidget> CursorWidgetPtr;
 
    FWeakWidgetPath WeakFocusPath;
 
    mutable TSharedPtr<FWidgetPath> StrongFocusPath;
 
    EFocusCause FocusCause = EFocusCause::Cleared;
 
    bool bShowFocus = false;
 
    int32 FocusVersion = 0;
 
    TMap<uint32, FVector2f> PointerPositionsByIndex;
    TMap<uint32, FVector2f> PreviousPointerPositionsByIndex;
 
    TMap<uint32, FWeakWidgetPath> PointerCaptorPathsByIndex;
 
    struct FDragDetectionState
    {
        FDragDetectionState(const FWidgetPath& PathToWidget, int32 PointerIndex, FKey DragButton, const FVector2f& StartLocation)
            : DetectDragForWidget(PathToWidget)
            , DragStartLocation(StartLocation)
            , TriggerButton(DragButton)
            , PointerIndex(PointerIndex)
        {
        }
 
        FWeakWidgetPath DetectDragForWidget;
 
        FVector2f DragStartLocation = FVector2f::ZeroVector;
        FKey TriggerButton = EKeys::Invalid;
        int32 PointerIndex = INDEX_NONE;
    };
 
    TMap<uint32, FDragDetectionState> DragStatesByPointerIndex;
 
    TSharedPtr<FDragDropOperation> DragDropContent;
 
    TWeakPtr<SWindow> DragDropWindowPtr;
 
    TMap<uint32, FWeakWidgetPath> WidgetsUnderPointerLastEventByIndex;
 
    FWeakWidgetPath LockingWidgetPath;
 
    FSlateRect LastComputedLockBounds;
 
    TWeakPtr<SWindow> TooltipWindowPtr;
 
    enum class ETooltipOffsetDirection : uint8
    {
        Undetermined,
        Down,
        Right
    };
    struct FActiveTooltipInfo
    {
        void Reset();
 
        TWeakPtr<IToolTip> Tooltip;
 
        TWeakPtr<SWidget> TooltipVisualizer;
 
        TWeakPtr<SWidget> SourceWidget;
 
        FVector2f DesiredLocation = FVector2f::ZeroVector;
 
        FVector2f DesiredSize = FVector2f::ZeroVector;
 
        double SummonTime = 0.0;
 
        ETooltipOffsetDirection OffsetDirection = ETooltipOffsetDirection::Undetermined;
 
        bool WasInteractive = false;
 
        bool HasBeenPositioned = false;
    };
    FActiveTooltipInfo ActiveTooltipInfo;
 
    FGestureDetector GestureDetector;
};