ButtonWidget.cpp

Go to the documentation of this file.

// Copyright(c) Pixo Group. All Rights Reserved.
 
#include "UI/ButtonWidget.h"
 
#include "Blueprint/WidgetTree.h"
#include "Components/TextBlock.h"
#include "GameFramework/GameModeBase.h"
#include "Interfaces/PixoCoreInterface.h"
#include "Kismet/GameplayStatics.h"
#include "Managers/HintManager.h"
#include "Story/StoryComponent.h"
 
#if WITH_EDITOR
void UButtonWidget::PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent)
{
    Super::PostEditChangeChainProperty(PropertyChangedEvent);
 
    RefreshWidgetStyle();
}
#endif // WITH_EDITOR
 
void UButtonWidget::NativeOnInitialized()
{
    Super::NativeOnInitialized();
 
    bCurrentState = false;
 
    ensure(ButtonHighlight);
    ensure(ButtonBounds);
    ensure(Button);
    ensure(BtnName);
 
    RefreshWidgetStyle();
 
    AGameModeBase* GameModeBase = GetWorld()->GetAuthGameMode();
    if (GameModeBase->GetClass()->ImplementsInterface(UPixoCoreInterface::StaticClass()))
    {
        HintManager = Cast<UHintManager>(
            IPixoCoreInterface::Execute_GetManagerRef(GameModeBase, UHintManager::StaticClass()));
        if (HintManager)
        {
            HintManager->OnHintActivated.AddDynamic(this, &UButtonWidget::OnHintActivated);
        }
 
        StoryManager = Cast<UStoryManager>(
            IPixoCoreInterface::Execute_GetManagerRef(GameModeBase, UStoryManager::StaticClass()));
        if (StoryManager)
        {
            StoryManager->OnNewStep.AddDynamic(this, &UButtonWidget::NewStep);
            StoryManager->OnNewSubStep.AddDynamic(this, &UButtonWidget::NewSubStep);
            StoryManager->OnStoryLoaded.AddDynamic(this, &UButtonWidget::StoryLoaded);
 
            NewStep(StoryManager->CurrentStep, false);
        }
    }
    else
    {
        UE_LOG(LogTemp, Error, TEXT("GameModeBase doesn't implement IPixoCoreInterface"));
    }
 
    Button->OnReleased.AddDynamic(this, &UButtonWidget::ButtonReleased);
    Button->OnHovered.AddDynamic(this, &UButtonWidget::ButtonHovered);
    Button->OnUnhovered.AddDynamic(this, &UButtonWidget::OnUnHovered);
    Button->OnPressed.AddDynamic(this, &UButtonWidget::OnPressed);
 
    Type = ButtonType::BT_None;
}
 
void UButtonWidget::NativePreConstruct()
{
    Super::NativePreConstruct();
 
    RefreshWidgetStyle();
}
 
void UButtonWidget::SetButtonName(const FText& Name)
{
    this->ButtonName = Name;
    BtnName->SetText(ButtonName);
}
 
const FText& UButtonWidget::GetButtonName()
{
    return this->ButtonName;
}
 
void UButtonWidget::ChangeButtonState(const bool bState)
{
    bCurrentState = bState;
    SwitchButtonColor(bCurrentState);
}
 
void UButtonWidget::SwitchButtonColor(const bool bState)
{
    Button->SetBackgroundColor(bIsSelectable && bState ? SelectedButtonColor : DefaultButtonColor);
}
 
void UButtonWidget::RefreshWidgetStyle()
{
    ButtonHighlight->SetPadding(FMargin(ButtonHighlightWidth));
    ButtonHighlight->SetBrushColor(ButtonHighlightColor);
 
    ButtonBounds->SetPadding(FMargin(ButtonBoundsWidth));
    ButtonBounds->SetBrushColor(ButtonBoundsColor);
 
    BtnName->SetText(ButtonName);
    BtnName->SetColorAndOpacity(ButtonNameColor);
 
    FSlateFontInfo FontInfo = BtnName->Font;
    FontInfo.Size = ButtonNameFontSize;
    BtnName->SetFont(FontInfo);
 
    SwitchButtonColor(bCurrentState);
}
 
void UButtonWidget::ActivateButtonHighlight()
{
    ButtonHighlight->BrushColor.A = 1.f;
    ButtonHighlight->SetBrushColor(ButtonHighlight->BrushColor);
}
 
void UButtonWidget::ActivateButtonPulsationHighlight()
{
    if (ButtonHighlightAnimation)
    {
        PlayAnimation(ButtonHighlightAnimation, 0.f, 0, EUMGSequencePlayMode::Forward, HighlightAnimationSpeed);
    }
}
 
void UButtonWidget::DeactivateButtonHighlight()
{
    if (ButtonHighlightAnimation && IsPlayingAnimation())
    {
        StopAnimation(ButtonHighlightAnimation);
    }
 
    ButtonHighlight->BrushColor.A = 0.f;
    ButtonHighlight->SetBrushColor(ButtonHighlight->BrushColor);
}
 
