DialogueGraphNode_Edge.h

Go to the documentation of this file.

// Copyright Csaba Molnar, Daniel Butum. All Rights Reserved.
#pragma once
 
#include "CoreTypes.h"
 
#include "DialogueGraphNode_Base.h"
#include "DialogueGraphNode.h"
 
#include "DialogueGraphNode_Edge.generated.h"
 
 
UCLASS()
class UDialogueGraphNode_Edge : public UDialogueGraphNode_Base
{
    GENERATED_BODY()
 
public:
    // Begin UObject Interface.
    void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
 
    bool Modify(bool bAlwaysMarkDirty = true) override;
 
    bool SuperModify(bool bAlwaysMarkDirty = true) { return Super::Modify(bAlwaysMarkDirty); }
 
    // UEdGraphNode interface.
    void AllocateDefaultPins() override;
 
    FText GetNodeTitle(ENodeTitleType::Type TitleType) const override;
 
    FText GetTooltipText() const override;
 
    void PinConnectionListChanged(UEdGraphPin* Pin) override;
 
    void PostPasteNode() override;
 
    FSlateIcon GetIconAndTint(FLinearColor& OutColor) const override
    {
        static const FSlateIcon Icon = FSlateIcon(FEditorStyle::GetStyleSetName(), "Graph.TransitionNode.Icon");
        OutColor = GetNodeBackgroundColor();
        return Icon;
    }
 
    // Begin UDialogueGraphNode_Base interface
    FLinearColor GetNodeBackgroundColor() const override { return FColorList::White; }
 
    // Begin own functions
    bool HasParentNode() const
    {
        if (HasInputPin())
        {
            UEdGraphPin* InputPin = GetInputPin();
            return InputPin->LinkedTo.Num() == 1 && InputPin->LinkedTo[0] != nullptr &&
                   InputPin->LinkedTo[0]->GetOwningNodeUnchecked() != nullptr;
        }
 
        return false;
    }
 
    bool HasChildNode() const
    {
        if (HasOutputPin())
        {
            UEdGraphPin* OutputPin = GetOutputPin();
            return OutputPin->LinkedTo.Num() == 1 && OutputPin->LinkedTo[0] != nullptr &&
                   OutputPin->LinkedTo[0]->GetOwningNodeUnchecked() != nullptr;
        }
 
        return false;
    }
 
    UDialogueGraphNode* GetParentNode() const
    {
        check(HasParentNode());
        return CastChecked<UDialogueGraphNode>(GetInputPin()->LinkedTo[0]->GetOwningNode());
    }
 
    UDialogueGraphNode* GetChildNode() const
    {
        check(HasChildNode());
        return CastChecked<UDialogueGraphNode>(GetOutputPin()->LinkedTo[0]->GetOwningNode());
    }
 
    void CreateConnections(UDialogueGraphNode* ParentNode, UDialogueGraphNode* ChildNode);
 
    // Begin own function
    const FDlgEdge& GetDialogueEdge() const { return DialogueEdge; }
    FDlgEdge& GetDialogueEdge() { return DialogueEdge; }
 
    void SetDialogueEdge(const FDlgEdge& InEdge) { DialogueEdge = InEdge; }
 
    void SetDialogueEdgeTargetIndex(int32 InIndex) { DialogueEdge.TargetIndex = InIndex; }
 
    void SetDialogueEdgeText(const FText& InText)
    {
        DialogueEdge.SetText(InText);
    }
 
    bool HasConditions() const { return DialogueEdge.Conditions.Num() > 0; }
 
    FLinearColor GetEdgeColor(bool bIsHovered) const;
 
    bool IsPrimaryEdge() const { return bIsPrimaryEdge; }
 
    void SetIsPrimaryEdge(bool bValue) { bIsPrimaryEdge = bValue; }
 
    bool ShouldDrawEdge() const
    {
        // If The parent or the child is hidden, we also hide this edge no matter the settings
        if (HasInputPin() && HasOutputPin())
        {
            if (!GetParentNode()->ShouldDrawNode() || !GetChildNode()->ShouldDrawNode())
            {
                return false;
            }
        }
 
        const UDlgSystemSettings* Settings = GetDefault<UDlgSystemSettings>();
        if (Settings->bShowPrimarySecondaryEdges)
        {
            return IsPrimaryEdge() ? Settings->bDrawPrimaryEdges : Settings->bDrawSecondaryEdges;
        }
 
        return true;
    }
    // End own functions
 
protected:
    // Begin UDialogueGraphNode_Base interface
    void CreateInputPin() override
    {
        static const FName PinName(TEXT("Input"));
        static const FName CategoryName(TEXT("Transition"));
        FCreatePinParams PinParams;
        PinParams.Index = INDEX_PIN_Input;
        CreatePin(EGPD_Input, CategoryName, PinName, PinParams);
    }
 
    void CreateOutputPin() override
    {
        static const FName PinName(TEXT("Output"));
        static const FName CategoryName(TEXT("Transition"));
        FCreatePinParams PinParams;
        PinParams.Index = INDEX_PIN_Output;
        CreatePin(EGPD_Output, CategoryName, PinName, PinParams);
    }
 
private:
    // Begin own functions
    FDlgEdge* GetMutableDialogueEdgeFromParentNode() const;
 
private:
    UPROPERTY(EditAnywhere, Category = DialogueGraphNode, Meta = (ShowOnlyInnerProperties))
    FDlgEdge DialogueEdge;
 
    UPROPERTY()
    bool bIsPrimaryEdge = true;
};