DiffResults.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Styling/StyleColors.h"
#include "Styling/AppStyle.h"
 
class SWidget;
 
namespace EDiffType
{
    enum Type
    {
        // No actual difference
        NO_DIFFERENCE,
        
        // Object does not exist in current version
        OBJECT_REMOVED,
 
        // Object was added to current version
        OBJECT_ADDED,
 
        // An individual property differs
        OBJECT_PROPERTY,
 
        // Requests a full diff to be done on two objects, this will expand into other diffs
        OBJECT_REQUEST_DIFF,
 
        NODE_REMOVED,
        NODE_ADDED,
        PIN_LINKEDTO_NUM_DEC,
        PIN_LINKEDTO_NUM_INC,
        PIN_DEFAULT_VALUE,
        PIN_TYPE_CATEGORY,
        PIN_TYPE_SUBCATEGORY,
        PIN_TYPE_SUBCATEGORY_OBJECT,
        PIN_TYPE_IS_ARRAY,
        PIN_TYPE_IS_REF,
        PIN_LINKEDTO_NODE,
        PIN_LINKEDTO_PIN, // only used when a pin was relinked to a different pin on the same node
        NODE_MOVED,
        TIMELINE_LENGTH,
        TIMELINE_AUTOPLAY,
        TIMELINE_LOOP,
        TIMELINE_IGNOREDILATION,
        TIMELINE_NUM_TRACKS,
        TIMELINE_TRACK_MODIFIED,
        NODE_PIN_COUNT,
        NODE_COMMENT,
        NODE_PROPERTY,
 
        // Informational message, does't count as a real diff
        INFO_MESSAGE,
 
        // User defined custom diff. Allows user to override property diffing and panel widgets
        CUSTOM_OBJECT
    };
    
    enum Category
    {
        ADDITION,
        SUBTRACTION,
        MODIFICATION,
        
        // used for small changes like moving nodes that don't effect the compilation
        MINOR,
 
        // used for items that are purely informational and don't show up in the diff results
        CONTROL,
    };
}
 
struct FDiffSingleResult
{
    FDiffSingleResult()
    {
        Diff = EDiffType::NO_DIFFERENCE;
        Node1 = nullptr;
        Node2 = nullptr;
        Pin1 = nullptr;
        Pin2 = nullptr;
        Object1 = nullptr;
        Object2 = nullptr;
    }
 
    EDiffType::Type Diff;
 
    EDiffType::Category Category;
 
    class UEdGraphNode* Node1;
 
    class UEdGraphNode* Node2;
 
    class UEdGraphPin* Pin1;
 
    class UEdGraphPin* Pin2;
 
    const UObject* Object1;
 
    const UObject* Object2;
 
    FText DisplayString;
 
    FText ToolTip; 
 
    TSharedPtr<class IDiffCustomObject> CustomObject;
    TSharedPtr<class IDiffCustomProperty> CustomProperty;
 
    FLinearColor GetDisplayColor() const
    {
        switch(Category)
        {
        case EDiffType::ADDITION: return FAppStyle::Get().GetSlateColor("SourceControl.Diff.AdditionColor").GetSpecifiedColor();
        case EDiffType::SUBTRACTION: return FAppStyle::Get().GetSlateColor("SourceControl.Diff.SubtractionColor").GetSpecifiedColor();
        case EDiffType::MODIFICATION: return FAppStyle::Get().GetSlateColor("SourceControl.Diff.MajorModificationColor").GetSpecifiedColor();
        case EDiffType::MINOR:  return FAppStyle::Get().GetSlateColor("SourceControl.Diff.MinorModificationColor").GetSpecifiedColor();
        
        default: return FStyleColors::Foreground.GetSpecifiedColor();
        }
    }
 
    FString OwningObjectPath;
 
    inline bool IsRealDifference() const 
    {
        switch (Diff)
        {
        case EDiffType::NO_DIFFERENCE:
        case EDiffType::OBJECT_REQUEST_DIFF:
        case EDiffType::INFO_MESSAGE:
            return false;
        default:
            return true;
        }
    }
};
 
inline bool operator==( const FDiffSingleResult& LHS, const FDiffSingleResult& RHS )
{
    return  LHS.Diff == RHS.Diff &&
            LHS.Node1 == RHS.Node1 &&
            LHS.Node2 == RHS.Node2 &&
            LHS.Pin1 == RHS.Pin1 &&
            LHS.Pin2 == RHS.Pin2 &&
            LHS.Object1 == RHS.Object1 &&
            LHS.Object2 == RHS.Object2 &&
            LHS.DisplayString.ToString() == RHS.DisplayString.ToString() &&
            LHS.ToolTip.ToString() == RHS.ToolTip.ToString() &&
            LHS.Category == RHS.Category;
}
 
struct FDiffResults
{
    FDiffResults(TArray<FDiffSingleResult>* InResultArray): ResultArray(InResultArray), bHasFoundDiffs(false)
    {}
 
    void Add(const FDiffSingleResult& Result)
    {
        if(Result.Diff != EDiffType::NO_DIFFERENCE)
        {
            bHasFoundDiffs = true;
            if(ResultArray)
            {
                ResultArray->Add(Result);
            }
        }
    }
 
    bool CanStoreResults() const
    {
        return ResultArray != nullptr;
    }
 
    int32 Num() const { return ResultArray ? ResultArray->Num() : 0;}
 
    bool HasFoundDiffs() const { return bHasFoundDiffs; }
 
private:
    TArray<FDiffSingleResult>* ResultArray;
    bool bHasFoundDiffs;
};
 
class IDiffCustomObject : public TSharedFromThis<IDiffCustomObject>
{
public:
    virtual ~IDiffCustomObject() = default;
    virtual TSharedPtr<SWidget> GetOldWidget() = 0;
    virtual TSharedPtr<SWidget> GetNewWidget() = 0;
};
 
class IDiffCustomProperty : public TSharedFromThis<IDiffCustomProperty>
{
public:
    virtual ~IDiffCustomProperty() = default;
    virtual void HighlightProperty(const TSharedPtr<IDiffCustomObject> Widget) = 0;
};