void UButtonWidget::OnHintActivated_Implementation(bool Activate)
{
    if (GEngine)
    {
        if (Activate)
        {
            bIsPulsationHighlight ? ActivateButtonPulsationHighlight() : ActivateButtonHighlight();
        }
        else
        {
            DeactivateButtonHighlight();
        }
    }
 
    if (Activate)
    {
        for (auto Item : HighlightActiveSteps)
        {
            if (Item.EqualTo(ActiveStep))
            {
                bIsPulsationHighlight ? ActivateButtonPulsationHighlight() : ActivateButtonHighlight();
                break;
            }
        }
    }
    else
    {
        DeactivateButtonHighlight();
    }
}
 
void UButtonWidget::ButtonReleased()
{
    bCurrentState = !bCurrentState;
    Button->SetBackgroundColor(bIsSelectable && bCurrentState ? SelectedHoveredButtonColor : DefaultHoveredButtonColor);
 
    OnClickEventDelegate.Broadcast(ButtonName);
    OnClickEventPtrDelegate.Broadcast(ButtonName, GetUniqueID());
    OnClickEventSelfPtrDelegate.Broadcast(this);
 
    UWorld* ThisWorld = GetWorld();
    if (SelectSound && ThisWorld && ThisWorld->bAllowAudioPlayback && !ThisWorld->IsNetMode(NM_DedicatedServer))
    {
        UGameplayStatics::PlaySound2D(ThisWorld, SelectSound);
    }
}
 
void UButtonWidget::ButtonHovered()
{
    Button->SetBackgroundColor(bIsSelectable && bCurrentState ? SelectedHoveredButtonColor : DefaultHoveredButtonColor);
 
    UWorld* ThisWorld = GetWorld();
    if (HoverSound && ThisWorld && ThisWorld->bAllowAudioPlayback && !ThisWorld->IsNetMode(NM_DedicatedServer))
    {
        UGameplayStatics::PlaySound2D(ThisWorld, HoverSound);
    }
}
 
void UButtonWidget::OnUnHovered()
{
    SwitchButtonColor(bCurrentState);
}
 
void UButtonWidget::OnPressed()
{
    Button->SetBackgroundColor(PressedButtonColor);
}
 
void UButtonWidget::NewStep(FStoryStep NewStep, bool IsForward)
{
    if (!ActivateHighlightOnEachActiveStep)
    {
        return;
    }
 
    ActiveStep = StoryManager->CurrentStep.StepName;
    ActiveSubStep = StoryManager->CurrentSubStep.StepName;
 
    bool StepFound = false;
    bool SubStepFound = false;
    for (auto Step : HighlightActiveSteps)
    {
        if (ActiveStep.EqualTo(Step))
        {
            StepFound = true;
            break;
        }
    }
 
    for (auto SubStep : HighlightActiveSubSteps)
    {
        if (ActiveSubStep.EqualTo(SubStep))
        {
            SubStepFound = true;
            break;
        }
    }
 
    if (StepFound && (SubStepFound || HighlightActiveSubSteps.Num() == 0 || ActiveSubStep.IsEmpty()))
    {
        bWidgetActiveOnStep = true;
        bIsPulsationHighlight ? ActivateButtonPulsationHighlight() : ActivateButtonHighlight();
    }
    else
    {
        if (bWidgetActiveOnStep)
        {
            bWidgetActiveOnStep = false;
            DeactivateButtonHighlight();
        }
    }
}
 
void UButtonWidget::NewSubStep(FStoryStep NewSubStep)
{
    if (!ActivateHighlightOnEachActiveStep)
    {
        return;
    }
 
    ActiveStep = StoryManager->CurrentStep.StepName;
    ActiveSubStep = NewSubStep.StepName;
 
    bool StepFound = false;
    bool SubStepFound = false;
 
    for (auto Step : HighlightActiveSteps)
    {
        if (ActiveStep.EqualTo(Step))
        {
            StepFound = true;
            break;
        }
    }
 
    for (auto SubStep : HighlightActiveSubSteps)
    {
        if (ActiveSubStep.EqualTo(SubStep))
        {
            SubStepFound = true;
            break;
        }
    }
 
    if (StepFound && (SubStepFound || HighlightActiveSubSteps.Num() == 0))
    {
        bWidgetActiveOnStep = true;
        bIsPulsationHighlight ? ActivateButtonPulsationHighlight() : ActivateButtonHighlight();
    }
    else
    {
        if (bWidgetActiveOnStep)
        {
            bWidgetActiveOnStep = false;
            DeactivateButtonHighlight();
        }
    }
}
 
void UButtonWidget::StoryLoaded()
{
    NewStep(StoryManager->CurrentStep, false);
}