EdGraphSchema.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/Object.h"
#include "EdGraph/EdGraphNode.h"
#include "EdGraph/EdGraphPin.h"
#include "AssetRegistry/AssetData.h"
#include "UObject/ObjectKey.h"
#include "Input/Reply.h"
#if WITH_EDITOR
#include "Kismet2/Kismet2NameValidators.h"
#endif
#include "EdGraphSchema.generated.h"
 
class FSlateRect;
struct FSlateBrush;
class UEdGraph;
struct FBPVariableDescription;
 
UENUM()
enum EGraphType : int
{
    GT_Function,
    GT_Ubergraph,
    GT_Macro,
    GT_Animation,
    GT_StateMachine,
    GT_MAX,
};
 
UENUM()
enum ECanCreateConnectionResponse : int
{
    CONNECT_RESPONSE_MAKE,
 
    CONNECT_RESPONSE_DISALLOW,
 
    CONNECT_RESPONSE_BREAK_OTHERS_A,
 
    CONNECT_RESPONSE_BREAK_OTHERS_B,
 
    CONNECT_RESPONSE_BREAK_OTHERS_AB,
 
    CONNECT_RESPONSE_MAKE_WITH_CONVERSION_NODE,
 
    CONNECT_RESPONSE_MAKE_WITH_PROMOTION,
 
    CONNECT_RESPONSE_MAX,
};
 
// Used to opaquely verify that two different persistent entries backing actions are part of the same section/category (e.g., both are variables in the same Blueprint)
struct FEdGraphSchemaActionDefiningObject
{
    FEdGraphSchemaActionDefiningObject(UObject* InObject, void* AdditionalPointer = nullptr, FName AdditionalName = NAME_None)
        : DefiningObject(InObject)
        , DefiningPointer(AdditionalPointer)
        , DefiningName(AdditionalName)
        , bIsEditable((InObject != nullptr) ? !InObject->IsNative() : false)
    {
    }
 
    friend bool operator==(const FEdGraphSchemaActionDefiningObject& A, const FEdGraphSchemaActionDefiningObject& B)
    {
        return (A.DefiningObject == B.DefiningObject) && (A.DefiningPointer == B.DefiningPointer) && (A.DefiningName == B.DefiningName) && (A.bIsEditable == B.bIsEditable);
    }
 
    friend bool operator!=(const FEdGraphSchemaActionDefiningObject& A, const FEdGraphSchemaActionDefiningObject& B)
    {
        return !(A == B);
    }
 
    bool IsPotentiallyEditable() const
    {
        return bIsEditable;
    }
private:
    FObjectKey DefiningObject;
    void* DefiningPointer;
    FName DefiningName;
    bool bIsEditable;
};
 
USTRUCT()
struct FEdGraphSchemaAction
{
    GENERATED_USTRUCT_BODY()
 
    
    static FName StaticGetTypeId() {static FName Type("FEdGraphSchemaAction"); return Type;}
    virtual FName GetTypeId() const { return StaticGetTypeId(); }
 
private:
    UPROPERTY()
    FText MenuDescription;
 
    UPROPERTY()
    FText TooltipDescription;
 
    UPROPERTY()
    FText Category;
 
    UPROPERTY()
    FText Keywords;
    
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<FString> CategoryChain;
#endif
public:
    UPROPERTY()
    int32 Grouping;
 
    UPROPERTY()
    int32 SectionID;
 
    UPROPERTY()
    TArray<FString> MenuDescriptionArray;
 
    UPROPERTY()
    TArray<FString> FullSearchTitlesArray;
 
    UPROPERTY()
    TArray<FString>  FullSearchKeywordsArray;
 
    UPROPERTY()
    TArray<FString>  FullSearchCategoryArray;
 
    UPROPERTY()
    TArray<FString> LocalizedMenuDescriptionArray;
 
    UPROPERTY()
    TArray<FString> LocalizedFullSearchTitlesArray;
 
    UPROPERTY()
    TArray<FString>  LocalizedFullSearchKeywordsArray;
 
    UPROPERTY()
    TArray<FString>  LocalizedFullSearchCategoryArray;
 
    UPROPERTY()
    FString SearchText;
    FEdGraphSchemaAction() 
        : Grouping(0)
        , SectionID(0)
    {}
    
    virtual ~FEdGraphSchemaAction() {}
 
    FEdGraphSchemaAction(FText InNodeCategory, FText InMenuDesc, FText InToolTip, const int32 InGrouping, FText InKeywords = FText(), int32 InSectionID = 0)
        : Grouping(InGrouping)
        , SectionID(InSectionID)
    {
        UpdateSearchData(MoveTemp(InMenuDesc), MoveTemp(InToolTip), MoveTemp(InNodeCategory), MoveTemp(InKeywords));
    }
 
    virtual bool IsParentable() const { return false; }
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual UEdGraphNode* PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2D Location, bool bSelectNewNode = true) UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION
    {
        return nullptr;
    }
    virtual UEdGraphNode* PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2f& Location, bool bSelectNewNode = true)
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return PerformAction(ParentGraph, FromPin, FVector2D(Location), bSelectNewNode);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual UEdGraphNode* PerformAction(class UEdGraph* ParentGraph, TArray<UEdGraphPin*>& FromPins, const FVector2D Location, bool bSelectNewNode = true) UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION
    {
        UEdGraphNode* NewNode = nullptr;
        if (FromPins.Num() > 0)
        {
            NewNode = PerformAction(ParentGraph, FromPins[0], UE::Slate::CastToVector2f(Location), bSelectNewNode);
        }
        else
        {
            NewNode = PerformAction(ParentGraph, nullptr, UE::Slate::CastToVector2f(Location), bSelectNewNode);
        }
 
        return NewNode;
    }
    virtual UEdGraphNode* PerformAction(class UEdGraph* ParentGraph, TArray<UEdGraphPin*>& FromPins, const FVector2f& Location, bool bSelectNewNode = true)
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return PerformAction(ParentGraph, FromPins, FVector2D(Location), bSelectNewNode);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    ENGINE_API virtual FReply OnDoubleClick(UBlueprint* InBlueprint);
 
    // Updates the category of the *action* and refreshes the search text; does not change the persistent backing item
    // (e.g., it will not actually move a user added variable or function to a new category)
    ENGINE_API void CosmeticUpdateCategory(FText NewCategory);
 
