ULayerWidget Class Reference

#include <LayerWidget.h>

Inheritance diagram for ULayerWidget:

Public Member Functions
	ULayerWidget ()
virtual UUserWidget *	PushWidget (const TSoftClassPtr< UUserWidget > &WidgetClass) override
virtual void	PopWidget () override
virtual void	ClearStack () override
virtual UUserWidget *	AddWidgetToLayer (const TSoftClassPtr< UUserWidget > &WidgetClass) override
virtual UUserWidget *	GetContentFromLayer (const TSoftClassPtr< UUserWidget > &WidgetClass) override
virtual bool	ToggleWidget (UUserWidget *Widget) override
virtual UUserWidget *	AddWidgetToLayerWithSlot (const FGameplayTag &SlotTag, const TSoftClassPtr< UUserWidget > &WidgetClass) override
void	CollapseTopWidget ()
void	ShowTopWidget ()
FText	GetStackListNames () const
void	GetSlots ()

Protected Member Functions
virtual bool	Initialize () override
virtual void	NativePreConstruct () override
virtual void	NativeConstruct () override
UUserWidget *	GetTopWidget () const
USlotWidget *	FindSlotByTag (const FGameplayTag &SlotTag) const

Protected Attributes
TArray< UUserWidget * >	Stack
TArray< UUserWidget * >	BackStack
class UBorder *	Border = nullptr
class UWidgetSwitcher *	Switcher = nullptr
class UOverlay *	EmptyOverlay = nullptr
class UOverlay *	BackOverlay = nullptr
class UOverlay *	SlotsOverlay = nullptr
TMap< FGameplayTag, USlotWidget * >	HUDSlots

Constructor & Destructor Documentation

ULayerWidget()

ULayerWidget::ULayerWidget

(

)

{
    
}

Member Function Documentation

AddWidgetToLayer()

UUserWidget * ULayerWidget::AddWidgetToLayer ( const TSoftClassPtr< UUserWidget > & WidgetClass )

overridevirtual

Implements IWidgetLayout.

{
    UClass* LoadedClass = UKismetSystemLibrary::LoadClassAsset_Blocking(WidgetClass);
    if(LoadedClass == nullptr || !LoadedClass->IsChildOf(UUserWidget::StaticClass())){return nullptr;}
    const TSubclassOf<UUserWidget> LoadedWidgetClass = LoadedClass;
    if(LoadedWidgetClass == nullptr){return nullptr;}
    UUserWidget* CreatedWidget = CreateWidget(GetOwningPlayer(), LoadedWidgetClass);
    BackStack.Add(CreatedWidget);
    BackOverlay->AddChild(CreatedWidget);
    UOverlaySlot* OverlaySlot = Cast<UOverlaySlot>(CreatedWidget->Slot);
    if(OverlaySlot != nullptr)
    {
        OverlaySlot->SetHorizontalAlignment(HAlign_Fill);
        OverlaySlot->SetVerticalAlignment(VAlign_Fill);
    }
    else
    {
        UE_LOG(LogBaseWidgets, Warning, TEXT("Widget Slot Failed %s"), *WidgetClass->GetName());
    }
    return CreatedWidget;
}

AddWidgetToLayerWithSlot()

UUserWidget * ULayerWidget::AddWidgetToLayerWithSlot ( const FGameplayTag & SlotTag, const TSoftClassPtr< UUserWidget > & WidgetClass )

overridevirtual

Implements IWidgetLayout.

