SNotificationList.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/Attribute.h"
#include "Types/SlateStructs.h"
#include "Layout/Visibility.h"
#include "Fonts/SlateFontInfo.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Widgets/SCompoundWidget.h"
#include "Styling/SlateTypes.h"
#include "Widgets/Input/SCheckBox.h"
 
class INotificationWidget;
class SVerticalBox;
class SWindow;
 
class SNotificationItem
    : public SCompoundWidget
{
public:
    enum ECompletionState
    {
        CS_None,
        CS_Pending,
        CS_Success,
        CS_Fail,
    };
 
    virtual void SetText(const TAttribute< FText >& InText) = 0;
    
    virtual void SetSubText(const TAttribute<FText>& InSubText) = 0;
 
    virtual void SetHyperlink(const FSimpleDelegate& InHyperlink, const TAttribute< FText >& InHyperlinkText = TAttribute< FText >()) = 0;
 
    virtual void SetExpireDuration(float ExpireDuration) = 0;
 
    virtual void SetFadeInDuration(float FadeInDuration) = 0;
 
    virtual void SetFadeOutDuration(float FadeOutDuration) = 0;
 
    virtual ECompletionState GetCompletionState() const = 0;
 
    virtual void SetCompletionState(ECompletionState State) = 0;
 
    virtual void ExpireAndFadeout() = 0;
 
    virtual void Fadeout() = 0;
 
    virtual void Pulse(const FLinearColor& GlowColor) = 0;
};
 
 
struct FNotificationButtonInfo
{
    using FVisibilityDelegate = TDelegate<EVisibility(SNotificationItem::ECompletionState)>;
    using FIsEnabledDelegate = TDelegate<bool(SNotificationItem::ECompletionState)>;
 
    FNotificationButtonInfo( const TAttribute<FText>& InText, const TAttribute<FText>& InToolTip, FSimpleDelegate InCallback, SNotificationItem::ECompletionState VisibleInState = SNotificationItem::CS_Pending )
        : Text( InText )
        , ToolTip( InToolTip )
        , Callback( MoveTemp(InCallback) )
        , VisibilityCallback()
        , IsEnabledCallback()
        , VisibilityOnNone( VisibleInState == SNotificationItem::CS_None ? EVisibility::Visible : EVisibility::Collapsed )
        , VisibilityOnPending( VisibleInState == SNotificationItem::CS_Pending ? EVisibility::Visible : EVisibility::Collapsed )
        , VisibilityOnSuccess( VisibleInState == SNotificationItem::CS_Success ? EVisibility::Visible : EVisibility::Collapsed )
        , VisibilityOnFail( VisibleInState == SNotificationItem::CS_Fail ? EVisibility::Visible : EVisibility::Collapsed )
    { }
 
    FNotificationButtonInfo( const TAttribute<FText>& InText, const TAttribute<FText>& InToolTip, FSimpleDelegate InCallback, FVisibilityDelegate InVisibilityCallback, FIsEnabledDelegate InIsEnabledCallback = FIsEnabledDelegate() )
        : Text( InText )
        , ToolTip( InToolTip )
        , Callback( MoveTemp(InCallback) )
        , VisibilityCallback( MoveTemp(InVisibilityCallback) )
        , IsEnabledCallback( MoveTemp(InIsEnabledCallback) )
        , VisibilityOnNone( VisibilityCallback.IsBound() ? EVisibility::Collapsed : EVisibility::Visible )
        , VisibilityOnPending( VisibilityCallback.IsBound() ? EVisibility::Collapsed : EVisibility::Visible )
        , VisibilityOnSuccess( VisibilityCallback.IsBound() ? EVisibility::Collapsed : EVisibility::Visible )
        , VisibilityOnFail( VisibilityCallback.IsBound() ? EVisibility::Collapsed : EVisibility::Visible )
    { }
 
    TAttribute<FText> Text;
    TAttribute<FText> ToolTip;
    FSimpleDelegate Callback;
    FVisibilityDelegate VisibilityCallback;
    FIsEnabledDelegate IsEnabledCallback;
 