#if WITH_EDITOR
    ENGINE_API void CosmeticUpdateRootCategory(FText NewRootCategory);
#endif
 
    ENGINE_API void UpdateSearchData(FText NewMenuDescription, FText NewToolTipDescription, FText NewCategory, FText NewKeywords);
 
    int32 GetSectionID() const
    {
        return SectionID;
    }
 
    int32 GetGrouping() const 
    {
        return Grouping;
    }
 
    const FText& GetMenuDescription() const
    {
        return MenuDescription;
    }
 
    const FText& GetTooltipDescription() const
    {
        return TooltipDescription;
    }
 
    const FText& GetCategory() const
    {
        return Category;
    }
 
    const FText& GetKeywords() const
    {
        return Keywords;
    }
 
    const TArray<FString>& GetMenuDescriptionArray() const
    {
        return MenuDescriptionArray;
    }
 
    const TArray<FString>& GetSearchTitleArray() const
    {
        return FullSearchTitlesArray;
    }
 
    const TArray<FString>& GetSearchKeywordsArray() const
    {
        return FullSearchKeywordsArray;
    }
 
    const TArray<FString>& GetSearchCategoryArray() const
    {
        return FullSearchCategoryArray;
    }
 
    const TArray<FString>& GetLocalizedMenuDescriptionArray() const
    {
        return LocalizedMenuDescriptionArray;
    }
 
    const TArray<FString>& GetLocalizedSearchTitleArray() const
    {
        return LocalizedFullSearchTitlesArray;
    }
 
    const TArray<FString>& GetLocalizedSearchKeywordsArray() const
    {
        return LocalizedFullSearchKeywordsArray;
    }
 
    const TArray<FString>& GetLocalizedSearchCategoryArray() const
    {
        return LocalizedFullSearchCategoryArray;
    }
 
    const FString& GetFullSearchText() const
    {
        return SearchText;
    }
 
    // GC.
    virtual void AddReferencedObjects(FReferenceCollector& Collector) {}
 
    // Moves the item backing this action to the specified category if it is possible (does nothing for native-introduced variables/functions/etc...)
    virtual void MovePersistentItemToCategory(const FText& NewCategoryName) {}
 
    // Returns the ordering index of this action in the parent container (if the item cannot be reordered then this will return INDEX_NONE)
    virtual int32 GetReorderIndexInContainer() const { return INDEX_NONE; }
 
    // Reorders this action to be before the other item in the parent container (returns false if they are not in the same container or cannot be reordered)
    virtual bool ReorderToBeforeAction(TSharedRef<FEdGraphSchemaAction> OtherAction) { return false; }
 
    // Returns an opaque handle that can be used to confirm that two different persistent entries backing actions are part of the same section/category
    // (e.g., both are variables in the same Blueprint)
    virtual FEdGraphSchemaActionDefiningObject GetPersistentItemDefiningObject() const { return FEdGraphSchemaActionDefiningObject(nullptr); }
 
    // Returns true if the action is of the given type.
    virtual bool IsA(const FName& InType) const
    {
        return InType == GetTypeId();
    }
 
    // Returns true if the action refers to a member or local variable
    virtual bool IsAVariable() const { return false; }
 
    // Returns true if the action can be renamed
    virtual bool CanBeRenamed() const { return true; }
 
    // Returns true if the action can be deleted
    virtual bool CanBeDeleted() const { return false; }
 
    // Can be used to override the icon of the action in the palette
    virtual FSlateBrush const* GetPaletteIcon() const { return nullptr; }
 
    // Can be used to override the tooltip shown in the palette
    virtual FText GetPaletteToolTip() const { return FText(); }
 
#if WITH_EDITOR
    // returns the full list of categories, after any pipe (|) separators have been parsed
    ENGINE_API const TArray<FString>& GetCategoryChain() const;
#endif
private:
    ENGINE_API void UpdateSearchText();
};
 
USTRUCT()
struct FEdGraphSchemaAction_NewNode : public FEdGraphSchemaAction
{
    GENERATED_USTRUCT_BODY()
 
    // Simple type info
    static FName StaticGetTypeId() {static FName Type("FEdGraphSchemaAction_NewNode"); return Type;}
    virtual FName GetTypeId() const override { return StaticGetTypeId(); } 
 
    UPROPERTY()
    TObjectPtr<class UEdGraphNode> NodeTemplate;
 
 
    FEdGraphSchemaAction_NewNode() 
        : FEdGraphSchemaAction()
        , NodeTemplate(nullptr)
    {}
 
    FEdGraphSchemaAction_NewNode(FText InNodeCategory, FText InMenuDesc, FText InToolTip, const int32 InGrouping)
        : FEdGraphSchemaAction(MoveTemp(InNodeCategory), MoveTemp(InMenuDesc), MoveTemp(InToolTip), InGrouping)
        , NodeTemplate(nullptr)
    {}
 