{
    UClass* LoadedClass = UKismetSystemLibrary::LoadClassAsset_Blocking(WidgetClass);
    if(LoadedClass == nullptr || !LoadedClass->IsChildOf(UUserWidget::StaticClass())){return nullptr;}
    const TSubclassOf<UUserWidget> LoadedWidgetClass = LoadedClass;
    if(LoadedWidgetClass == nullptr){return nullptr;}
    UUserWidget* CreatedWidget = CreateWidget(GetOwningPlayer(), LoadedWidgetClass);
    if(CreatedWidget == nullptr){UE_LOG(LogTemp, Error, TEXT("ULayerWidget::AddWidgetToLayerWithSlot Created Widget FAILED "))return nullptr;}
    BackStack.Add(CreatedWidget);
    const USlotWidget* SlotWidget = FindSlotByTag(SlotTag);
    if(SlotWidget == nullptr){UE_LOG(LogBaseWidgets, Error, TEXT("ULayerWidget::AddWidgetToLayerWithSlot Slot %s Doesn't Exist on %s"), *SlotTag.ToString(), *GetName())return nullptr;}
    SlotWidget->AddWidgetToSlot(CreatedWidget, false);
    // UE_LOG(LogTemp, Warning, TEXT("ULayerWidget::AddWidgetToLayerWithSlot WIDGET %s ADDED TO SLOT %s in ULayerWidget"), *CreatedWidget->GetName(), *SlotTag.GetTagName().ToString())
    return CreatedWidget;
}

ClearStack()

void ULayerWidget::ClearStack ( )

overridevirtual

Implements IWidgetLayout.

{
    for(const auto Widget : Stack)
    {
        if(Widget == nullptr){continue;}
        Widget->RemoveFromParent();
    }
    Stack.Empty();
    Border->ClearChildren();
}

CollapseTopWidget()

void ULayerWidget::CollapseTopWidget

(

)

{
    if(Stack.Num() == 0 || GetTopWidget() == nullptr){UE_LOG(LogBaseWidgets,Error, TEXT("Top Widget Invalid ULayerWidget::CollapseTopWidget"));return;}
    GetTopWidget()->SetVisibility(ESlateVisibility::Collapsed);
}

FindSlotByTag()

USlotWidget * ULayerWidget::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;
}

GetContentFromLayer()

UUserWidget * ULayerWidget::GetContentFromLayer ( const TSoftClassPtr< UUserWidget > & WidgetClass )

overridevirtual

Get the Widget that was already created by class

Implements IWidgetLayout.

{
    UClass* LoadedClass = UKismetSystemLibrary::LoadClassAsset_Blocking(WidgetClass);
    if(LoadedClass == nullptr || !LoadedClass->IsChildOf(UUserWidget::StaticClass())){return nullptr;}
    const TSubclassOf<UUserWidget> LoadedWidgetClass = LoadedClass;
    if(LoadedWidgetClass == nullptr){return nullptr;}
    for(const auto Widget : BackStack)
    {
        if(Widget == nullptr){continue;}
        if(Widget->GetClass() == LoadedWidgetClass)
        {
            return Widget;
        }
    }
    return nullptr;
}

GetSlots()

void ULayerWidget::GetSlots

(

)

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

GetStackListNames()

FText ULayerWidget::GetStackListNames

(

)

const

{
    TArray<FString> Names;
    for (int32 i = Stack.Num() - 1; i >= 0; --i)
    {
        if(Stack[i] == nullptr){continue;}
        Names.Add(UKismetSystemLibrary::GetDisplayName(Stack[i]));
    }
    return FText::FromString(UKismetStringLibrary::JoinStringArray(Names, "\n"));
}

GetTopWidget()

UUserWidget * ULayerWidget::GetTopWidget ( ) const

protected

{
    const int32 ArraySize = Stack.Num();
    const int32 LastIndex = (ArraySize > 0) ? ArraySize-1 : 0;
    if(Stack.IsValidIndex(LastIndex))
    {
        return Stack[LastIndex];
    }
    return nullptr;
}

Initialize()

bool ULayerWidget::Initialize ( )

overrideprotectedvirtual

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

NativeConstruct()

void ULayerWidget::NativeConstruct ( )

overrideprotectedvirtual

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

NativePreConstruct()

void ULayerWidget::NativePreConstruct ( )

overrideprotectedvirtual

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

PopWidget()

void ULayerWidget::PopWidget ( )

overridevirtual

