DlgTreeViewNode.h

Go to the documentation of this file.

// Copyright Csaba Molnar, Daniel Butum. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "Widgets/Views/STreeView.h"
 
template <class SelfType>
class FDlgTreeViewNode : public TSharedFromThis<SelfType>
{
public:
    /* Create a listing for a search result*/
    FDlgTreeViewNode(const FText& InDisplayText, const TSharedPtr<SelfType>& InParent)
        : Parent(InParent), DisplayText(InDisplayText) {}
    virtual ~FDlgTreeViewNode() {}
 
    /* Called when user clicks on the search item */
    virtual FReply OnClick()
    {
        // If there is a parent, handle it using the parent's functionality
        if (Parent.IsValid())
        {
            return Parent.Pin()->OnClick();
        }
 
        return FReply::Unhandled();
    }
 
    // DisplayText:
    FText GetDisplayText() const { return DisplayText; }
    FName GetDisplayTextAsFName() const { return FName(*DisplayText.ToString()); }
    void SetDisplayText(const FText& InText) { DisplayText = InText; }
    bool DoesDisplayTextContains(const FString& InSearch, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase)
    {
        return DisplayText.ToString().Contains(InSearch, SearchCase);
    }
 
    // Parent:
    bool HasParent() const { return Parent.IsValid(); }
    TWeakPtr<SelfType> GetParent() const { return Parent; }
    void SetParent(TWeakPtr<SelfType> InParentNode) { Parent = InParentNode; }
    void ClearParent() { Parent.Reset(); }
 
    // Children:
    bool HasChildren() const { return Children.Num() > 0; }
    const TArray<TSharedPtr<SelfType>>& GetChildren() const { return Children; }
    void GetVisibleChildren(TArray<TSharedPtr<SelfType>>& OutChildren)
    {
        for (const TSharedPtr<SelfType>& Child : Children)
        {
            if (Child->IsVisible())
            {
                OutChildren.Add(Child);
            }
        }
    }
    virtual void AddChild(const TSharedPtr<SelfType>& ChildNode)
    {
        ensure(!ChildNode->IsRoot());
        ChildNode->SetParent(this->AsShared());
        Children.Add(ChildNode);
    }
    virtual void SetChildren(const TArray<TSharedPtr<SelfType>>& InChildren)
    {
        Children = InChildren;
        for (const TSharedPtr<SelfType>& Child : Children)
        {
            ensure(!Child->IsRoot());
            Child->SetParent(this->AsShared());
        }
    }
    virtual void ClearChildren()
    {
        Children.Empty();
    }
 
    // bIsVisible:
    bool IsVisible() const { return bIsVisible; }
    void SetIsVisible(bool InIsVisible) { bIsVisible = InIsVisible; }
 
    bool IsRoot() const { return !Parent.IsValid(); }
 
    bool IsLeaf() const { return Children.Num() == 0; }
 
    void ExpandAllChildren(const TSharedPtr<STreeView<TSharedPtr<SelfType>>>& TreeView, bool bRecursive = true)
    {
        static constexpr bool bShouldExpandItem = true;
        if (!HasChildren())
        {
            return;
        }
 
        TreeView->SetItemExpansion(this->AsShared(), bShouldExpandItem);
        for (const TSharedPtr<SelfType>& ChildNode : Children)
        {
            if (bRecursive)
            {
                // recursive on all children.
                ChildNode->ExpandAllChildren(TreeView, bRecursive);
            }
            else
            {
                // Only direct children
                TreeView->SetItemExpansion(ChildNode, bShouldExpandItem);
            }
        }
    }
 
    void GetAllNodes(TArray<TSharedPtr<SelfType>>& OutNodeArray) const
    {
        for (const TSharedPtr<SelfType>& ChildNode : Children)
        {
            OutNodeArray.Add(ChildNode);
            ChildNode->GetAllNodes(OutNodeArray);
        }
    }
 
    virtual void FilterPathsToNodesThatContainText(const FString& InSearch, TArray<TArray<TSharedPtr<SelfType>>>& OutNodes)
    {
        for (int32 Index = 0, Num = Children.Num(); Index < Num; Index++)
        {
            TSharedPtr<SelfType> CurrentChild = Children[Index];
            CurrentChild->SetIsVisible(false);
            GetPathToChildThatContainsText(Children[Index], InSearch, OutNodes);
 
            // Let child classes handle this themselves
            PostFilterPathsToNodes(CurrentChild);
        }
    }
 
protected:
    virtual void PostFilterPathsToNodes(const TSharedPtr<SelfType>& Child) {}
 
    virtual void PostBuildPathToTopMostParent(const TSharedPtr<SelfType>& CurrentParentNode) {}
 
    virtual bool FilterIsChildVisible(const TSharedPtr<SelfType>& GrandChild)
    {
        return GrandChild->IsLeaf();
    }
 
    virtual bool FilterDoesChildContainText(const TSharedPtr<SelfType>& Child, const FString& InSearch)
    {
        return Child->DoesDisplayTextContains(InSearch);
    }
 
    virtual void GetPathToChildThatContainsText(
        const TSharedPtr<SelfType>& Child,
        const FString& InSearch,
        TArray<TArray<TSharedPtr<SelfType>>>& OutNodes
    )
    {
        // Child has text, build path to it
        bool bChildIsVisible;
        if (FilterDoesChildContainText(Child, InSearch))
        {
            bChildIsVisible = true;
 
            // Build path to top most parent
            TSharedPtr<SelfType> CurrentNode = Child;
            TArray<TSharedPtr<SelfType>> ChildOutNodes;
            while (CurrentNode->HasParent())
            {
                ChildOutNodes.Add(CurrentNode);
 
                // Parents are visible too
                TSharedPtr<SelfType> CurrentParentNode = CurrentNode->GetParent().Pin();
                CurrentParentNode->SetIsVisible(bChildIsVisible);
 
                // Advance up the tree
                CurrentNode = CurrentParentNode;
 
                PostBuildPathToTopMostParent(CurrentParentNode);
            }
 
            // reverse
            Algo::Reverse(ChildOutNodes);
            OutNodes.Emplace(ChildOutNodes);
        }
        else
        {
            bChildIsVisible = false;
        }
        Child->SetIsVisible(bChildIsVisible);
 
        // Check children
        for (const TSharedPtr<SelfType>& GrandChild : Child->GetChildren())
        {
            GetPathToChildThatContainsText(GrandChild, InSearch, OutNodes);
            GrandChild->SetIsVisible(bChildIsVisible && FilterIsChildVisible(GrandChild));
        }
    }
 
protected:
    TArray<TSharedPtr<SelfType>> Children;
 
    TWeakPtr<SelfType> Parent;
 
    FText DisplayText;
 
    bool bIsVisible = true;
};