    // FEdGraphSchemaAction interface
    ENGINE_API virtual UEdGraphNode* PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2f& Location, bool bSelectNewNode = true) override;
    ENGINE_API virtual UEdGraphNode* PerformAction(class UEdGraph* ParentGraph, TArray<UEdGraphPin*>& FromPins, const FVector2f& Location, bool bSelectNewNode = true) override;
    ENGINE_API virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    // End of FEdGraphSchemaAction interface
 
    template <typename NodeType>
    static NodeType* SpawnNodeFromTemplate(class UEdGraph* ParentGraph, NodeType* InTemplateNode, const UE::Slate::FDeprecateVector2DParameter& Location, bool bSelectNewNode = true)
    {
        FEdGraphSchemaAction_NewNode Action;
        Action.NodeTemplate = InTemplateNode;
 
        return Cast<NodeType>(Action.PerformAction(ParentGraph, nullptr, Location, bSelectNewNode));
    }
 
    static ENGINE_API UEdGraphNode* CreateNode(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const UE::Slate::FDeprecateVector2DParameter& Location, class UEdGraphNode* InNodeTemplate);
};
 
struct FEdGraphSchemaAction_Dummy : public FEdGraphSchemaAction
{
    static FName StaticGetTypeId() { static FName Type("FEdGraphSchemaAction_Dummy"); return Type; }
    virtual FName GetTypeId() const override { return StaticGetTypeId(); }
 
    FEdGraphSchemaAction_Dummy()
    : FEdGraphSchemaAction()
    {}
 
    FEdGraphSchemaAction_Dummy(FText InNodeCategory, FText InMenuDesc, FText InToolTip, const int32 InGrouping)
        : FEdGraphSchemaAction(MoveTemp(InNodeCategory), MoveTemp(InMenuDesc), MoveTemp(InToolTip), InGrouping)
    {}
};
 
struct FPinConnectionResponse
{
public:
    FText Message;
 
    TEnumAsByte<enum ECanCreateConnectionResponse> Response;
 
public:
    FPinConnectionResponse()
        : Message(FText::GetEmpty())
        , Response(CONNECT_RESPONSE_MAKE)
        , bIsFatal(false)
    {
    }
 
    FPinConnectionResponse(const ECanCreateConnectionResponse InResponse, FString InMessage)
        : Message(FText::FromString(MoveTemp(InMessage)))
        , Response(InResponse)
        , bIsFatal(false)
    {
    }
 
    FPinConnectionResponse(const ECanCreateConnectionResponse InResponse, const ANSICHAR* InMessage)
        : Message(FText::FromString(InMessage))
        , Response(InResponse)
        , bIsFatal(false)
    {
    }
 
    FPinConnectionResponse(const ECanCreateConnectionResponse InResponse, const WIDECHAR* InMessage)
        : Message(FText::FromString(InMessage))
        , Response(InResponse)
        , bIsFatal(false)
    {
    }
 
    FPinConnectionResponse(const ECanCreateConnectionResponse InResponse, FText InMessage)
        : Message(MoveTemp(InMessage))
        , Response(InResponse)
        , bIsFatal(false)
    {
    }
 
    friend bool operator==(const FPinConnectionResponse& A, const FPinConnectionResponse& B)
    {
        return (A.Message.ToString() == B.Message.ToString()) && (A.Response == B.Response) && (A.bIsFatal == B.bIsFatal);
    }   
 
    bool CanSafeConnect() const
    {
        return (Response == CONNECT_RESPONSE_MAKE  || Response == CONNECT_RESPONSE_MAKE_WITH_PROMOTION);
    }
 
    bool IsFatal() const
    {
        return (Response == CONNECT_RESPONSE_DISALLOW) && bIsFatal;
    }
 
    void SetFatal()
    {
        Response = CONNECT_RESPONSE_DISALLOW;
        bIsFatal = true;
    }
 
private:
    bool bIsFatal:1;
};
 
 
// This object is a base class helper used when building a list of actions for some menu or palette
struct FGraphActionListBuilderBase
{
public:
    class UE_DEPRECATED(5.5, "ActionGroup has been deprecated - operate only on TSharedPtr<FEdGraphSchemaAction> or const FEdGraphSchemaAction& as appropriate") 
    ActionGroup
    {
    public:
        ENGINE_API ActionGroup( TSharedPtr<FEdGraphSchemaAction> InAction, FString RootCategory = FString());
 
        ENGINE_API ActionGroup( const TArray< TSharedPtr<FEdGraphSchemaAction> >& InActions, FString RootCategory = FString());
 
        ENGINE_API ActionGroup(ActionGroup && Other);
        ENGINE_API ActionGroup& operator=(ActionGroup && Other);
 
        ENGINE_API ActionGroup(const ActionGroup&);
        ENGINE_API ActionGroup& operator=(const ActionGroup&);
 
        ENGINE_API ~ActionGroup();
         ENGINE_API const TArray<FString>& GetCategoryChain() const;
 
        ENGINE_API void PerformAction( class UEdGraph* ParentGraph, TArray<UEdGraphPin*>& FromPins, const UE::Slate::FDeprecateVector2DParameter& Location );
        
        const FString& GetSearchTextForFirstAction() const { return Actions[0]->GetFullSearchText(); }
 
        const TArray<FString>& GetSearchKeywordsArrayForFirstAction() const { return Actions[0]->GetSearchKeywordsArray(); }
        const TArray<FString>& GetMenuDescriptionArrayForFirstAction() const { return Actions[0]->GetMenuDescriptionArray(); }
        const TArray<FString>& GetSearchTitleArrayForFirstAction() const { return Actions[0]->GetSearchTitleArray(); }
        const TArray<FString>& GetSearchCategoryArrayForFirstAction() const { return Actions[0]->GetSearchCategoryArray(); }
 
        const TArray<FString>& GetLocalizedSearchKeywordsArrayForFirstAction() const { return Actions[0]->GetLocalizedSearchKeywordsArray(); }
        const TArray<FString>& GetLocalizedMenuDescriptionArrayForFirstAction() const { return Actions[0]->GetLocalizedMenuDescriptionArray(); }
        const TArray<FString>& GetLocalizedSearchTitleArrayForFirstAction() const { return Actions[0]->GetLocalizedSearchTitleArray(); }
        const TArray<FString>& GetLocalizedSearchCategoryArrayForFirstAction() const { return Actions[0]->GetLocalizedSearchCategoryArray(); }
 
        TArray< TSharedPtr<FEdGraphSchemaAction> > Actions;
 
    private:
        void Move(ActionGroup& Other);
        void Copy(const ActionGroup& Other);
 
        void InitCategoryChain();
 
        void InitSearchText();
 
        FString RootCategory;
        TArray<FString> CategoryChain;
    };
private:
 
