// Copyright Epic Games, Inc. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "UObject/ObjectMacros.h" #include "UObject/Class.h" #include "Templates/SubclassOf.h" #include "Textures/SlateIcon.h" #include "Engine/MemberReference.h" #include "EdGraph/EdGraphNodeUtils.h" #include "K2Node.h" #include "K2Node_CallFunction.generated.h" class FKismetCompilerContext; class SWidget; class UEdGraph; UCLASS() class BLUEPRINTGRAPH_API UK2Node_CallFunction : public UK2Node { GENERATED_UCLASS_BODY() /** Indicates that this is a call to a pure function */ UPROPERTY() uint32 bIsPureFunc:1; /** Indicates that this is a call to a const function */ UPROPERTY() uint32 bIsConstFunc:1; /** Indicates that during compile we want to create multiple exec pins from an enum param */ UPROPERTY() uint32 bWantsEnumToExecExpansion:1; /** Indicates that this is a call to an interface function */ UPROPERTY() uint32 bIsInterfaceCall:1; /** Indicates that this is a call to a final / superclass's function */ UPROPERTY() uint32 bIsFinalFunction:1; /** Indicates that this is a 'bead' function with no fixed location; it is drawn between the nodes that it is wired to */ UPROPERTY() uint32 bIsBeadFunction:1; /** The function to call */ UPROPERTY() FMemberReference FunctionReference; private: /** The name of the function to call */ UPROPERTY() FName CallFunctionName_DEPRECATED; /** The class that the function is from. */ UPROPERTY() TSubclassOf CallFunctionClass_DEPRECATED; protected: /** Constructing FText strings can be costly, so we cache the node's tooltip */ FNodeTextCache CachedTooltip; private: /** Flag used to track validity of pin tooltips, when tooltips are invalid they will be refreshed before being displayed */ mutable bool bPinTooltipsValid; TArray ExpandAsEnumPins; public: // UObject interface virtual void PostDuplicate(bool bDuplicateForPIE) override; virtual void Serialize(FArchive& Ar) override; // End of UObject interface // UEdGraphNode interface virtual void GetPinHoverText(const UEdGraphPin& Pin, FString& HoverTextOut) const override; virtual void AllocateDefaultPins() override; virtual FLinearColor GetNodeTitleColor() const override; virtual FText GetTooltipText() const override; virtual FText GetNodeTitle(ENodeTitleType::Type TitleType) const override; virtual FString GetDescriptiveCompiledName() const override; virtual bool HasDeprecatedReference() const override; virtual FEdGraphNodeDeprecationResponse GetDeprecationResponse(EEdGraphNodeDeprecationType DeprecationType) const override; virtual void PostPlacedNewNode() override; virtual FString GetDocumentationLink() const override; virtual FString GetDocumentationExcerptName() const override; virtual FSlateIcon GetIconAndTint(FLinearColor& OutColor) const override; virtual bool CanPasteHere(const UEdGraph* TargetGraph) const override; virtual void PinDefaultValueChanged(UEdGraphPin* Pin) override; virtual void AddSearchMetaDataInfo(TArray& OutTaggedMetaData) const override; virtual TSharedPtr CreateNodeImage() const override; virtual UObject* GetJumpTargetForDoubleClick() const override; virtual bool CanJumpToDefinition() const override; virtual void JumpToDefinition() const override; virtual FString GetPinMetaData(FName InPinName, FName InKey) override; virtual bool HasExternalDependencies(TArray* OptionalOutput) const override; // End of UEdGraphNode interface // UK2Node interface virtual void ReallocatePinsDuringReconstruction(TArray& OldPins) override; virtual bool IsNodePure() const override { return bIsPureFunc; } virtual void PostReconstructNode() override; virtual bool ShouldDrawCompact() const override; virtual bool ShouldDrawAsBead() const override; virtual FText GetCompactNodeTitle() const override; virtual void PostPasteNode() override; virtual void ValidateNodeDuringCompilation(class FCompilerResultsLog& MessageLog) const override; virtual bool ShouldShowNodeProperties() const override; virtual void GetRedirectPinNames(const UEdGraphPin& Pin, TArray& RedirectPinNames) const override; virtual void NotifyPinConnectionListChanged(UEdGraphPin* Pin) override; virtual class FNodeHandlingFunctor* CreateNodeHandler(class FKismetCompilerContext& CompilerContext) const override; virtual void ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph) override; virtual FName GetCornerIcon() const override; virtual FText GetToolTipHeading() const override; virtual void GetNodeAttributes( TArray>& OutNodeAttributes ) const override; virtual FText GetMenuCategory() const override; virtual bool IsActionFilteredOut(class FBlueprintActionFilter const& Filter) override; virtual bool IsConnectionDisallowed(const UEdGraphPin* MyPin, const UEdGraphPin* OtherPin, FString& OutReason) const override; // End of UK2Node interface /** Returns the UFunction that this class is pointing to */ UFunction* GetTargetFunction() const; /** Get the then output pin */ UEdGraphPin* GetThenPin() const; /** Get the return value pin */ UEdGraphPin* GetReturnValuePin() const; /** @return true if the function is a latent operation */ bool IsLatentFunction() const; /** @return true if this function can be called on multiple contexts at once */ virtual bool AllowMultipleSelfs(bool bInputAsArray) const override; /** * Creates a self pin for the graph, taking into account the scope of the function call * * @param Function The function to be called by the Node. * * @return Pointer to the pin that was created */ virtual UEdGraphPin* CreateSelfPin(const UFunction* Function); /** * Creates all of the pins required to call a particular UFunction. * * @param Function The function to be called by the Node. * * @return true on success. */ bool CreatePinsForFunctionCall(const UFunction* Function); /** Create exec pins for this function. May be multiple is using 'expand enum as execs' */ void CreateExecPinsForFunctionCall(const UFunction* Function); /** Gets the name of the referenced function */ FName GetFunctionName() const; virtual void PostParameterPinCreated(UEdGraphPin *Pin) {} /** Gets the user-facing name for the function */ static FText GetUserFacingFunctionName(const UFunction* Function); /** Set up a pins tooltip from a function's tooltip */ static void GeneratePinTooltipFromFunction(UEdGraphPin& Pin, const UFunction* Function); /** Gets the non-specific tooltip for the function */ static FString GetDefaultTooltipForFunction(const UFunction* Function); /** Get default category for this function in action menu */ static FText GetDefaultCategoryForFunction(const UFunction* Function, const FText& BaseCategory); /** Get keywords for this function in the action menu */ static FText GetKeywordsForFunction(const UFunction* Function); /** Should be drawn compact for this function */ static bool ShouldDrawCompact(const UFunction* Function); /** Get the compact name for this function */ static FString GetCompactNodeTitle(const UFunction* Function); /** Get the text to use to explain the context for this function (used on node title) */ virtual FText GetFunctionContextString() const; /** Set properties of this node from a supplied function (does not save ref to function) */ virtual void SetFromFunction(const UFunction* Function); static void CallForEachElementInArrayExpansion(UK2Node* Node, UEdGraphPin* MultiSelf, FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph); static UEdGraphPin* InnerHandleAutoCreateRef(UK2Node* Node, UEdGraphPin* Pin, FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph, bool bForceAssignment); /** * Returns the graph for this function, if available. In cases of calling an event, it will be the ubergraph for the event * * @param OutGraphNode If this function calls an event, this param is the event node, otherwise it is NULL */ UEdGraph* GetFunctionGraph(const UEdGraphNode*& OutGraphNode) const; /** Checks if the property is marked as "CustomStructureParam" */ static bool IsStructureWildcardProperty(const UFunction* InFunction, const FName PropertyName); /** returns true if InProperty should be treated as a wildcard (e.g. due to SetParam markup) */ static bool IsWildcardProperty(const UFunction* InFunction, const FProperty* InProperty); /** Used to determine the result of AllowMultipleSelfs() (without having a node instance) */ static bool CanFunctionSupportMultipleTargets(UFunction const* InFunction); /** Checks if the input function can be called in the input object with respect to editor-only/runtime mismatch*/ static bool CanEditorOnlyFunctionBeCalled(const UFunction* InFunction, const UObject* InObject); /** */ static FSlateIcon GetPaletteIconForFunction(UFunction const* Function, FLinearColor& OutColor); static void GetExpandEnumPinNames(const UFunction* Function, TArray& EnumNamesToCheck); private: /* Looks at function metadata and properties to determine if this node should be using enum to exec expansion */ void DetermineWantsEnumToExecExpansion(const UFunction* Function); /** * Creates hover text for the specified pin. * * @param Pin The pin you want hover text for (should belong to this node) */ void GeneratePinTooltip(UEdGraphPin& Pin) const; /** * Connect Execute and Then pins for functions, which became pure. */ bool ReconnectPureExecPins(TArray& OldPins); /** Conforms container pins */ void ConformContainerPins(); protected: /** Invalidates current pin tool tips, so that they will be refreshed before being displayed: */ void InvalidatePinTooltips(); /** Helper function to ensure function is called in our context */ virtual void FixupSelfMemberContext(); /** Helper function to find UFunction entries from the skeleton class, use with caution.. */ UFunction* GetTargetFunctionFromSkeletonClass() const; };