UNotificationManager Class Reference

#include <NotificationManager.h>

Inheritance diagram for UNotificationManager:

Public Member Functions
	UNotificationManager (const FObjectInitializer &ObjectInitializer)
virtual void	AddNotificationToQueue (const FNotificationData &Data) override
virtual void	AddNotification (const FNotificationData &Data) override
virtual void	UpdateValue (const int32 IncreaseAmount, const int32 TotalValue, const FGameplayTag &HUDSlot) override
virtual bool	GetIsShowingNotification (FUniqueID &UniqueID) const override
bool	GetIsShowingNotification () const

Protected Member Functions
virtual bool	Initialize () override
virtual void	NativePreConstruct () override
virtual void	NativeConstruct () override
void	OnShowNotifications ()
void	OnStopNotifications ()
void	GetSlots ()
USlotWidget *	FindSlotByTag (const FGameplayTag &SlotTag) const

Protected Attributes
bool	bDebuggingMode = false
bool	bMultipleAtOnce = true
bool	bInstant = false
float	NextNotificationTime = 3.0f
float	InitialNotificationDelay = 3.0f
float	EndNotificationDelay = 5.0f
TArray< FNotificationData >	NotificationsQueue
class UOverlay *	NotificationOverlay = nullptr
class UOverlay *	SlotsOverlay = nullptr
TMap< FGameplayTag, USlotWidget * >	HUDSlots
TMap< FGameplayTag, TSubclassOf< UUserWidget > >	SlotWidgetClasses

Private Member Functions
void	ShowNotifications ()
void	AddNotification ()
void	StopNotifications ()
bool	IsValidSlot (const FGameplayTag &SlotTag) const
TSubclassOf< UUserWidget >	GetCustomClass (const FGameplayTag &SlotTag)

Private Attributes
TSubclassOf< UUserWidget >	NotificationWidgetClass
int32	CurrentIndex = 0
bool	bIsShowingNotification = false
INotificationInterface *	CurrentNotification = nullptr
FTimerHandle	NotificationTimerHandle
FTimerHandle	InitialNotificationTimerHandle
FTimerHandle	NotificationEndTimerHandle

Constructor & Destructor Documentation

UNotificationManager()

UNotificationManager::UNotificationManager ( const FObjectInitializer & ObjectInitializer )

explicit

    :Super(ObjectInitializer)
{
    
}

Member Function Documentation

AddNotification() [1/2]

void UNotificationManager::AddNotification ( )

private

{
    if(bMultipleAtOnce == false)
    {
        NotificationOverlay->ClearChildren();
    }
    if(NotificationsQueue.IsEmpty() == false)
    {
        bIsShowingNotification = true;
        if(bDebuggingMode){UE_LOG(LogBaseWidgets ,Warning,TEXT("UNotificationManager::AddNotification Add Notification Widget"));}
        const FNotificationData& Data = NotificationsQueue[0];
        TSubclassOf<UUserWidget> WidgetClass = NotificationWidgetClass;
        if(Data.bUseCustomClass && GetCustomClass(Data.SlotName) != nullptr)
        {
            WidgetClass = GetCustomClass(Data.SlotName);
        }
        UUserWidget* NotificationWidget = CreateWidget<UUserWidget>(GetOwningPlayer(), WidgetClass);
        if(NotificationWidget == nullptr){UE_LOG(LogBaseWidgets ,Error,TEXT("UNotificationManager::AddNotification NotificationWidget null"));StopNotifications();return;}
        CurrentNotification = Cast<INotificationInterface>(NotificationWidget);
        if(CurrentNotification == nullptr)
        {
            UE_LOG(LogBaseWidgets, Error, TEXT("UNotificationManager::AddNotification INotificationInterface null"));
            return;
        }
        CurrentNotification->SetLifeDuration(NextNotificationTime);
        CurrentNotification->SetNotificationData(Data);
        
        if(Data.bUseSlot && IsValidSlot(Data.SlotName))
        {
            const USlotWidget* SlotWidget = FindSlotByTag(Data.SlotName);
            if(SlotWidget == nullptr){UE_LOG(LogBaseWidgets, Error, TEXT("UNotificationManager::AddNotification Slot %s Doesn't Exist on %s"), *Data.SlotName.ToString(), *GetName())return;}
            SlotWidget->AddWidgetToSlot(NotificationWidget, false);
        }
        else
        {
            NotificationOverlay->AddChildToOverlay(NotificationWidget);
        }
        NotificationsQueue.RemoveAt(0);
        if(bInstant)
        {
            GetWorld()->GetTimerManager().ClearTimer(NotificationEndTimerHandle);
            AddNotification();
            return;
        }
        float FullNextNotificationTime = NextNotificationTime;
        if(Data.bUseCustomLife)
        {
            FullNextNotificationTime += Data.LifeDuration;
        }
        GetWorld()->GetTimerManager().SetTimer(NotificationTimerHandle, this, &UNotificationManager::AddNotification, FullNextNotificationTime);
    }
    else
    {
        bIsShowingNotification = false;
        GetWorld()->GetTimerManager().SetTimer(NotificationEndTimerHandle, this, &UNotificationManager::StopNotifications, EndNotificationDelay);
    }
}