    TArray< TSharedPtr<FEdGraphSchemaAction> > Entries;
 
public:
 
    virtual ~FGraphActionListBuilderBase() { }
 
    ENGINE_API virtual void AddAction( const TSharedPtr<FEdGraphSchemaAction>& NewAction);
    UE_DEPRECATED(5.5, "Overriding the schema action category is no longer supported, set the category via CosmeticUpdateRootCategory or CosmeticUpdateCategory")
    ENGINE_API virtual void AddAction(const TSharedPtr<FEdGraphSchemaAction>& NewAction, FString const& Category);
 
    UE_DEPRECATED(5.5, "Collections of Action lists were ambiguous and unused - make a compound FEdGraphSchemaAction and Add it")
    ENGINE_API virtual void AddActionList( const TArray<TSharedPtr<FEdGraphSchemaAction> >& NewActions, FString const& Category = FString() );
 
    ENGINE_API void Append( FGraphActionListBuilderBase& Other );
 
    ENGINE_API int32 GetNumActions() const;
 
    ENGINE_API TSharedPtr<FEdGraphSchemaAction>& GetSchemaAction(int32 Index);
 
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.5, "FGraphActionListBuilderBase::ActionGroup has been deprecated, access TSharedPtr<FEdGraphSchemaAction> directly using GetSchemaAction")
    ENGINE_API ActionGroup GetAction(int32 Index);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API virtual void Empty();
 
    // The temporary graph outer to store any template nodes created
    UEdGraph* OwnerOfTemporaries;
 
public:
    template<typename NodeType>
    NodeType* CreateTemplateNode(UClass* Class=NodeType::StaticClass())
    {
        return NewObject<NodeType>(OwnerOfTemporaries, Class);
    }
 
    FGraphActionListBuilderBase()
        : OwnerOfTemporaries(nullptr)
    {
    }
};
 
struct FCategorizedGraphActionListBuilder : public FGraphActionListBuilderBase
{
public:
    ENGINE_API FCategorizedGraphActionListBuilder(FString Category = FString());
 
    // FGraphActionListBuilderBase Interface
    ENGINE_API virtual void AddAction(const TSharedPtr<FEdGraphSchemaAction>& NewAction) override;
    UE_DEPRECATED(5.5, "Overriding the schema action category is no longer supported, specify category via FCategorizedGraphActionListBuilder constructor, or on the FEdGraphSchemaAction")
    ENGINE_API virtual void AddAction(const TSharedPtr<FEdGraphSchemaAction>& NewAction, FString const& Category) override;
    UE_DEPRECATED(5.5, "Collections of Action lists were ambiguous and unused - make a compound FEdGraphSchemaAction and Add it")
    ENGINE_API virtual void AddActionList(const TArray<TSharedPtr<FEdGraphSchemaAction> >& NewActions, FString const& Category = FString()) override;
    // End of FGraphActionListBuilderBase Interface
 
private:
    FString Category;
};
 
// This context is used when building a list of actions that can be done in the current blueprint
struct FGraphActionMenuBuilder : public FGraphActionListBuilderBase
{
public:
    const UEdGraphPin* FromPin;
public:
    FGraphActionMenuBuilder() : FromPin(nullptr) {}
};
 
// This context is used when building a list of actions that can be done in the current context
struct FGraphContextMenuBuilder : public FGraphActionMenuBuilder
{
public:
    // The current graph (will never be NULL)
    const UEdGraph* CurrentGraph;
 
    // The selected objects
    TArray<UObject*> SelectedObjects;
public:
    ENGINE_API FGraphContextMenuBuilder(const UEdGraph* InGraph);
};
 
struct FGraphDisplayInfo
{
public:
    FText PlainName;
    FText DisplayName;
    FText Tooltip;
    FString DocLink;
    FString DocExcerptName;
 
    TArray<FString> Notes;
public:
    FGraphDisplayInfo() 
    {}
 
    ENGINE_API FString GetNotesAsString() const;
};
 
#if WITH_EDITORONLY_DATA
struct FGraphSchemaSearchWeightModifiers
{
    float NodeTitleWeight = 0.0f;
    float KeywordWeight = 0.0f;
    float DescriptionWeight = 0.0f;
    float CategoryWeight = 0.0f;
    float WholeMatchLocalizedWeightMultiplier = 0.0f;
    float WholeMatchWeightMultiplier = 0.0f;
    float StartsWithBonusWeightMultiplier = 0.0f;
    float PercentageMatchWeightMultiplier = 0.0f;
    float ShorterMatchWeight = 0.0f;
};
 
// Helper struct storing the search text array with its weight info
struct FGraphSchemaSearchTextWeightInfo
{
    FGraphSchemaSearchTextWeightInfo(const TArray< FString >* InArray, float InWeightModifier, float* OutDebugWeight)
        : Array(InArray), WeightModifier(InWeightModifier), DebugWeight(OutDebugWeight)
    {}
 
    const TArray< FString >* Array = nullptr;
    float WeightModifier = 0.0f;
    float* DebugWeight = nullptr;
};
 
// Helper struct storing the breakdown of the weights assigned to the search text
struct FGraphSchemaSearchTextDebugInfo
{
    virtual ~FGraphSchemaSearchTextDebugInfo() = default;
    
    float TotalWeight = 0.0f;           // Overall weight
 
    float NodeTitleWeight = 0.0f;       // Weight for the node's title
    float KeywordWeight = 0.0f;         // Weight for the node's keywords
    float DescriptionWeight = 0.0f;     // Weight for the node's description
    float CategoryWeight = 0.0f;        // Weight for the category
 
