UToastRootHUDWidget 클래스 참조

#include <ToastRootHUDWidget.h>

UToastRootHUDWidget에 대한 상속 다이어그램 :

UToastRootHUDWidget에 대한 협력 다이어그램:

Public 멤버 함수
bool	ShowToastByID (const int32 ToastID, const bool bApplyImmediately=false)
bool	ShowToastByRowName (const FName ToastRowName, const bool bApplyImmediately=false)
void	ShowToast (const FDT_ToastMessageTable &InToastData, const bool bApplyImmediately=false)
void	SetToastDataTable (UDataTable *InToastDataTable)
UDataTable *	GetToastDataTable () const
UStageEventListenableUserWidget(으)로부터 상속된 Public 멤버 함수
virtual EEventListenableUI	GetListeningUIEvent ()
virtual UUIEventProxy *	GetEventProxy () const
UUserWidgetBase(으)로부터 상속된 Public 멤버 함수
virtual void	SetAbilitySystemComponent (AActor *InOwner)
virtual UAbilitySystemComponent *	GetAbilitySystemComponent () const override
virtual void	OnActivated ()
virtual void	OnDeactivated ()
void	Activate ()
void	Deactivate ()
FORCEINLINE FGameplayTag	GetLayerTag () const
FORCEINLINE void	SetLayerTag (const FGameplayTag InTag)
FORCEINLINE bool	IsPrimary () const
FORCEINLINE void	SetPrimary (const bool InPrimary)
FORCEINLINE EWidgetState	GetWidgetState () const
FORCEINLINE void	SetWidgetState (const EWidgetState InState)
FORCEINLINE UWaitForWidgetActivation *	GetActivationHandle ()
FORCEINLINE bool	HasAppearanceAnim () const
FORCEINLINE bool	HasDisappearanceAnim () const

Protected 멤버 함수
virtual void	NativeDestruct () override
bool	CanAddToastWidget () const
void	EnqueueToast (const FDT_ToastMessageTable &InToastData)
void	ProcessPendingToastQueue ()
void	ShowToastInternal (const FDT_ToastMessageTable &InToastData)
void	AddToastWidget (UToastWidgetBase *ToastWidget, const FDT_ToastMessageTable &InToastData)
bool	TryUpdateActiveToastByGroup (const FDT_ToastMessageTable &InToastData)
void	RequestOldestToastExit ()
void	StartToastDurationTimer (UToastWidgetBase *ToastWidget, const float ToastDuration)
void	RequestToastExit (UToastWidgetBase *ToastWidget)
void	RemoveToastWidget (UToastWidgetBase *ToastWidget)
bool	TryShowNextToastInGroup (UToastWidgetBase *ToastWidget)
const FDT_ToastMessageTable *	FindNextToastRowInGroup (const FDT_ToastMessageTable &CurrentToastData)
UToastWidgetBase *	CreateToastWidget (const FDT_ToastMessageTable &InToastData)
int32	FindActiveToastIndex (const UToastWidgetBase *ToastWidget) const
int32	FindActiveToastIndexByGroupID (const int32 GroupID) const
UDataTable *	ResolveToastDataTable ()
void	OnToastRequested (const FDT_ToastMessageTable &InToastData)
UStageEventListenableUserWidget(으)로부터 상속된 Protected 멤버 함수
virtual void	OnPushedToLayer () override
virtual void	OnPoppedFromLayer () override
UUserWidgetBase(으)로부터 상속된 Protected 멤버 함수
virtual void	OnWidgetActivated ()
virtual void	OnWidgetDeactivated ()
void	OnPushedToLayer_Internal ()
void	OnPoppedFromLayer_Internal ()
void	OnActivated_Internal ()
void	OnDeactivated_Internal ()

Protected 속성
TSubclassOf< UToastWidgetBase >	ToastWidgetClass
int32	MaxStackCount = 3
TObjectPtr< UDataTable >	CachedToastDataTable
TObjectPtr< UStackBox >	ToastMessageStack
TArray< FActiveToastWidgetEntry >	ActiveToastWidgets
TArray< FPendingToastWidgetEntry >	PendingToastWidgets
int32	ExitingToastCount = 0
UStageEventListenableUserWidget(으)로부터 상속된 Protected 속성
TObjectPtr< UUIEventProxy >	EventProxy
UUserWidgetBase(으)로부터 상속된 Protected 속성
EWidgetState	WidgetState
TObjectPtr< UAbilitySystemComponent >	ASC
FGameplayTag	LayerTag
bool	bPrimary = false
TObjectPtr< UWidgetAnimation >	AppearanceAnim
TObjectPtr< UWidgetAnimation >	DisappearanceAnim

