NotificationManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "SlateFwd.h"
#include "Containers/LockFreeList.h"
#include "Layout/SlateRect.h"
#include "Widgets/SWindow.h"
 
#include "HAL/IConsoleManager.h"
#include "Misc/CoreAsyncTaskNotificationImpl.h"
 
struct FNotificationInfo;
 
template <class T> class TLockFreePointerListLIFO;
 
struct FProgressNotificationHandle
{
    friend class FSlateNotificationManager;
 
    FProgressNotificationHandle()
        : Id(INDEX_NONE)
    {}
 
    void Reset() { Id = INDEX_NONE; }
    bool IsValid() const { return Id != INDEX_NONE; }
 
    bool operator==(const FProgressNotificationHandle& OtherHandle) const
    {
        return Id == OtherHandle.Id;
    }
private:
    FProgressNotificationHandle(int32 InId)
        : Id(InId)
    {}
 
    int32 Id;
};
 
class IProgressNotificationHandler
{
public:
    virtual ~IProgressNotificationHandler() {}
 
    virtual void StartProgressNotification(FProgressNotificationHandle Handle, FText DisplayText, int32 TotalWorkToDo) = 0;
 
    virtual void UpdateProgressNotification(FProgressNotificationHandle Handle, int32 TotalWorkDone, int32 UpdatedTotalWorkToDo, FText UpdatedDisplayText) = 0;
 
    virtual void CancelProgressNotification(FProgressNotificationHandle Handle) = 0;
};
class FSlateNotificationManager
{
    friend class SNotificationList;
 
public:
    static SLATE_API FSlateNotificationManager& Get();
 
    SLATE_API void Tick();
 
    SLATE_API void SetRootWindow( const TSharedRef<SWindow> InRootWindow );
 
    SLATE_API TSharedPtr<SNotificationItem> AddNotification(const FNotificationInfo& Info);
 
    SLATE_API void QueueNotification(FNotificationInfo* Info);
 
    SLATE_API FProgressNotificationHandle StartProgressNotification(FText DisplayText, int32 TotalWorkToDo);
 
    SLATE_API void UpdateProgressNotification(FProgressNotificationHandle InHandle, int32 TotalWorkDone, int32 UpdatedTotalWorkToDo = 0, FText UpdatedDisplayText = FText::GetEmpty());
 
    SLATE_API void CancelProgressNotification(FProgressNotificationHandle InHandle);
 
    SLATE_API void SetProgressNotificationHandler(IProgressNotificationHandler* NewHandler);
 
    SLATE_API void ForceNotificationsInFront(const TSharedRef<SWindow> InWindow);
 
    SLATE_API void GetWindows(TArray< TSharedRef<SWindow> >& OutWindows) const;
 
    void SetAllowNotifications( const bool bShouldAllow )
    {
        this->bAllowNotifications = bShouldAllow;
    }
 
    bool AreNotificationsAllowed() const
    {
        return this->bAllowNotifications;
    }
 
    SLATE_API void RegisterStagedNotification(TSharedPtr<IAsyncTaskNotificationImpl> InNotification);
 
    SLATE_API void UnregisterStagedNotification(TSharedPtr<IAsyncTaskNotificationImpl> InNotification);
 
protected:
    SLATE_API FSlateNotificationManager();
 
    SLATE_API TSharedRef<SNotificationList> CreateStackForArea(const FSlateRect& InRectangle, TSharedPtr<SWindow> Window);
 
    SLATE_API void ShutdownOnPreExit();
 
private:
 
    struct FRegionalNotificationList
    {
        FRegionalNotificationList(const FSlateRect& InRectangle);
 
        void Arrange();
 
        void RemoveDeadNotifications();
 
        TArray<TSharedRef<SNotificationList>> Notifications;
 
        FSlateRect Region;
    };
 
    IProgressNotificationHandler* ProgressNotificationHandler = nullptr;
 
    TWeakPtr<SWindow> RootWindowPtr;
 
    TArray<FRegionalNotificationList> RegionalLists;
 
    TLockFreePointerListLIFO<FNotificationInfo> PendingNotifications;
 
    TArray<TSharedPtr<IAsyncTaskNotificationImpl>> StagedNotifications;
 
    FCriticalSection StagedNotificationCS;
 
    static SLATE_API int32 ProgressHandleCounter;
 
    bool bAllowNotifications = true;
 
    FAutoConsoleVariableRef CVarAllowNotifications;
    
    // On Linux there is a hack in SDL to already delayed the showing of notification that is not interacting well with this optimization.
    static constexpr bool bShowNotificationImmediately = PLATFORM_LINUX;
};