    float PercentMatch = 0.0f;          // The calculated whole match percentage
    float PercentMatchWeight = 0.0f;    // Weight for the whole match percentage
    float ShorterMatchWeight = 0.0f;    // Weight for the shorter matched words
 
    ENGINE_API virtual void Print(const TArray<FString>& SearchForKeywords, const FEdGraphSchemaAction& Action) const;
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.5, "FGraphActionListBuilderBase::ActionGroup weight calculation was always performed on the first action, provide that if scoring a FGraphActionListBuilderBase::ActionGroup, or just provide the FEdGraphSchemaAction")
    ENGINE_API virtual void Print(const TArray<FString>& SearchForKeywords, const FGraphActionListBuilderBase::ActionGroup& Action) const;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
};
#endif // WITH_EDITORONLY_DATA
 
UCLASS(abstract, MinimalAPI)
class UEdGraphSchema : public UObject
{
    GENERATED_UCLASS_BODY()
 
 
    
     ENGINE_API virtual void GetGraphContextActions(FGraphContextMenuBuilder& ContextMenuBuilder) const;
 
    ENGINE_API FName GetContextMenuName() const;
 
    ENGINE_API virtual FName GetParentContextMenuName() const;
 
    static ENGINE_API FName GetContextMenuName(UClass* InClass);
 
    ENGINE_API virtual void GetContextMenuActions(class UToolMenu* Menu, class UGraphNodeContextMenuContext* Context) const;
    
    virtual const FPinConnectionResponse CanCreateConnection(const UEdGraphPin* A, const UEdGraphPin* B) const
    {
        return FPinConnectionResponse(CONNECT_RESPONSE_DISALLOW, TEXT("Not implemented by this schema"));
    }
 
    virtual const FPinConnectionResponse CanMergeNodes(const UEdGraphNode* A, const UEdGraphNode* B) const 
    {
        return FPinConnectionResponse(CONNECT_RESPONSE_DISALLOW, TEXT("Not implemented by this schema"));
    }
 
 
    // Categorizes two pins into an input pin and an output pin.  Returns true if successful or false if they don't make sense as such (two inputs or two outputs)
    template<typename PinType>
    static bool CategorizePinsByDirection(PinType* PinA, PinType* PinB, /*out*/ PinType*& InputPin, /*out*/ PinType*& OutputPin)
    {
        InputPin = nullptr;
        OutputPin = nullptr;
 
        bool bResult = false;
        if (ensure(PinA && PinB))
        {
            if ((PinA->Direction == EGPD_Input) && (PinB->Direction == EGPD_Output))
            {
                InputPin = PinA;
                OutputPin = PinB;
                bResult = true;
            }
            else if ((PinB->Direction == EGPD_Input) && (PinA->Direction == EGPD_Output))
            {
                InputPin = PinB;
                OutputPin = PinA;
                bResult = true;
            }
        }
        return bResult;
    }
 
    ENGINE_API virtual bool TryCreateConnection(UEdGraphPin* A, UEdGraphPin* B) const;
 
    ENGINE_API virtual bool IsConnectionRelinkingAllowed(UEdGraphPin* InPin) const;
 
    ENGINE_API virtual const FPinConnectionResponse CanRelinkConnectionToPin(const UEdGraphPin* OldSourcePin, const UEdGraphPin* TargetPinCandidate) const;
 
    ENGINE_API virtual bool TryRelinkConnectionTarget(UEdGraphPin* SourcePin, UEdGraphPin* OldTargetPin, UEdGraphPin* NewTargetPin, const TArray<UEdGraphNode*>& InSelectedGraphNodes) const;
 
    ENGINE_API virtual bool CreateAutomaticConversionNodeAndConnections(UEdGraphPin* A, UEdGraphPin* B) const;
 
    ENGINE_API virtual bool CreatePromotedConnection(UEdGraphPin* A, UEdGraphPin* B) const;
    
#if WITH_EDITORONLY_DATA
    ENGINE_API bool ShouldShowPanelContextMenuForIncompatibleConnections() const;
#endif
 
    virtual FString IsPinDefaultValid(const UEdGraphPin* Pin, const FString& NewDefaultValue, TObjectPtr<UObject> NewDefaultObject, const FText& InNewDefaultText) const  { return TEXT("Not implemented by this schema"); }
 
    ENGINE_API FString IsCurrentPinDefaultValid(const UEdGraphPin* Pin) const;
 
    virtual bool DoesSupportPinWatching() const { return false; }
 
    virtual bool IsPinBeingWatched(UEdGraphPin const* Pin) const { return false; }
 
    virtual void ClearPinWatch(UEdGraphPin const* Pin) const {}
 
    virtual bool CanShowDataTooltipForPin(const UEdGraphPin& Pin) const { return false; }
 
    ENGINE_API virtual void TrySetDefaultValue(UEdGraphPin& Pin, const FString& NewDefaultValue, bool bMarkAsModified = true) const;
 
    ENGINE_API virtual void TrySetDefaultObject(UEdGraphPin& Pin, UObject* NewDefaultObject, bool bMarkAsModified = true) const;
 
    ENGINE_API virtual void TrySetDefaultText(UEdGraphPin& InPin, const FText& InNewDefaultText, bool bMarkAsModified = true) const;
 
    ENGINE_API virtual bool DoesDefaultValueMatch(const UEdGraphPin& InPin, const FString& InValue) const;
 
    ENGINE_API virtual bool DoesDefaultValueMatchAutogenerated(const UEdGraphPin& InPin) const;
 
    virtual void ResetPinToAutogeneratedDefaultValue(UEdGraphPin* Pin, bool bCallModifyCallbacks = true) const { }
 
    virtual bool ShouldHidePinDefaultValue(UEdGraphPin* Pin) const { return false; }
 