AddNotification() [2/2]

void UNotificationManager::AddNotification ( const FNotificationData & Data )

overridevirtual

Implements INotificationManagerInterface.

{
    if(bDebuggingMode){UE_LOG(LogBaseWidgets ,Warning,TEXT("UNotificationManager::AddNotification Add Notification Widget"));}
    TSubclassOf<UUserWidget> WidgetClass = NotificationWidgetClass;
    if(Data.bUseCustomClass && GetCustomClass(Data.SlotName) != nullptr)
    {
        WidgetClass = GetCustomClass(Data.SlotName);
    }
    UUserWidget* NotificationWidget = CreateWidget<UUserWidget>(GetOwningPlayer(), WidgetClass);
    if(NotificationWidget == nullptr){UE_LOG(LogBaseWidgets ,Error,TEXT("UNotificationManager::AddNotification NotificationWidget null"));return;}
    INotificationInterface* Notification = Cast<INotificationInterface>(NotificationWidget);
    if(Notification == nullptr)
    {
        UE_LOG(LogBaseWidgets, Error, TEXT("UNotificationManager::AddNotification INotificationInterface null"));
        return;
    }
    float Lifetime = NextNotificationTime;
    if(Data.bUseCustomLife)
    {
        Lifetime = Data.LifeDuration;
    }
    Notification->SetLifeDuration(Lifetime);
    Notification->SetNotificationData(Data);
        
    if(Data.bUseSlot && IsValidSlot(Data.SlotName))
    {
        const USlotWidget* SlotWidget = FindSlotByTag(Data.SlotName);
        if(SlotWidget == nullptr){UE_LOG(LogBaseWidgets, Error, TEXT("UNotificationManager::AddNotification Slot %s Doesn't Exist on %s"), *Data.SlotName.ToString(), *GetName())return;}
        SlotWidget->AddWidgetToSlot(NotificationWidget, false);
    }
    else
    {
        NotificationOverlay->AddChildToOverlay(NotificationWidget);
    }
}

AddNotificationToQueue()

void UNotificationManager::AddNotificationToQueue ( const FNotificationData & Data )

overridevirtual

Implements INotificationManagerInterface.

{
    NotificationsQueue.Add(Data);
    GetWorld()->GetTimerManager().ClearTimer(NotificationEndTimerHandle);
    if(bInstant)
    {
        ShowNotifications();
        return;
    }
    if(bIsShowingNotification == false)
    {
        GetWorld()->GetTimerManager().SetTimer(InitialNotificationTimerHandle, this, &UNotificationManager::ShowNotifications, InitialNotificationDelay);
    }
}

FindSlotByTag()

USlotWidget * UNotificationManager::FindSlotByTag ( const FGameplayTag & SlotTag ) const

protected

{
    for(int32 i = 0; i < SlotsOverlay->GetChildrenCount(); ++i)
    {
        if(SlotsOverlay->GetChildAt(i) == nullptr){continue;}
        USlotWidget* SlotWidget = Cast<USlotWidget>(SlotsOverlay->GetChildAt(i));
        if(SlotWidget == nullptr){continue;}
        if(SlotTag == SlotWidget->SlotTag)
        {
            return SlotWidget;
        }
    }
    return nullptr;
}

GetCustomClass()

TSubclassOf< UUserWidget > UNotificationManager::GetCustomClass ( const FGameplayTag & SlotTag )

private

{
    if(SlotWidgetClasses.Find(SlotTag) != nullptr)
    {
        const TSubclassOf<UUserWidget>* WidgetPtr = SlotWidgetClasses.Find(SlotTag);
        return *WidgetPtr;
    }
    return nullptr;
}

GetIsShowingNotification() [1/2]

bool UNotificationManager::GetIsShowingNotification ( ) const

inline

{ return bIsShowingNotification; };

GetIsShowingNotification() [2/2]

bool UNotificationManager::GetIsShowingNotification ( FUniqueID & UniqueID ) const

overridevirtual

Returns if showing a notification and the ID of the one showwing

Implements INotificationManagerInterface.

{
    if(bIsShowingNotification)
    {
        if(CurrentNotification != nullptr)
        {
            UniqueID = CurrentNotification->GetNotificationData().NotificationID;
        }
        else
        {
            return false;
        }
    }
    return bIsShowingNotification;
}

GetSlots()

void UNotificationManager::GetSlots ( )

protected