    EVisibility VisibilityOnNone;
    EVisibility VisibilityOnPending;
    EVisibility VisibilityOnSuccess;
    EVisibility VisibilityOnFail;
};
 
 
struct FNotificationInfo
{
    FNotificationInfo(const FText& InText)
        : ContentWidget(),
        Text(InText),
        SubText(),
        ButtonDetails(),
        Image(nullptr),
        FadeInDuration(0.5f),
        FadeOutDuration(2.0f),
        ExpireDuration(1.0f),
        bUseThrobber(true),
        bUseSuccessFailIcons(true),
        bUseLargeFont(true),
        bUseCopyToClipboard(false),
        WidthOverride(320.0f),
        bFireAndForget(true),
        CheckBoxState(ECheckBoxState::Unchecked),
        CheckBoxStateChanged(),
        CheckBoxText(),
        Hyperlink(),
        HyperlinkText( NSLOCTEXT("EditorNotification", "DefaultHyperlinkText", "Show Log") ),
        bAllowThrottleWhenFrameRateIsLow(true)
    { };
 
    FNotificationInfo(TSharedPtr<INotificationWidget> InContentWidget)
        : ContentWidget(InContentWidget),
        Text(),
        SubText(),
        ButtonDetails(),
        Image(nullptr),
        FadeInDuration(0.5f),
        FadeOutDuration(2.0f),
        ExpireDuration(1.0f),
        bUseThrobber(false),
        bUseSuccessFailIcons(false),
        bUseLargeFont(false),
        bUseCopyToClipboard(false),
        WidthOverride(320.0f),
        bFireAndForget(true),
        CheckBoxState(ECheckBoxState::Unchecked),
        CheckBoxStateChanged(),
        CheckBoxText(),
        Hyperlink(),
        HyperlinkText(),
        bAllowThrottleWhenFrameRateIsLow(true)
    { };
 
    UE_DEPRECATED(5.6, "Use the flag bUseCopyToClipboard instead.")
    SLATE_API void ShowCopyToClipboadHyperlink();
 
    TSharedPtr<INotificationWidget> ContentWidget;
 
    TAttribute<FText> Text;
 
    TAttribute<FText> SubText;
 
    TArray<FNotificationButtonInfo> ButtonDetails;
 
    const FSlateBrush* Image;
 
    float FadeInDuration;
 
    float FadeOutDuration;
 
    float ExpireDuration;
 
    bool bUseThrobber;
 
    bool bUseSuccessFailIcons;
 
    bool bUseLargeFont;
 
    bool bUseCopyToClipboard;
 
    FOptionalSize WidthOverride;
 
    bool bFireAndForget;
 
    TAttribute<ECheckBoxState> CheckBoxState;
 
    FOnCheckStateChanged CheckBoxStateChanged;
 
    TAttribute<FText> CheckBoxText;
 
    FSimpleDelegate Hyperlink;
 
    TAttribute<FText> HyperlinkText;
 
    TSharedPtr<SWindow> ForWindow;
 
    bool bAllowThrottleWhenFrameRateIsLow;
};
 
 
class SNotificationList
    : public SCompoundWidget
{
    friend class SNotificationExtendable;
    friend class FSlateNotificationManager;
 
public:
 
    SLATE_BEGIN_ARGS( SNotificationList ){}
    SLATE_END_ARGS()
    
    
    SLATE_API void Construct( const FArguments& InArgs );
 
    SLATE_API virtual TSharedRef<SNotificationItem> AddNotification(const FNotificationInfo& Info);
 
protected:
 
    SLATE_API virtual void NotificationItemFadedOut (const TSharedRef<SNotificationItem>& NotificationItem);
 
protected:
 
    TSharedPtr<SVerticalBox> MessageItemBoxPtr;
 
    TWeakPtr<SWindow> ParentWindowPtr;
 
    bool bDone;
 
private:
 
    TSharedPtr<SNotificationItem> LastNotification;
 
};