    virtual bool ShouldShowAssetPickerForPin(UEdGraphPin* Pin) const { return true; }
 
    virtual bool SupportsPinType(TWeakPtr<const FEdGraphSchemaAction> SchemaAction, const FEdGraphPinType& PinType) const { return true; }
 
    virtual bool SupportsPinTypeContainer(TWeakPtr<const FEdGraphSchemaAction> SchemaAction, const FEdGraphPinType& PinType, const EPinContainerType& ContainerType) const { return true; }
 
    virtual FLinearColor GetPinTypeColor(const FEdGraphPinType& PinType) const { return FLinearColor::Black; }
 
    virtual FLinearColor GetPinColor(const UEdGraphPin* InPin) const { return InPin ? GetPinTypeColor(InPin->PinType) : FLinearColor::Black; }
 
    virtual FLinearColor GetSecondaryPinTypeColor(const FEdGraphPinType& PinType) const { return FLinearColor::White; };
 
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual FText GetPinDisplayName(const UEdGraphPin* Pin) const;
 
    ENGINE_API virtual float GetActionFilteredWeight(const FEdGraphSchemaAction& InCurrentAction, const TArray<FString>& InFilterTerms, const TArray<FString>& InSanitizedFilterTerms, const TArray<UEdGraphPin*>& DraggedFromPins) const;
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.5, "FGraphActionListBuilderBase::ActionGroup weight calculation was always performed on the first action, provide that if scoring a FGraphActionListBuilderBase::ActionGroup, or just provide the FEdGraphSchemaAction")
    ENGINE_API virtual float GetActionFilteredWeight(const FGraphActionListBuilderBase::ActionGroup& InCurrentAction, const TArray<FString>& InFilterTerms, const TArray<FString>& InSanitizedFilterTerms, const TArray<UEdGraphPin*>& DraggedFromPins) const;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API virtual FGraphSchemaSearchWeightModifiers GetSearchWeightModifiers() const;
