TokenizedMessage.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Internationalization/Text.h"
#include "Misc/Attribute.h"
#include "Misc/Guid.h"
#include "Templates/SharedPointer.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
namespace EMessageSeverity
{
    enum Type : int
    {
        CriticalError UE_DEPRECATED(5.1, "CriticalError was removed because it can't trigger an assert at the callsite. Use 'checkf' instead.") = 0,
        Error = 1,
        PerformanceWarning = 2,
        Warning = 3,
        Info = 4,   // Should be last
    };
}
 
DECLARE_DELEGATE_OneParam(FOnMessageTokenActivated, const TSharedRef<class IMessageToken>&);
 
namespace EMessageToken
{
    enum Type
    {
        Action,
        Actor,
        AssetName,
        AssetData,
        Documentation,
        Image,
        Object,
        Severity,
        Text,
        Tutorial,
        URL,
        EdGraph,
        DynamicText,
        Fix,
    };
}
 
class IMessageToken : public TSharedFromThis<IMessageToken>
{
public:
 
    virtual ~IMessageToken() {}
 
    virtual EMessageToken::Type GetType() const = 0;
 
    virtual const FText& ToText() const
    {
        return CachedText;
    }
 
    virtual const FOnMessageTokenActivated& GetOnMessageTokenActivated() const
    {
        return MessageTokenActivated;
    }
 
    virtual TSharedRef<IMessageToken> OnMessageTokenActivated( FOnMessageTokenActivated InMessageTokenActivated )
    {
        MessageTokenActivated = InMessageTokenActivated;
        return AsShared();
    }
 
protected:
    FOnMessageTokenActivated MessageTokenActivated;
 
    FText CachedText;
};
 
class FTokenizedMessage : public TSharedFromThis<FTokenizedMessage>
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
 
    CORE_API static TSharedRef<FTokenizedMessage> Create(EMessageSeverity::Type InSeverity, const FText& InMessageText = FText());
 
    CORE_API TSharedRef<FTokenizedMessage> Clone() const;
 
    CORE_API FText ToText() const;
    
    CORE_API TSharedRef<FTokenizedMessage> AddToken( const TSharedRef<IMessageToken>& InToken );
 
    CORE_API TSharedRef<FTokenizedMessage> AddText(const FText& InText);
 
    template<typename... TArguments>
    TSharedRef<FTokenizedMessage> AddText(FTextFormat InTextFormat, TArguments&&... InArgs)
    {
        return AddText(FText::FormatOrdered(InTextFormat, Forward<TArguments...>(InArgs...)));
    }
 
    CORE_API void SetSeverity( const EMessageSeverity::Type InSeverity );
 
    CORE_API EMessageSeverity::Type GetSeverity() const;
 
    CORE_API const TArray< TSharedRef<IMessageToken> >& GetMessageTokens() const;
 
    CORE_API void SetMessageLink(const TSharedRef<IMessageToken>& InToken);
 
    CORE_API TSharedPtr<IMessageToken> GetMessageLink() const;
 
    CORE_API static FText GetSeverityText(EMessageSeverity::Type InSeverity);
 
    CORE_API static FName GetSeverityIconName(EMessageSeverity::Type InSeverity);
    
    CORE_API FName GetIdentifier() const;
    
    CORE_API void SetIdentifier(FName InIdentifier);
 
    explicit FTokenizedMessage(FPrivateToken)
        : Severity( EMessageSeverity::Info )
        , Identifier(NAME_None)
    {
    }
 
protected:
 
    TArray< TSharedRef<IMessageToken> > MessageTokens;
 
    TSharedPtr<IMessageToken> MessageLink;
 
private:
 
    EMessageSeverity::Type Severity;
 
    FName Identifier;
};
 
class FTextToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FTextToken> Create(const FText& InMessage, bool InIsSourceLinkOnLeft = true);
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::Text;
    }
    FTextToken(FPrivateToken, const FText& InMessage, bool InIsSourceLinkOnLeft)
    {
        CachedText = InMessage;
        bIsSourceLinkOnLeft = InIsSourceLinkOnLeft;
    }
 
    bool IsSourceLinkOnLeft() const
    {
        return bIsSourceLinkOnLeft;
    }
 
private:
    bool bIsSourceLinkOnLeft;
};
 
class FDynamicTextToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FDynamicTextToken> Create(const TAttribute<FText>& InMessage);
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::DynamicText;
    }
 
    virtual const FText& ToText() const
    {
        return Message.Get();
    }
    const TAttribute<FText>& GetTextAttribute() const
    {
        return Message;
    }
 
    FDynamicTextToken(FPrivateToken, const TAttribute<FText>& InMessage)
        : Message(InMessage)
    {
        CachedText = InMessage.Get();
    }
 
private:
    TAttribute<FText> Message;
};
 
class FImageToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FImageToken> Create(const FName& InImageName);
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::Image;
    }
    const FName& GetImageName() const
    {
        return ImageName;
    }
 
    FImageToken(FPrivateToken, const FName& InImageName)
        : ImageName(InImageName)
    {
        CachedText = FText::FromName( InImageName );
    }
 
private:
    FName ImageName;
};
 
class FSeverityToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FSeverityToken> Create(EMessageSeverity::Type InSeverity);
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::Severity;
    }
    EMessageSeverity::Type GetSeverity() const
    {
        return Severity;
    }
 
    FSeverityToken(FPrivateToken, EMessageSeverity::Type InSeverity)
        : Severity(InSeverity)
    {
        CachedText = FTokenizedMessage::GetSeverityText( InSeverity );
    }
 
private:
    EMessageSeverity::Type Severity;
};
 
class FURLToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FURLToken> Create(const FString& InURL, const FText& InMessage = FText());
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::URL;
    }
    const FString& GetURL() const
    {
        return URL;
    }
 
    inline FURLToken(FPrivateToken, const FString& InURL, const FText& InMessage)
        : FURLToken(InURL, InMessage)
    {
    }
 
private:
    FURLToken(const FString& InURL, const FText& InMessage);
 
    static void VisitURL(const TSharedRef<IMessageToken>& Token, FString InURL);
 
    FString URL;
};
 
class FAssetNameToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FAssetNameToken> Create(const FString& InAssetName, const FText& InMessage = FText());
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::AssetName;
    }
    const FString& GetAssetName() const
    {
        return AssetName;
    }
 
    DECLARE_DELEGATE_OneParam(FOnGotoAsset, const FString&);
    static FOnGotoAsset& OnGotoAsset()
    {
        return GotoAsset;
    }
 
    inline FAssetNameToken(FPrivateToken, const FString& InAssetName, const FText& InMessage)
        : FAssetNameToken(InAssetName, InMessage)
    {
    }
 
private:
    FAssetNameToken(const FString& InAssetName, const FText& InMessage);
 
    static void FindAsset(const TSharedRef<IMessageToken>& Token, FString InAssetName);
 
    FString AssetName;
 
    CORE_API static FOnGotoAsset GotoAsset;
};
 
class FDocumentationToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FDocumentationToken> Create(const FString& InDocumentationLink, const FString& InPreviewExcerptLink = FString(), const FString& InPreviewExcerptName = FString());
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::Documentation;
    }
    const FString& GetDocumentationLink() const
    {
        return DocumentationLink;
    }
 
    const FString& GetPreviewExcerptLink() const
    {
        return PreviewExcerptLink;
    }
 
    const FString& GetPreviewExcerptName() const
    {
        return PreviewExcerptName;
    }
 
    inline FDocumentationToken(FPrivateToken, const FString& InDocumentationLink, const FString& InPreviewExcerptLink, const FString& InPreviewExcerptName)
        : FDocumentationToken(InDocumentationLink, InPreviewExcerptLink, InPreviewExcerptName)
    {
    }
 
protected:
    FDocumentationToken(const FString& InDocumentationLink, const FString& InPreviewExcerptLink, const FString& InPreviewExcerptName);
 
private:
    FString DocumentationLink;
 
    FString PreviewExcerptLink;
 
    FString PreviewExcerptName;
};
 
 
DECLARE_DELEGATE(FOnActionTokenExecuted);
DECLARE_DELEGATE_RetVal(bool, FCanExecuteActionToken);
 
class FActionToken
    : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
 
    CORE_API static TSharedRef<FActionToken> Create(const FText& InActionName, const FText& InActionDescription, const FOnActionTokenExecuted& InAction, bool bInSingleUse = false);
    CORE_API static TSharedRef<FActionToken> Create(const FText& InActionName, const FText& InActionDescription, const FOnActionTokenExecuted& InAction, const FCanExecuteActionToken& InCanExecuteAction, bool bInSingleUse = false);
 
    void ExecuteAction()
    {
        ActionDelegate.ExecuteIfBound();
        bActionExecuted = true;
    }
 
    const FText& GetActionDescription()
    {
        return ActionDescription;
    }
 
    bool CanExecuteAction() const
    {
        return ActionDelegate.IsBound() && (!bSingleUse || !bActionExecuted) && (!CanExecuteActionDelegate.IsBound() || CanExecuteActionDelegate.Execute());
    }
 
    bool IsValidAction() const
    {
        return ActionDelegate.IsBound();
    }
 
    // IMessageToken interface
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::Action;
    }
 
    inline FActionToken(FPrivateToken, const FText& InActionName, const FText& InActionDescription, const FOnActionTokenExecuted& InAction, bool bInSingleUse)
        : FActionToken(InActionName, InActionDescription, InAction, bInSingleUse)
    {
    }
 
    inline FActionToken(FPrivateToken, const FText& InActionName, const FText& InActionDescription, const FOnActionTokenExecuted& InAction, const FCanExecuteActionToken& InCanExecuteAction, bool bInSingleUse)
        : FActionToken(InActionName, InActionDescription, InAction, InCanExecuteAction, bInSingleUse)
    {
    }
 