멤버 함수 문서화

AddToastWidget()

void UToastRootHUDWidget::AddToastWidget ( UToastWidgetBase *  ToastWidget, const FDT_ToastMessageTable &  InToastData  )

protected

{
    if (IsValid(ToastWidget) == false)
    {
        return;
    }
 
    if (IsValid(ToastMessageStack) == false)
    {
        LOG_ERROR(LogCK, "%s 바인딩이 없습니다.", NAMEOF_VAR(ToastMessageStack));
        return;
    }
 
    ToastMessageStack->AddChild(ToastWidget);
 
    FActiveToastWidgetEntry ActiveToastWidget;
    ActiveToastWidget.ToastWidget = ToastWidget;
    ActiveToastWidget.GroupID = InToastData.Group_ID;
    ActiveToastWidgets.Add(ActiveToastWidget);
 
    ToastWidget->PlayEnterToastAnimation();
    StartToastDurationTimer(ToastWidget, InToastData.Toast_Duration);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

CanAddToastWidget()

bool UToastRootHUDWidget::CanAddToastWidget ( ) const

protected

{
    const int32 EffectiveMaxStackCount = FMath::Max(1, MaxStackCount);
    return ActiveToastWidgets.Num() + ExitingToastCount < EffectiveMaxStackCount;
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

CreateToastWidget()

UToastWidgetBase * UToastRootHUDWidget::CreateToastWidget ( const FDT_ToastMessageTable &  InToastData )

protected

{
    if (IsValid(ToastMessageStack) == false)
    {
        LOG_ERROR(LogCK, "%s 바인딩이 없습니다.", NAMEOF_VAR(ToastMessageStack));
        return nullptr;
    }
 
    if (ToastWidgetClass == nullptr)
    {
        LOG_ERROR(LogCK, "%s 설정이 없습니다.", NAMEOF_VAR(ToastWidgetClass));
        return nullptr;
    }
 
    UToastWidgetBase* ToastWidget = CreateWidget<UToastWidgetBase>(GetOwningPlayer(), ToastWidgetClass);
    if (IsValid(ToastWidget) == false)
    {
        LOG_ERROR(LogCK, "ToastWidget 생성에 실패했습니다.");
        return nullptr;
    }
 
    ToastWidget->SetupToast(InToastData);
    return ToastWidget;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

EnqueueToast()

void UToastRootHUDWidget::EnqueueToast ( const FDT_ToastMessageTable &  InToastData )

protected

{
    FPendingToastWidgetEntry PendingToastWidget;
    PendingToastWidget.ToastData = InToastData;
    PendingToastWidgets.Add(PendingToastWidget);
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

FindActiveToastIndex()

int32 UToastRootHUDWidget::FindActiveToastIndex ( const UToastWidgetBase *  ToastWidget ) const

protected

{
    if (ToastWidget == nullptr)
    {
        return INDEX_NONE;
    }
 
    return ActiveToastWidgets.IndexOfByPredicate([&ToastWidget](auto ActiveToastWidget)
    {
        return ActiveToastWidget.ToastWidget == ToastWidget;
    });
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

FindActiveToastIndexByGroupID()

int32 UToastRootHUDWidget::FindActiveToastIndexByGroupID ( const int32  GroupID ) const

protected

{
    return ActiveToastWidgets.IndexOfByPredicate([GroupID](const FActiveToastWidgetEntry& ActiveToastWidget)
    {
        return ActiveToastWidget.GroupID == GroupID;
    });
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

FindNextToastRowInGroup()

const FDT_ToastMessageTable * UToastRootHUDWidget::FindNextToastRowInGroup ( const FDT_ToastMessageTable &  CurrentToastData )

protected

{
    const UDataTable* ToastDataTable = ResolveToastDataTable();
 
    if (IsValid(ToastDataTable) == false)
    {
        return nullptr;
    }
 
    const TArray<FName> RowNames = ToastDataTable->GetRowNames();
    const FName CurrentRowName = FName(*FString::FromInt(CurrentToastData.Toast_ID));
    const int32 CurrentRowIndex = RowNames.IndexOfByKey(CurrentRowName);
 
    if (CurrentRowIndex == INDEX_NONE || RowNames.IsValidIndex(CurrentRowIndex + 1) == false)
    {
        return nullptr;
    }
 
    const FString ContextString = FString::Printf(TEXT("%s::FindNextToastRowInGroup"), TEXT("UToastRootHUDWidget"));
    const FDT_ToastMessageTable* NextToastData = ToastDataTable->FindRow<FDT_ToastMessageTable>(RowNames[CurrentRowIndex + 1], *ContextString);
 
    if (NextToastData == nullptr)
    {
        return nullptr;
    }
 
    if (NextToastData->Group_ID != CurrentToastData.Group_ID)
    {
        return nullptr;
    }
 
    return NextToastData;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

GetToastDataTable()

UDataTable * UToastRootHUDWidget::GetToastDataTable

(

)

const

{
    return CachedToastDataTable;
}

NativeDestruct()

void UToastRootHUDWidget::NativeDestruct ( )

overrideprotectedvirtual

{
    UWorld* World = GetWorld();
    check(World);
 
    for (FActiveToastWidgetEntry& ActiveToastWidget : ActiveToastWidgets)
    {
        World->GetTimerManager().ClearTimer(ActiveToastWidget.DurationTimerHandle);
    }
 
    ActiveToastWidgets.Empty();
    PendingToastWidgets.Empty();
    ExitingToastCount = 0;
    Super::NativeDestruct();
}

OnToastRequested()

void UToastRootHUDWidget::OnToastRequested ( const FDT_ToastMessageTable &  InToastData )

protected

ProcessPendingToastQueue()

void UToastRootHUDWidget::ProcessPendingToastQueue ( )

protected

{
    while (PendingToastWidgets.IsEmpty() == false)
    {
        const FDT_ToastMessageTable ToastData = PendingToastWidgets[0].ToastData;
 
        if (TryUpdateActiveToastByGroup(ToastData))
        {
            PendingToastWidgets.RemoveAt(0);
            continue;
        }
 
        if (CanAddToastWidget() == false)
        {
            if (ExitingToastCount <= 0)
            {
                RequestOldestToastExit();
            }
 
            return;
        }
 
        PendingToastWidgets.RemoveAt(0);
        ShowToastInternal(ToastData);
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

RemoveToastWidget()

void UToastRootHUDWidget::RemoveToastWidget ( UToastWidgetBase *  ToastWidget )

protected

{
    if (IsValid(ToastWidget))
    {
        ToastWidget->RemoveFromParent();
    }
 
    ExitingToastCount = FMath::Max(0, ExitingToastCount - 1);
    ProcessPendingToastQueue();
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

RequestOldestToastExit()

void UToastRootHUDWidget::RequestOldestToastExit ( )

protected

{
    if (ActiveToastWidgets.IsEmpty())
    {
        return;
    }
 
    RequestToastExit(ActiveToastWidgets[0].ToastWidget);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

RequestToastExit()

void UToastRootHUDWidget::RequestToastExit ( UToastWidgetBase *  ToastWidget )

protected

{
    const int32 ActiveToastIndex = FindActiveToastIndex(ToastWidget);
 
    if (ActiveToastIndex == INDEX_NONE)
    {
        return;
    }
 
    const UWorld* World = GetWorld();
 
    if (World)
    {
        World->GetTimerManager().ClearTimer(ActiveToastWidgets[ActiveToastIndex].DurationTimerHandle);
    }
 
    UToastWidgetBase* ExitingToastWidget = ActiveToastWidgets[ActiveToastIndex].ToastWidget;
    ActiveToastWidgets.RemoveAt(ActiveToastIndex);
 
    if (IsValid(ExitingToastWidget) == false)
    {
        ProcessPendingToastQueue();
        return;
    }
 
    ++ExitingToastCount;
    ExitingToastWidget->PlayExitToastAnimation();
 
    const float ExitDuration = FMath::Max(0.0f, ExitingToastWidget->GetExitAnimationDuration());
 
    if (World == nullptr || ExitDuration < KINDA_SMALL_NUMBER)
    {
        RemoveToastWidget(ExitingToastWidget);
        return;
    }
 
    TWeakObjectPtr<UToastRootHUDWidget> WeakThis(this);
    TWeakObjectPtr<UToastWidgetBase> WeakToastWidget(ExitingToastWidget);
 
    FTimerDelegate TimerDelegate;
 
    TimerDelegate.BindLambda([WeakThis, WeakToastWidget]()
    {
        if (WeakThis.IsValid() == false || WeakToastWidget.IsValid() == false)
        {
            return;
        }
 
        WeakThis->RemoveToastWidget(WeakToastWidget.Get());
    });
 
    FTimerHandle RemoveTimerHandle;
    World->GetTimerManager().SetTimer(RemoveTimerHandle, TimerDelegate, ExitDuration, false);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ResolveToastDataTable()

UDataTable * UToastRootHUDWidget::ResolveToastDataTable ( )

protected

{
    if (IsValid(CachedToastDataTable))
    {
        return CachedToastDataTable;
    }
 
    CachedToastDataTable = GetEnvironmentAssetByKey<UDataTable>("ToastMessageData");
    return CachedToastDataTable;
}

이 함수를 호출하는 함수들에 대한 그래프입니다.:

SetToastDataTable()

void UToastRootHUDWidget::SetToastDataTable

(

UDataTable *

InToastDataTable

)

{
    CachedToastDataTable = InToastDataTable;
}

ShowToast()

void UToastRootHUDWidget::ShowToast	(	const FDT_ToastMessageTable &	InToastData,
		const bool	bApplyImmediately = false
	)

{
    if (bApplyImmediately)
    {
        PendingToastWidgets.Empty();
    }
 
    if (TryUpdateActiveToastByGroup(InToastData))
    {
        return;
    }
 
    if (CanAddToastWidget())
    {
        ShowToastInternal(InToastData);
        return;
    }
 
    EnqueueToast(InToastData);
 
    if (ExitingToastCount <= 0)
    {
        RequestOldestToastExit();
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ShowToastByID()

bool UToastRootHUDWidget::ShowToastByID	(	const int32	ToastID,
		const bool	bApplyImmediately = false
	)

{
    if (ToastID <= 0)
    {
        LOG_WARNING(LogCK, "유효하지 않은 ToastID입니다. ToastID: %d", ToastID);
        return false;
    }
 
    if (ShowToastByRowName(FName(*FString::FromInt(ToastID)), bApplyImmediately))
    {
        return true;
    }
    else
    {
        return false;
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

ShowToastByRowName()

bool UToastRootHUDWidget::ShowToastByRowName	(	const FName	ToastRowName,
		const bool	bApplyImmediately = false
	)

{
    if (ToastRowName.IsNone())
    {
        LOG_WARNING(LogCK, "ToastRowName이 비어있습니다.");
        return false;
    }
 
    const UDataTable* ToastDataTable = ResolveToastDataTable();
 
    if (IsValid(ToastDataTable) == false)
    {
        LOG_WARNING(LogCK, "ToastDataTable을 찾을 수 없습니다.");
        return false;
    }
 
    const FString ContextString = FString::Printf(TEXT("%s::ShowToastByRowName"), TEXT("UToastRootHUDWidget"));
    const FDT_ToastMessageTable* RowData = ToastDataTable->FindRow<FDT_ToastMessageTable>(ToastRowName, *ContextString);
 
    if (RowData == nullptr)
    {
        LOG_WARNING(LogCK, "Toast row를 찾을 수 없습니다. RowName: %s", *ToastRowName.ToString());
        return false;
    }
    else
    {
        ShowToast(*RowData, bApplyImmediately);
        return true;
    }
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

ShowToastInternal()

void UToastRootHUDWidget::ShowToastInternal ( const FDT_ToastMessageTable &  InToastData )

protected

{
    if (CanAddToastWidget() == false)
    {
        EnqueueToast(InToastData);
 
        if (ExitingToastCount <= 0)
        {
            RequestOldestToastExit();
        }
 
        return;
    }
 
    UToastWidgetBase* ToastWidget = CreateToastWidget(InToastData);
 
    if (IsValid(ToastWidget) == false)
    {
        LOG_ERROR(LogCK, "%s가 유효하지 않습니다. ", NAMEOF_VAR(ToastWidget));
        return;
    }
 
    AddToastWidget(ToastWidget, InToastData);
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

StartToastDurationTimer()

void UToastRootHUDWidget::StartToastDurationTimer ( UToastWidgetBase *  ToastWidget, const float  ToastDuration  )

protected

{
    const int32 ActiveToastIndex = FindActiveToastIndex(ToastWidget);
 
    if (ActiveToastIndex == INDEX_NONE)
    {
        return;
    }
 
    const UWorld* World = GetWorld();
    check(World);
 
    World->GetTimerManager().ClearTimer(ActiveToastWidgets[ActiveToastIndex].DurationTimerHandle);
 
    const float ValidToastDuration = FMath::Max(0.0f, ToastDuration);
 
    if (ValidToastDuration < KINDA_SMALL_NUMBER)
    {
        if (TryShowNextToastInGroup(ToastWidget))
        {
            return;
        }
 
        RequestToastExit(ToastWidget);
        return;
    }
 
    TWeakObjectPtr<UToastRootHUDWidget> WeakThis(this);
    TWeakObjectPtr<UToastWidgetBase> WeakToastWidget(ToastWidget);
 
    FTimerDelegate TimerDelegate;
 
    TimerDelegate.BindLambda([WeakThis, WeakToastWidget]()
    {
        if (WeakThis.IsValid() == false || WeakToastWidget.IsValid() == false)
        {
            return;
        }
 
        if (WeakThis->TryShowNextToastInGroup(WeakToastWidget.Get()))
        {
            return;
        }
 
        WeakThis->RequestToastExit(WeakToastWidget.Get());
    });
 
    World->GetTimerManager().SetTimer
    (
        ActiveToastWidgets[ActiveToastIndex].DurationTimerHandle,
        TimerDelegate,
        ValidToastDuration,
        false
    );
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

TryShowNextToastInGroup()

bool UToastRootHUDWidget::TryShowNextToastInGroup ( UToastWidgetBase *  ToastWidget )

protected

{
    const int32 ActiveToastIndex = FindActiveToastIndex(ToastWidget);
 
    if (ActiveToastIndex == INDEX_NONE)
    {
        return false;
    }
 
    if (IsValid(ToastWidget) == false)
    {
        return false;
    }
 
    const FDT_ToastMessageTable CurrentToastData = ToastWidget->GetToastData();
    const FDT_ToastMessageTable* NextToastData = FindNextToastRowInGroup(CurrentToastData);
 
    if (NextToastData == nullptr)
    {
        return false;
    }
 
    ToastWidget->QueueNextToastData(*NextToastData);
    ToastWidget->PlayPingPongToastAnimation();
    StartToastDurationTimer(ToastWidget, NextToastData->Toast_Duration);
    return true;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

TryUpdateActiveToastByGroup()

bool UToastRootHUDWidget::TryUpdateActiveToastByGroup ( const FDT_ToastMessageTable &  InToastData )

protected

{
    const int32 ActiveToastIndex = FindActiveToastIndexByGroupID(InToastData.Group_ID);
 
    if (ActiveToastIndex == INDEX_NONE)
    {
        return false;
    }
 
    UToastWidgetBase* ToastWidget = ActiveToastWidgets[ActiveToastIndex].ToastWidget;
 
    if (IsValid(ToastWidget) == false)
    {
        const UWorld* World = GetWorld();
 
        if (World)
        {
            World->GetTimerManager().ClearTimer(ActiveToastWidgets[ActiveToastIndex].DurationTimerHandle);
        }
 
        ActiveToastWidgets.RemoveAt(ActiveToastIndex);
        return false;
    }
 
    ToastWidget->QueueNextToastData(InToastData);
    ToastWidget->PlayPingPongToastAnimation();
    StartToastDurationTimer(ToastWidget, InToastData.Toast_Duration);
    return true;
}

이 함수 내부에서 호출하는 함수들에 대한 그래프입니다.:

이 함수를 호출하는 함수들에 대한 그래프입니다.:

멤버 데이터 문서화

ActiveToastWidgets

TArray<FActiveToastWidgetEntry> UToastRootHUDWidget::ActiveToastWidgets

protected

CachedToastDataTable

TObjectPtr<UDataTable> UToastRootHUDWidget::CachedToastDataTable

protected

ExitingToastCount

int32 UToastRootHUDWidget::ExitingToastCount = 0

protected

MaxStackCount

int32 UToastRootHUDWidget::MaxStackCount = 3

protected

PendingToastWidgets

TArray<FPendingToastWidgetEntry> UToastRootHUDWidget::PendingToastWidgets

protected

ToastMessageStack

TObjectPtr<UStackBox> UToastRootHUDWidget::ToastMessageStack

protected

ToastWidgetClass

TSubclassOf<UToastWidgetBase> UToastRootHUDWidget::ToastWidgetClass

protected

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• Source/CK_UE/UI/HUD/Toast/ToastRootHUDWidget.h
• Source/CK_UE/UI/HUD/Toast/ToastRootHUDWidget.cpp