#endif // WITH_EDITORONLY_DATA
 
    ENGINE_API virtual void ConstructBasicPinTooltip(UEdGraphPin const& Pin, FText const& PinDescription, FString& TooltipOut) const;
 
    //@TODO: This is too K2-specific to be included in EdGraphSchema and should be refactored
    virtual EGraphType GetGraphType(const UEdGraph* TestEdGraph) const { return GT_Function; }
 
    virtual bool IsTitleBarPin(const UEdGraphPin& Pin) const { return false; }
 
    ENGINE_API virtual void BreakNodeLinks(UEdGraphNode& TargetNode) const;
 
    static ENGINE_API bool SetNodeMetaData(UEdGraphNode* Node, FName const& KeyValue);
 
    ENGINE_API virtual void BreakPinLinks(UEdGraphPin& TargetPin, bool bSendsNodeNotifcation) const;
 
    ENGINE_API virtual void BreakSinglePinLink(UEdGraphPin* SourcePin, UEdGraphPin* TargetPin) const;
 
    virtual void SplitPin(UEdGraphPin* Pin, bool bNotify = true) const { };
 
    virtual void RecombinePin(UEdGraphPin* Pin) const { };
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual void OnPinConnectionDoubleCicked(UEdGraphPin* PinA, UEdGraphPin* PinB, const FVector2D& GraphPosition) const UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION { }
    virtual void OnPinConnectionDoubleCicked(UEdGraphPin* PinA, UEdGraphPin* PinB, const FVector2f& GraphPosition) const
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return OnPinConnectionDoubleCicked(PinA, PinB, FVector2D(GraphPosition));
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    ENGINE_API virtual FPinConnectionResponse MovePinLinks(UEdGraphPin& MoveFromPin, UEdGraphPin& MoveToPin, bool bIsIntermediateMove = false, bool bNotifyLinkedNodes = false) const;
     
    ENGINE_API virtual FPinConnectionResponse CopyPinLinks(UEdGraphPin& CopyFromPin, UEdGraphPin& CopyToPin, bool bIsIntermediateCopy = false) const;
 
    virtual bool IsSelfPin(const UEdGraphPin& Pin) const   {return false;}
 
    virtual bool IsDelegateCategory(const FName Category) const   {return false;}
 
    virtual void CreateDefaultNodesForGraph(UEdGraph& Graph) const {}
 
    ENGINE_API virtual void ReconstructNode(UEdGraphNode& TargetNode, bool bIsBatchRequest=false) const;
 
    virtual UEdGraphNode* CreateSubstituteNode(UEdGraphNode* Node, const UEdGraph* Graph, FObjectInstancingGraph* InstanceGraph, TSet<FName>& InOutExtraNames) const { return nullptr; }
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    ENGINE_API virtual void SetNodePosition(UEdGraphNode* Node, const FVector2D& Position) const UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION;
    ENGINE_API virtual void SetNodePosition(UEdGraphNode* Node, const FVector2f& Position) const;
 
    virtual int32 GetNodeSelectionCount(const UEdGraph* Graph) const { return 0; }
 
    virtual TSharedPtr<FEdGraphSchemaAction> GetCreateCommentAction() const { return nullptr; }
 
    virtual void HandleGraphBeingDeleted(UEdGraph& GraphBeingRemoved) const {}
 
    /*
     * Try to delete the graph through the schema, return true if successful
     */
    virtual bool TryDeleteGraph(UEdGraph* GraphToDelete) const { return false; }
 
    /*
     * Try to rename a graph through the schema, return true if successful
     */
    virtual bool TryRenameGraph(UEdGraph* GraphToRename, const FName& InNewName) const { return false; }
 
    /*
     * Try to retrieve the event child actions for a given graph
     */
    virtual bool TryToGetChildEvents(const UEdGraph* Graph, const int32 SectionId, TArray<TSharedPtr<FEdGraphSchemaAction>>& Actions, const FText& ParentCategory) const { return false; }
 
    virtual bool CanEncapuslateNode(UEdGraphNode const& TestNode) const { return true; }
 
    /*
     * Can the function graph be dropped into another graph
     */
    virtual bool CanGraphBeDropped(TSharedPtr<FEdGraphSchemaAction> InAction) const { return false; }
 
    /*
     * Returns a custom reference string for searching within the blueprint based on a given action
     */
    virtual FString GetFindReferenceSearchTerm(const FEdGraphSchemaAction* InGraphAction) const { return FString(); }
 
    /*
     * Begins a drag and drop action to drag a graph action into another graph
     */
    UE_DEPRECATED(5.0, "Use version that takes FPointerEvent instead.")
    ENGINE_API virtual FReply BeginGraphDragAction(TSharedPtr<FEdGraphSchemaAction> InAction) const;
 
    /*
    * Begins a drag and drop action to drag a graph action into another graph
    */
    ENGINE_API virtual FReply BeginGraphDragAction(TSharedPtr<FEdGraphSchemaAction> InAction, const FPointerEvent& MouseEvent) const;
 
    ENGINE_API virtual void GetGraphDisplayInformation(const UEdGraph& Graph, /*out*/ FGraphDisplayInfo& DisplayInfo) const;
 
    virtual FText GetGraphCategory(const UEdGraph* InGraph) const { return FText(); }
 
    ENGINE_API virtual FReply TrySetGraphCategory(const UEdGraph* InGraph, const FText& InCategory) const;
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual void DroppedAssetsOnGraph(const TArray<struct FAssetData>& Assets, const FVector2D& GraphPosition, UEdGraph* Graph) const UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION {}
    virtual void DroppedAssetsOnGraph(const TArray<struct FAssetData>& Assets, const FVector2f& GraphPosition, UEdGraph* Graph) const
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return DroppedAssetsOnGraph(Assets, FVector2D(GraphPosition), Graph);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual void DroppedAssetsOnNode(const TArray<struct FAssetData>& Assets, const FVector2D& GraphPosition, UEdGraphNode* Node) const UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION {}
    virtual void DroppedAssetsOnNode(const TArray<struct FAssetData>& Assets, const FVector2f& GraphPosition, UEdGraphNode* Node) const
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return DroppedAssetsOnNode(Assets, FVector2D(GraphPosition), Node);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual void DroppedAssetsOnPin(const TArray<struct FAssetData>& Assets, const FVector2D& GraphPosition, UEdGraphPin* Pin) const UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION {}
    virtual void DroppedAssetsOnPin(const TArray<struct FAssetData>& Assets, const FVector2f& GraphPosition, UEdGraphPin* Pin) const
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return DroppedAssetsOnPin(Assets, FVector2D(GraphPosition), Pin);
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    virtual void GetAssetsNodeHoverMessage(const TArray<struct FAssetData>& Assets, const UEdGraphNode* HoverNode, FString& OutTooltipText, bool& OutOkIcon) const 
    { 
        OutTooltipText = FString();
        OutOkIcon = false;
    }
 
    virtual void GetAssetsPinHoverMessage(const TArray<struct FAssetData>& Assets, const UEdGraphPin* HoverPin, FString& OutTooltipText, bool& OutOkIcon) const 
    { 
        OutTooltipText = FString();
        OutOkIcon = false;
    }
 
    virtual void GetAssetsGraphHoverMessage(const TArray<FAssetData>& Assets, const UEdGraph* HoverGraph, FString& OutTooltipText, bool& OutOkIcon) const
    {
        OutTooltipText = FString();
        OutOkIcon = false;
    }
 
    /* Can this graph type be duplicated? */
    virtual bool CanDuplicateGraph(UEdGraph* InSourceGraph) const { return true; }
 
    /* Duplicate a given graph return the duplicate graph */
    virtual UEdGraph* DuplicateGraph(UEdGraph* GraphToDuplicate) const { return nullptr;}
 
    /* Indicates whether variants of functions are allowed */
    virtual bool AllowsFunctionVariants() const { return false; }
 
    /* returns new FConnectionDrawingPolicy from this schema */
    virtual class FConnectionDrawingPolicy* CreateConnectionDrawingPolicy(int32 InBackLayerID, int32 InFrontLayerID, float InZoomFactor, const FSlateRect& InClippingRect, class FSlateWindowElementList& InDrawElements, class UEdGraph* InGraphObj) const { return nullptr; }
 
    /* When dragging off a pin, we want to duck the alpha of some nodes */
    virtual bool FadeNodeWhenDraggingOffPin(const UEdGraphNode* Node, const UEdGraphPin* Pin) const { return false; }
 
    virtual void BackwardCompatibilityNodeConversion(UEdGraph* Graph, bool bOnlySafeChanges) const { }
 
    /* When a node is removed, this method determines whether we should remove it immediately or use the old (slower) code path that results in all node being recreated: */
    virtual bool ShouldAlwaysPurgeOnModification() const { return true; }
 
    virtual bool SafeDeleteNodeFromGraph(UEdGraph* Graph, UEdGraphNode* Node) const { return false; }
 
    /*
     * Some schemas have nodes that support the user dynamically adding pins when dropping a connection on the node
     *
     * @param InTargetNode                  Node to check for pin adding support
     * @param InSourcePinName               Name of the pin being dropped, a new pin of similar name will be constructed
     * @param InSourcePinType               Type of pin to drop onto the node
     * @param InSourcePinDirection          Direction of the source pin
     * @return                              Returns the new pin if created
     */
    virtual UEdGraphPin* DropPinOnNode(UEdGraphNode* InTargetNode, const FName& InSourcePinName, const FEdGraphPinType& InSourcePinType, EEdGraphPinDirection InSourcePinDirection) const { return nullptr; }
 
    virtual bool SupportsDropPinOnNode(UEdGraphNode* InTargetNode, const FEdGraphPinType& InSourcePinType, EEdGraphPinDirection InSourcePinDirection, FText& OutErrorMessage) const { return false; }
 
    virtual void SetPinBeingDroppedOnNode(UEdGraphPin* InSourcePin) const {}
 
    virtual bool IsCacheVisualizationOutOfDate(int32 InVisualizationCacheID) const { return false; }
 
    virtual int32 GetCurrentVisualizationCacheID() const { return 0; }
 
    virtual void ForceVisualizationCacheClear() const {};
 
    virtual FPinConnectionResponse CanCreateNewNodes(UEdGraphPin* InSourcePin) const { return FPinConnectionResponse(); }
 
    virtual bool CanVariableBeDropped(UEdGraph* InGraph, FProperty* InVariableToDrop) const { return false; }
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual bool RequestVariableDropOnPanel(UEdGraph* InGraph, FProperty* InVariableToDrop, const FVector2D& InDropPosition, const FVector2D& InScreenPosition) const UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION
    {
        return false;
    }
    virtual bool RequestVariableDropOnPanel(UEdGraph* InGraph, FProperty* InVariableToDrop, const FVector2f& InDropPosition, const FVector2f& InScreenPosition) const
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return RequestVariableDropOnPanel(InGraph, InVariableToDrop, FVector2D(InDropPosition), FVector2D(InScreenPosition));
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual bool RequestVariableDropOnNode(UEdGraph* InGraph, FProperty* InVariableToDrop, UEdGraphNode* InNode, const FVector2D& InDropPosition, const FVector2D& InScreenPosition) const UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION
    {
        return false;
    }
    virtual bool RequestVariableDropOnNode(UEdGraph* InGraph, FProperty* InVariableToDrop, UEdGraphNode* InNode, const FVector2f& InDropPosition, const FVector2f& InScreenPosition) const
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return RequestVariableDropOnNode(InGraph, InVariableToDrop, InNode, FVector2D(InDropPosition), FVector2D(InScreenPosition));
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f; this API no longer interfaces directly with double-precision scalars and vectors.")
    virtual bool RequestVariableDropOnPin(UEdGraph* InGraph, FProperty* InVariableToDrop, UEdGraphPin* InPin, const FVector2D& InDropPosition, const FVector2D& InScreenPosition) const UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION
    {
        return false;
    }
    virtual bool RequestVariableDropOnPin(UEdGraph* InGraph, FProperty* InVariableToDrop, UEdGraphPin* InPin, const FVector2f& InDropPosition, const FVector2f& InScreenPosition) const
    {
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return RequestVariableDropOnPin(InGraph, InVariableToDrop, InPin, FVector2D(InDropPosition), FVector2D(InScreenPosition));
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
    virtual bool ArePinsCompatible(const UEdGraphPin* PinA, const UEdGraphPin* PinB, const UClass* CallingContext = nullptr, bool bIgnoreArray = false) const { return true; }
 
    virtual bool ArePinTypesEquivalent(const FEdGraphPinType& PinA, const FEdGraphPinType& PinB) const { return true; }
 
    virtual bool MarkBlueprintDirtyFromNewNode(UBlueprint* InBlueprint, UEdGraphNode* InEdGraphNode) const { return false; }
 
    virtual bool GetLocalVariables(const UEdGraph* InGraph, TArray<FBPVariableDescription>& OutLocalVariables) const { return false; }
 
    virtual TSharedPtr<FEdGraphSchemaAction> MakeActionFromVariableDescription(const UEdGraph* InEdGraph, const FBPVariableDescription& VariableDescription) const { return nullptr; }
 
    virtual void InsertAdditionalActions(TArray<UBlueprint*> InBlueprints, TArray<UEdGraph*> InGraphs, TArray<UEdGraphPin*> InPins, FGraphActionListBuilderBase& OutAllActions) const {}
 
#if WITH_EDITOR
    ENGINE_API virtual TSharedPtr<INameValidatorInterface> GetNameValidator(const UBlueprint* InBlueprintObj, const FName& InOriginalName, const UStruct* InValidationScope, const FName& InActionTypeId) const;
#endif
    
#if WITH_EDITORONLY_DATA
private:
    virtual bool ShouldShowPanelContextMenuForIncompatibleConnectionsImpl() const { return false; }
protected:
    ENGINE_API int32 CollectSearchTextWeightInfo(const FEdGraphSchemaAction& InCurrentAction, const FGraphSchemaSearchWeightModifiers& InWeightModifiers,
        TArray<FGraphSchemaSearchTextWeightInfo>& OutWeightedArrayList, FGraphSchemaSearchTextDebugInfo* InDebugInfo) const;
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.5, "FGraphActionListBuilderBase::ActionGroup weight calculation was always performed on the first action, provide that if scoring a FGraphActionListBuilderBase::ActionGroup, or just provide the FEdGraphSchemaAction")
    ENGINE_API int32 CollectSearchTextWeightInfo(const FGraphActionListBuilderBase::ActionGroup& InCurrentAction, const FGraphSchemaSearchWeightModifiers& InWeightModifiers,
        TArray<FGraphSchemaSearchTextWeightInfo>& OutWeightedArrayList, FGraphSchemaSearchTextDebugInfo* InDebugInfo) const;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
 
    ENGINE_API void PrintSearchTextDebugInfo(const TArray<FString>& InFilterTerms, const FEdGraphSchemaAction& InCurrentAction, const FGraphSchemaSearchTextDebugInfo* InDebugInfo) const;
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UE_DEPRECATED(5.5, "Only the first entry in the action group has ever been used, provide it to PrintSearchTextDebugInfo")
    ENGINE_API void PrintSearchTextDebugInfo(const TArray<FString>& InFilterTerms, const FGraphActionListBuilderBase::ActionGroup& InCurrentAction, const FGraphSchemaSearchTextDebugInfo* InDebugInfo) const;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif // WITH_EDITORONLY_DATA
};