WidgetPath.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Types/SlateEnums.h"
#include "Layout/Visibility.h"
#include "Layout/ArrangedWidget.h"
#include "Widgets/SWidget.h"
#include "Widgets/SWindow.h"
 
enum class EWidgetPathSearchPurpose
{
    Standard,
 
    FocusHandling
};
 
struct FWidgetMatcher
{
    FWidgetMatcher( const TSharedRef<const SWidget> InWidget )
        : WidgetToFind( InWidget )
    {}
 
    bool IsMatch( const TSharedRef<const SWidget>& InWidget ) const
    {
        return WidgetToFind == InWidget;
    }
 
    TSharedRef<const SWidget> WidgetToFind;
};
 
class FWidgetPath
{
public:
    SLATECORE_API FWidgetPath();
 
    SLATECORE_API FWidgetPath( TSharedPtr<SWindow> InTopLevelWindow, const FArrangedChildren& InWidgetPath );
 
    SLATECORE_API FWidgetPath( TArrayView<FWidgetAndPointer> InWidgetsAndPointers );
 
    SLATECORE_API FWidgetPath GetPathDownTo( TSharedRef<const SWidget> MarkerWidget ) const;
 
    TOptional<FVirtualPointerPosition> GetVirtualPointerPosition(int32 Index) const
    {
        return VirtualPointerPositions[Index];
    }
    
    SLATECORE_API bool ContainsWidget( const SWidget* WidgetToFind ) const;
 
    SLATECORE_API TOptional<FArrangedWidget> FindArrangedWidget( TSharedRef<const SWidget> WidgetToFind ) const;
 
    SLATECORE_API TOptional<FWidgetAndPointer> FindArrangedWidgetAndCursor( TSharedRef<const SWidget> WidgetToFind ) const;
 
    SLATECORE_API TSharedRef<SWindow> GetWindow() const;
 
    SLATECORE_API TSharedRef<SWindow> GetDeepestWindow() const;
 
    SLATECORE_API bool IsValid() const;
    
    SLATECORE_API FString ToString() const;
 
    template<typename MatcherType>
    bool ExtendPathTo( const MatcherType& Matcher, EVisibility VisibilityFilter = EVisibility::Visible, EWidgetPathSearchPurpose SearchPurpose = EWidgetPathSearchPurpose::Standard)
    {
        const FArrangedWidget& LastWidget = Widgets.Last();
        
        FArrangedChildren Extension = GeneratePathToWidget(Matcher, LastWidget, EUINavigation::Next, VisibilityFilter, SearchPurpose);
 
        for( int32 WidgetIndex=0; WidgetIndex < Extension.Num(); ++WidgetIndex )
        {
            this->Widgets.AddWidget( Extension[WidgetIndex] );
        }
 
        return Extension.Num() > 0;
    }
 
    template<typename MatcherType>
    FArrangedChildren GeneratePathToWidget(const MatcherType& Matcher, const FArrangedWidget& FromWidget, EUINavigation NavigationType = EUINavigation::Next, EVisibility VisibilityFilter = EVisibility::Visible, EWidgetPathSearchPurpose SearchPurpose = EWidgetPathSearchPurpose::Standard)
    {
        FArrangedChildren PathResult(VisibilityFilter);
 
        if (NavigationType == EUINavigation::Next)
        {
            SearchForWidgetRecursively( Matcher, FromWidget, PathResult, VisibilityFilter, SearchPurpose);
        }
        else
        {
            SearchForWidgetRecursively_Reverse( Matcher, FromWidget, PathResult, VisibilityFilter, SearchPurpose);
        }
        
 
        // Reverse the list of widgets we found; canonical form is leafmost last.
        PathResult.Reverse();
 
        return PathResult;
    }
    
    SLATECORE_API bool MoveFocus(int32 PathLevel, EUINavigation NavigationType, bool bSearchFromPathWidget = true);
 
    TSharedRef< SWidget > GetLastWidget() const
    {
        check(IsValid());
        return Widgets[Widgets.Num() - 1].Widget;
    }
 
public:
 
    FArrangedChildren Widgets;
 
    TSharedPtr<SWindow> TopLevelWindow;
 
private:
    TArray<TOptional<FVirtualPointerPosition>> VirtualPointerPositions;
 
private:
 
    template<typename MatchRuleType>
    static bool SearchForWidgetRecursively( const MatchRuleType& MatchRule, const FArrangedWidget& InCandidate, FArrangedChildren& OutReversedPath, EVisibility VisibilityFilter = EVisibility::Visible, EWidgetPathSearchPurpose SearchPurpose = EWidgetPathSearchPurpose::Standard);
 
    template<typename MatchRuleType>
    static bool SearchForWidgetRecursively_Reverse( const MatchRuleType& MatchRule, const FArrangedWidget& InCandidate, FArrangedChildren& OutReversedPath, EVisibility VisibilityFilter = EVisibility::Visible, EWidgetPathSearchPurpose SearchPurpose = EWidgetPathSearchPurpose::Standard);
};
 
class FWeakWidgetPath
{
public:
    SLATECORE_API FWeakWidgetPath( const FWidgetPath& InWidgetPath = FWidgetPath() );
 
    struct EInterruptedPathHandling
    {
        enum Type
        {
            Truncate,
            ReturnInvalid
        };
    };
 
    SLATECORE_API FWidgetPath ToWidgetPath( EInterruptedPathHandling::Type InterruptedPathHandling = EInterruptedPathHandling::Truncate, const FPointerEvent* PointerEvent = nullptr, const EVisibility VisibilityFilter = EVisibility::Visible) const;
 
    SLATECORE_API TSharedRef<FWidgetPath> ToWidgetPathRef( EInterruptedPathHandling::Type InterruptedPathHandling = EInterruptedPathHandling::Truncate, const FPointerEvent* PointerEvent = nullptr, const EVisibility VisibilityFilter = EVisibility::Visible) const;
 
    struct EPathResolutionResult
    {
        enum Result
        {
            Live,
            Truncated
        };
    };
 
    SLATECORE_API bool ContainsWidget(const SWidget* WidgetToFind) const;
 
    SLATECORE_API EPathResolutionResult::Result ToWidgetPath( FWidgetPath& WidgetPath, EInterruptedPathHandling::Type InterruptedPathHandling = EInterruptedPathHandling::Truncate, const FPointerEvent* PointerEvent = nullptr, const EVisibility VisibilityFilter = EVisibility::Visible) const;
 
    SLATECORE_API FWidgetPath ToNextFocusedPath(EUINavigation NavigationType) const;
 
    SLATECORE_API FWidgetPath ToNextFocusedPath(EUINavigation NavigationType, const FNavigationReply& NavigationReply, const FArrangedWidget& RuleWidget) const;
    
    TWeakPtr< SWidget > GetLastWidget() const
    {
        check( IsValid() );
        return Widgets[Widgets.Num()-1];
    }
    
    bool IsValid() const { return Widgets.Num() > 0; }
 
    TArray< TWeakPtr<SWidget> > Widgets;
    TWeakPtr< SWindow > Window;
};
 
#include "Layout/WidgetPath.inl" // IWYU pragma: export