Implements IWidgetLayout.

{
    UUserWidget* TopWidget = GetTopWidget();
    if(TopWidget == nullptr){UE_LOG(LogBaseWidgets,Error, TEXT("Top Widget Invalid ULayerWidget::PopWidget"));return;}
    TopWidget->RemoveFromParent();
    Stack.Remove(TopWidget);
    Border->ClearChildren();
    TopWidget = GetTopWidget();
    if(TopWidget == nullptr){UE_LOG(LogBaseWidgets,Error, TEXT("2nd Top Widget Invalid ULayerWidget::PopWidget"));return;}
    TopWidget->SetVisibility(ESlateVisibility::HitTestInvisible);
    Border->AddChild(TopWidget);
}

PushWidget()

UUserWidget * ULayerWidget::PushWidget ( const TSoftClassPtr< UUserWidget > & WidgetClass )

overridevirtual

Implements IWidgetLayout.

{
    UClass* LoadedClass = UKismetSystemLibrary::LoadClassAsset_Blocking(WidgetClass);
    if(LoadedClass == nullptr || !LoadedClass->IsChildOf(UUserWidget::StaticClass())){return nullptr;}
    const TSubclassOf<UUserWidget> LoadedWidgetClass = LoadedClass;
    if(LoadedWidgetClass == nullptr){return nullptr;}
    UUserWidget* CreatedWidget = CreateWidget(GetOwningPlayer(), LoadedWidgetClass);
    CollapseTopWidget();
    Border->ClearChildren();
    Stack.Add(CreatedWidget);
    Border->AddChild(CreatedWidget);
    ShowTopWidget();
    return CreatedWidget;
}

ShowTopWidget()

void ULayerWidget::ShowTopWidget

(

)

{
    if(GetTopWidget() == nullptr){UE_LOG(LogBaseWidgets,Error, TEXT("Top Widget Invalid ULayerWidget::ShowTopWidget"));return;}
    GetTopWidget()->SetVisibility(ESlateVisibility::HitTestInvisible);
}

ToggleWidget()

bool ULayerWidget::ToggleWidget ( UUserWidget * Widget )

overridevirtual

Implements IWidgetLayout.

{
    if(Widget == nullptr){UE_LOG(LogBaseWidgets, Error, TEXT("ULayerWidget::ToggleWidget Widget null"));return false;}
    if (Widget->IsVisible())
    {
        Widget->SetVisibility(ESlateVisibility::Collapsed);
        return false;
    }
    // else
    // {
        Widget->SetVisibility(ESlateVisibility::Visible);
        return true;
    // }
    // if(Stack.Contains(Widget) == false)
    // {
    //  UE_LOG(LogBaseWidgets, Error, TEXT("ULayerWidget::ToggleWidget %s Doesn't Exist On Layer"), *Widget->GetName())return false;
    // }
    // if(Switcher == nullptr || EmptyOverlay == nullptr){return false;}
    // if(Switcher->GetActiveWidget() == Widget)
    // {
    //  Switcher->SetActiveWidget(EmptyOverlay);
    // }
    // else
    // {
    //  Switcher->SetActiveWidget(Widget);
    // }
    // return true;
}

Member Data Documentation

BackOverlay

class UOverlay* ULayerWidget::BackOverlay = nullptr

protected

BackStack

TArray<UUserWidget*> ULayerWidget::BackStack

protected

Border

class UBorder* ULayerWidget::Border = nullptr

protected

EmptyOverlay

class UOverlay* ULayerWidget::EmptyOverlay = nullptr

protected

HUDSlots

TMap<FGameplayTag, USlotWidget*> ULayerWidget::HUDSlots

protected

SlotsOverlay

class UOverlay* ULayerWidget::SlotsOverlay = nullptr

protected

Stack

TArray<UUserWidget*> ULayerWidget::Stack

protected

Switcher

class UWidgetSwitcher* ULayerWidget::Switcher = nullptr

protected

---

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

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