{
    if(SlotsOverlay == nullptr){return;}
    for(const auto Widget : SlotsOverlay->GetAllChildren())
    {
        USlotWidget* SlotWidget = Cast<USlotWidget>(Widget);
        if(SlotWidget == nullptr){continue;}
        HUDSlots.Add(SlotWidget->SlotTag, SlotWidget);
    }
}

Initialize()

bool UNotificationManager::Initialize ( )

overrideprotectedvirtual

{
    const bool Success = Super::Initialize();
    if(!Success) return false;
    if (!ensure(NotificationOverlay != nullptr)) return false;
    if (!ensure(SlotsOverlay != nullptr)) return false;
 
    return true;
}

IsValidSlot()

bool UNotificationManager::IsValidSlot ( const FGameplayTag & SlotTag ) const

private

{
    const USlotWidget* SlotWidget = FindSlotByTag(SlotTag);
    if(SlotWidget == nullptr){UE_LOG(LogBaseWidgets, Error, TEXT("UNotificationManager::IsValidSlot Slot %s Doesn't Exist on %s"), *SlotTag.ToString(), *GetName());return false;}
    return true;
}

NativeConstruct()

void UNotificationManager::NativeConstruct ( )

overrideprotectedvirtual

{
    Super::NativeConstruct();
    GetSlots();
    if(NotificationWidgetClass == nullptr){UE_LOG(LogBaseWidgets, Error, TEXT("NotificationWidgetClass NUll in UNotificationManager"));}
}

NativePreConstruct()

void UNotificationManager::NativePreConstruct ( )

overrideprotectedvirtual

{
    Super::NativePreConstruct();
    GetSlots();
}

OnShowNotifications()

void UNotificationManager::OnShowNotifications ( )

protected

OnStopNotifications()

void UNotificationManager::OnStopNotifications ( )

protected

ShowNotifications()

void UNotificationManager::ShowNotifications ( )

private

{
    if(NotificationWidgetClass == nullptr){UE_LOG(LogBaseWidgets, Error, TEXT("NotificationWidgetClass NUll in UNotificationManager"));return;}
    OnShowNotifications();
    // bIsShowingNotification = true;
    AddNotification();
}

StopNotifications()

void UNotificationManager::StopNotifications ( )

private

{
    if(bDebuggingMode){UE_LOG(LogBaseWidgets ,Warning,TEXT("Stop Notifications"));}
    OnStopNotifications();
    if(NotificationOverlay != nullptr)
    {
        NotificationOverlay->ClearChildren();
    }
    NotificationsQueue.Empty();
    bIsShowingNotification = false;
}

UpdateValue()

void UNotificationManager::UpdateValue ( const int32 IncreaseAmount, const int32 TotalValue, const FGameplayTag & HUDSlot )

overridevirtual

Implements INotificationManagerInterface.

{
    //@TODO UpdateValue , Maybe Change Vars to be able to just be A seperate Value
}

Member Data Documentation

bDebuggingMode

bool UNotificationManager::bDebuggingMode = false

protected

bInstant

bool UNotificationManager::bInstant = false

protected

bIsShowingNotification

bool UNotificationManager::bIsShowingNotification = false

private

bMultipleAtOnce

bool UNotificationManager::bMultipleAtOnce = true

protected

CurrentIndex

int32 UNotificationManager::CurrentIndex = 0

private

CurrentNotification

INotificationInterface* UNotificationManager::CurrentNotification = nullptr

private

EndNotificationDelay

float UNotificationManager::EndNotificationDelay = 5.0f

protected

HUDSlots

TMap<FGameplayTag, USlotWidget*> UNotificationManager::HUDSlots

protected

InitialNotificationDelay

float UNotificationManager::InitialNotificationDelay = 3.0f

protected

InitialNotificationTimerHandle

FTimerHandle UNotificationManager::InitialNotificationTimerHandle

private

NextNotificationTime

float UNotificationManager::NextNotificationTime = 3.0f

protected

NotificationEndTimerHandle

FTimerHandle UNotificationManager::NotificationEndTimerHandle

private

NotificationOverlay

class UOverlay* UNotificationManager::NotificationOverlay = nullptr

protected

NotificationsQueue

TArray<FNotificationData> UNotificationManager::NotificationsQueue

protected

NotificationTimerHandle

FTimerHandle UNotificationManager::NotificationTimerHandle

private

NotificationWidgetClass

TSubclassOf<UUserWidget> UNotificationManager::NotificationWidgetClass

private

SlotsOverlay

class UOverlay* UNotificationManager::SlotsOverlay = nullptr

protected

SlotWidgetClasses

TMap<FGameplayTag, TSubclassOf<UUserWidget> > UNotificationManager::SlotWidgetClasses

protected

---

The documentation for this class was generated from the following files:

• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Public/Widgets/NotificationManager.h
• T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Plugins/BaseHelpers/Source/BaseHelpers/Private/Widgets/NotificationManager.cpp