protected:
 
    FActionToken(const FText& InActionName, const FText& InActionDescription, const FOnActionTokenExecuted& InAction, bool bInSingleUse)
        : ActionDelegate(InAction)
        , ActionDescription(InActionDescription)
        , bSingleUse(bInSingleUse)
        , bActionExecuted(false)
    {
        CachedText = InActionName;
    }
 
    FActionToken(const FText& InActionName, const FText& InActionDescription, const FOnActionTokenExecuted& InAction, const FCanExecuteActionToken& InCanExecuteAction, bool bInSingleUse)
        : ActionDelegate(InAction)
        , CanExecuteActionDelegate(InCanExecuteAction)
        , ActionDescription(InActionDescription)
        , bSingleUse(bInSingleUse)
        , bActionExecuted(false)
    {
        CachedText = InActionName;
    }
 
private:
 
    FOnActionTokenExecuted ActionDelegate;
 
    FCanExecuteActionToken CanExecuteActionDelegate;
 
    const FText ActionDescription;
    
    bool bSingleUse;
 
    bool bActionExecuted;
};
 
 
class FTutorialToken
    : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
 
    CORE_API static TSharedRef<FTutorialToken> Create(const FString& TutorialAssetName);
 
public:
 
    // IMessageToken interface
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::Tutorial;
    }
 
    const FString& GetTutorialAssetName() const
    {
        return TutorialAssetName;
    }
 
    FTutorialToken(FPrivateToken, const FString& InTutorialAssetName)
        : FTutorialToken(InTutorialAssetName)
    {
    }
 
protected:
    FTutorialToken( const FString& InTutorialAssetName )
        : TutorialAssetName(InTutorialAssetName)
    { }
 
private:
 
    FString TutorialAssetName;
};
 
class FActorToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FActorToken> Create(const FString& InActorPath, const FGuid& InActorGuid, const FText& InMessage = FText());
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::Actor;
    }
 
    virtual const FOnMessageTokenActivated& GetOnMessageTokenActivated() const override;
    const FString& GetActorPath() const
    {
        return ActorPath;
    }
 
    const FGuid& GetActorGuid() const
    {
        return ActorGuid;
    }
 
    static FOnMessageTokenActivated& DefaultOnMessageTokenActivated()
    {
        return DefaultMessageTokenActivated;
    }
 
    inline FActorToken(FPrivateToken, const FString& InActorPath, const FGuid& InActorGuid, const FText& InMessage)
        : FActorToken(InActorPath, InActorGuid, InMessage)
    {
    }
 
private:
    FActorToken(const FString& InActorPath, const FGuid& InActorGuid, const FText& InMessage);
 
    FString ActorPath;
 
    FGuid ActorGuid;
 
    CORE_API static FOnMessageTokenActivated DefaultMessageTokenActivated;
};
 
namespace UE::DataValidation
{
struct IFixer;
}
 
struct FFixResult
{
    bool bIsSuccess = true;
    FText Message;
 
    static FFixResult Success(const FText& Message)
    {
        return {true, Message};
    }
 
    static FFixResult Success()
    {
        return {true, FText::GetEmpty()};
    }
 
    static FFixResult Failure(const FText& Message)
    {
        return {false, Message};
    }
 
    // NOTE: No overload for Failure that accepts no message, because in case of an error you
    // should *always* let the user know what went wrong.
};
 
enum class EFixApplicability : uint8 
{
    CanBeApplied,
    Applied,
    DidNotApply,
};
 
class FFixToken : public IMessageToken
{
    // The private token allows only members or friends to call MakeShared.
    struct FPrivateToken { explicit FPrivateToken() = default; };
 
public:
    CORE_API static TSharedRef<FFixToken> Create(const FText& InName, TSharedRef<UE::DataValidation::IFixer> InFixer, int32 InFixIndex);
 
    virtual EMessageToken::Type GetType() const override
    {
        return EMessageToken::Fix;
    }
 
    TSharedRef<UE::DataValidation::IFixer> GetFixer() const { return Fixer.ToSharedRef(); }
    int32 GetFixIndex() const { return FixIndex; }
    void SetFix(TSharedRef<UE::DataValidation::IFixer> InFixer, int32 InFixIndex)
    {
        Fixer = InFixer;
        FixIndex = InFixIndex;
    }
 
    FFixToken(FPrivateToken, const FText& InName, TSharedPtr<UE::DataValidation::IFixer> Fixer, int32 FixIndex)
        : FFixToken(InName, MoveTemp(Fixer), FixIndex)
    {}
 
private:
    CORE_API FFixToken(const FText& InName, TSharedPtr<UE::DataValidation::IFixer> InFixer, int32 InFixIndex);
 
    TSharedPtr<UE::DataValidation::IFixer> Fixer;
    int32 FixIndex = INDEX_NONE;
};