SWidgetCarousel.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    SWidgetCarousel.h: Declares the SWidgetCarousel class.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Widgets/DeclarativeSyntaxSupport.h"
#include "Types/SlateEnums.h"
#include "Widgets/SWidget.h"
#include "Widgets/SCompoundWidget.h"
#include "Framework/SlateDelegates.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/SOverlay.h"
#include "Animation/CurveSequence.h"
#include "Widgets/Layout/SFxWidget.h"
 
namespace EWidgetCarouselScrollDirection
{
    enum Type
    {
        // Scroll the carousel left.
        Carousel_Left,
        // Scroll the carousel right.
        Carousel_Right,
        // Center the carousel
        Carousel_Center,
    };
}
 
struct FCarouselDisplayItem : public TSharedFromThis<FCarouselDisplayItem>
{
    FCarouselDisplayItem()
        : OpacityValue( 0.f )
        , SlideValue( 0.f )
        , DesiredOpacityValue( 0.f )
        , SlideValueLeftLimit( -1.0f )
        , SlideValueRightLimit( 1.0f )
        , PeakValueLeftLimit(-0.05f)
        , PeakValueRightLimit(0.05f)
        , OptimalSlideValue( 0.0f )
        , DesiredSlideValue( 0.f )
        , bTransition( false )
        , bPeak(false)
        , bFade( false )
        , MoveSpeed( 5.0f )
        , PeakSpeed(.2f)
        , PeakDistance(0.05f)
        , FadeRate( 2.0f )
        , Visibility(EVisibility::Visible)
    {
        // Create default widget
        FXWidget = SNew(SFxWidget)
            .IgnoreClipping(false);
 
        SlideInCurve = FCurveSequence();
        SlideInCurve.AddCurve(0.1f, 0.5f);
    }
 
    void ScrollIn( EWidgetCarouselScrollDirection::Type ScrollDirection )
    {
        bTransition = true;
        bPeak = false;
        bFade = FadeRate != 0;
        DesiredSlideValue = OptimalSlideValue;
        DesiredOpacityValue = 1.0f;
    }
 
    void PeakIn(EWidgetCarouselScrollDirection::Type ScrollDirection)
    {
        if (!bTransition)
        {
            SlideInCurve.JumpToEnd();
            SlideInCurve.PlayReverse(FXWidget.ToSharedRef());
            bPeak = true;
            bFade = FadeRate != 0;
            switch (ScrollDirection)
            {
                case EWidgetCarouselScrollDirection::Carousel_Left:
                {
                    DesiredSlideValue = PeakValueLeftLimit;
                }
                break;
                case EWidgetCarouselScrollDirection::Carousel_Right:
                {
                    DesiredSlideValue = PeakValueRightLimit;
                }
                break;
                case EWidgetCarouselScrollDirection::Carousel_Center:
                {
                    DesiredSlideValue = OptimalSlideValue;
                }
                break;
            }
            DesiredOpacityValue = 0.0f;
        }
    }
 
    void Tick( float DeltaTime )
    {
        if ( bTransition )
        {
            bTransition = BlendWidget(DeltaTime, DesiredSlideValue, MoveSpeed, SlideValue);
            SetSlide( SlideValue );
        }
        else if ( bPeak )
        {
            bPeak = BlendWidget(DeltaTime, DesiredSlideValue, PeakSpeed, SlideValue);
            SetSlide(SlideValue);
        }
 
        if ( bFade )
        {
            bFade = BlendWidget(DeltaTime, DesiredOpacityValue, FadeRate, OpacityValue);
            SetOpacity(OpacityValue);
        }
    }
 
    bool BlendWidget( const float& DeltaTime, const float& DesiredValue, const float& Speed, float& OutCurrentValue )
    {
        bool bStillBlending = true;
 
        float DesiredBlendSpeed = Speed * DeltaTime;
        float BlendDif = OutCurrentValue - DesiredValue;
 
        if (bPeak)
        {
            if (FMath::Abs(BlendDif) > PeakDistance + (float)FLOAT_NORMAL_THRESH)
            {
                SlideInCurve.JumpToEnd();
                SlideInCurve.PlayReverse(FXWidget.ToSharedRef());
            }
            float Lerp = FMath::Max(SlideInCurve.GetLerp(), 0.1f);
            DesiredBlendSpeed = Speed * Lerp * DeltaTime;
        }
 
        if (FMath::Abs(DesiredBlendSpeed) > FMath::Abs(BlendDif))
        {
            OutCurrentValue = DesiredValue;
            bStillBlending = false;
        }
        else
        {
            // Reverse Direction if sliding left
            if ( BlendDif > 0.f )
            {
                DesiredBlendSpeed *= -1.f;
            }
 
            OutCurrentValue += DesiredBlendSpeed;
        }
 
        return bStillBlending;
    }
 
    void SetWidgetContent( TSharedRef<SWidget> InContent )
    {
        FXWidget = SNew( SFxWidget )
        .IgnoreClipping(false)
        .VisualOffset( this, &FCarouselDisplayItem::GetSlide )
        [
//          SNew(SOverlay)
//          + SOverlay::Slot()
//          [
                InContent
//          ]
//          + SOverlay::Slot()
//          .HAlign(HAlign_Right)
//          [
//              SNew(STextBlock)
//              .Text(this, &FCarouselDisplayItem::GetPositionText)
//          ]
//          + SOverlay::Slot()
//          .HAlign(HAlign_Left)
//          [
//              SNew(STextBlock)
//              .Text(this, &FCarouselDisplayItem::GetPositionText)
//          ]
        ];
    }
 
    TSharedRef<SWidget> GetWidgetContent() const
    {
        if (FXWidget.IsValid())
        {
            FChildren* Children = FXWidget->GetChildren();
            if (Children && Children->Num() > 0)
            {
                return Children->GetChildAt(0);
            }       
        }
 
        return SNullWidget::NullWidget;
    }
 
//  FText GetPositionText() const
//  {
//      return FText::FromString(FString::Printf(TEXT("%.2f, %.2f, %.2f"), SlideValue, DesiredSlideValue, SlideInCurve.GetLerp()));
//  }
 
    TSharedPtr< SFxWidget > GetSFXWidget()
    {
        return FXWidget;
    }
 
    void SetOpacity( float InOpacity )
    {
        OpacityValue = InOpacity;
        FXWidget->SetColorAndOpacity( FLinearColor(1.f,1.f,1.f, OpacityValue ) );
    }
 
    void SetVisibility(EVisibility InVisibility)
    {
        Visibility = InVisibility;
        FXWidget->SetVisibility(InVisibility);
    }
 
    void SetSlide( float InSlide, bool bClearTransition = false)
    {
        SlideValue = InSlide;
 
        if (bClearTransition)
        {
            bPeak = false;
            bTransition = false;
            DesiredSlideValue = SlideValue;
        }
    }
 
    void SetMoveSpeed( float DesiredMoveSpeed )
    {
        MoveSpeed = DesiredMoveSpeed;
    }
 
    void SetSliderLeftLimit( float DesiredLeftLimit )
    {
        SlideValueLeftLimit = DesiredLeftLimit;
    }
 
    void SetSliderRightLimit( float DesiredRightLimit )
    {
        SlideValueRightLimit = DesiredRightLimit;
    }
 
    void SetSliderPeakLeftLimit(float DesiredLimit)
    {
        PeakValueLeftLimit = DesiredLimit;
    }
 
    void SetSliderPeakRightLimit(float DesiredLimit)
    {
        PeakValueRightLimit = DesiredLimit;
    }
 
    void SetSliderOptimalPostion( float DesiredOptimalSlideValue )
    {
        OptimalSlideValue = DesiredOptimalSlideValue;
    }
 
    void SetFadeRate( float DesiredFadeRate )
    {
        FadeRate = DesiredFadeRate;
    }
 
    bool IsInTransition()
    {
        return bTransition || bFade;
    }
 
    const float GetSlideValue() const
    {
        return SlideValue;
    }
 
    const float GetMoveSpeed() const
    {
        return MoveSpeed;
    }
 
protected:
 
    FVector2D GetSlide() const
    {
        return FVector2D( SlideValue, 0.f );
    }
 
protected:
    // Holds the Opacity Value. 0 == transparent
    float OpacityValue;
 
    // The slide position
    float SlideValue;
 
    // The desired opacity value
    float DesiredOpacityValue;
 
    // The max left position
    float SlideValueLeftLimit;
 
    // The max right position
    float SlideValueRightLimit;
 
    // The left peak position
    float PeakValueLeftLimit;
 
    // The right peak position
    float PeakValueRightLimit;
 
    // The slide value to display the widget on screen
    float OptimalSlideValue;
 
    // The desired slide value
    float DesiredSlideValue;
 
    // Holds if widget is in transition
    bool bTransition;
 
    // Hold if the widget is peaking
    bool bPeak;
 
    // Holds if the widget is fading in or out
    bool bFade;
 
    // Holds if the widget should fade in or out
    bool bFadeInAndOut;
 
    // The maximum move speed of the widget
    float MoveSpeed;
 
    // The Peak speed
    float PeakSpeed;
 
    // The Peak Distance
    float PeakDistance;
 
    // The amount by which a widget fades per frame
    float FadeRate;
 
    // Holds the FX widget that does the transitioning
    TSharedPtr< SFxWidget > FXWidget;
 
    // Holds the peak curve
    FCurveSequence SlideInCurve;
 
    // The current visibility of the display item
    EVisibility Visibility;
};
 
template <typename ItemType>
class SWidgetCarousel
    : public SCompoundWidget
{
public:
 
    DECLARE_DELEGATE_OneParam(FOnCarouselPageChanged, int32 /*PageIndex*/);
    typedef typename TSlateDelegates< ItemType >::FOnGenerateWidget FOnGenerateWidget;
 
    SLATE_BEGIN_ARGS(SWidgetCarousel<ItemType>)
        : _WidgetItemsSource( static_cast<const TArray<ItemType>*>(NULL) )
        , _MoveSpeed( 1.f )
        , _SlideValueLeftLimit( -1.f )
        , _SlideValueRightLimit( 1.f )
        , _PeakValueLeftLimit(-0.05f)
        , _PeakValueRightLimit(0.05f)
        , _FadeRate( 1.0f )
    {
        this->_Clipping = EWidgetClipping::ClipToBounds;
    }
 
    SLATE_EVENT( FOnGenerateWidget, OnGenerateWidget )
    SLATE_EVENT(FOnCarouselPageChanged, OnPageChanged)
    SLATE_ARGUMENT( const TArray<ItemType>*, WidgetItemsSource )
    SLATE_ATTRIBUTE(float, MoveSpeed )
    SLATE_ATTRIBUTE(float, SlideValueLeftLimit )
    SLATE_ATTRIBUTE(float, SlideValueRightLimit )
    SLATE_ATTRIBUTE(float, PeakValueLeftLimit)
    SLATE_ATTRIBUTE(float, PeakValueRightLimit)
    SLATE_ATTRIBUTE(float, FadeRate )
 
    SLATE_END_ARGS()
 
public:
    void Construct( const FArguments& InArgs )
    {
        OnGenerateWidget = InArgs._OnGenerateWidget;
        OnPageChanged = InArgs._OnPageChanged;
        ItemsSource = InArgs._WidgetItemsSource;
        WidgetIndex = 0;
        MoveSpeed = InArgs._MoveSpeed.Get();
        SlideValueLeftLimit = InArgs._SlideValueLeftLimit.Get();
        SlideValueRightLimit = InArgs._SlideValueRightLimit.Get(); 
        PeakValueLeftLimit = InArgs._PeakValueLeftLimit.Get();
        PeakValueRightLimit = InArgs._PeakValueRightLimit.Get();
 
        FadeRate = InArgs._FadeRate.Get();
 
        LeftCarouselWidget = MakeShareable(new FCarouselDisplayItem());
        CenterCarouselWidget = MakeShareable(new FCarouselDisplayItem());
        RightCarouselWidget = MakeShareable(new FCarouselDisplayItem());
 
        // Set up the Carousel Widget
        CenterCarouselWidget->SetOpacity(1.0f);
        CenterCarouselWidget->SetSlide(0.f);
        CenterCarouselWidget->SetMoveSpeed(MoveSpeed);
        CenterCarouselWidget->SetFadeRate(FadeRate);
 
        LeftCarouselWidget->SetOpacity(1.0f);
        LeftCarouselWidget->SetSlide(SlideValueLeftLimit);
        LeftCarouselWidget->SetMoveSpeed(MoveSpeed);
        LeftCarouselWidget->SetFadeRate(FadeRate);
 
        RightCarouselWidget->SetOpacity(1.0f);
        RightCarouselWidget->SetSlide(SlideValueRightLimit);
        RightCarouselWidget->SetMoveSpeed(MoveSpeed);
        RightCarouselWidget->SetFadeRate(FadeRate);
 
        // Create the widget
        ChildSlot
        [
            SAssignNew(WidgetDisplayBox, SHorizontalBox)
        ];
 
        GenerateCurrentWidgets();
 
        OnPageChanged.ExecuteIfBound(WidgetIndex);
    }
 
    void GenerateCurrentWidgets()
    {
        const TArray<ItemType>& ItemsSourceRef = (*ItemsSource);
        if (ItemsSourceRef.Num() > 0)
        {
            if (WidgetIndex >= ItemsSourceRef.Num())
            {
                WidgetIndex = WidgetIndex % ItemsSourceRef.Num();
            }
            
            TSharedRef<SWidget> LeftWidget = OnGenerateWidget.Execute(ItemsSourceRef[GetLeftWidgetIndex(WidgetIndex)]);
            TSharedRef<SWidget> RightWidget = OnGenerateWidget.Execute(ItemsSourceRef[GetRightWidgetIndex(WidgetIndex)]);
            TSharedRef<SWidget> CenterWidget = OnGenerateWidget.Execute(ItemsSourceRef[WidgetIndex]);
 
            // Each carousel widget must have unique content since Slate Global Invalidation requires that widgets only exist in a single slot
            const bool bIsLeftWidgetUnique = (LeftWidget != CenterWidget) && (RightWidget != LeftWidget);
            const bool bIsRightWidgetUnique = RightWidget != CenterWidget;
            LeftCarouselWidget->SetWidgetContent(bIsLeftWidgetUnique ? LeftWidget : SNullWidget::NullWidget);
            RightCarouselWidget->SetWidgetContent(bIsRightWidgetUnique ? RightWidget : SNullWidget::NullWidget);
            // CenterCarouselWidget is the one that displays the active child.  Needs to be populated last for the Widget Path to match the visible hierarchy.
            CenterCarouselWidget->SetWidgetContent(CenterWidget);
        }
 
        if (ItemsSourceRef.Num() == 1)
        {
            LeftCarouselWidget->SetVisibility(EVisibility::Collapsed);
            RightCarouselWidget->SetVisibility(EVisibility::Collapsed);
        }
        else
        {
            LeftCarouselWidget->SetVisibility(EVisibility::Visible);
            RightCarouselWidget->SetVisibility(EVisibility::Visible);
        }
 
        SetSliderLimits();
        GenerateWidgets();
    }
 
    int32 GetWidgetIndex()
    {
        return WidgetIndex;
    }
 
    void SetActiveWidgetIndex(int32 Index)
    {
        if (!IsInTransition())
        {
            // Don't change if the widget index is the same
            if (Index != WidgetIndex)
            {
                // Choose the scroll direction
                EWidgetCarouselScrollDirection::Type ScrollDirection = Index > WidgetIndex ?
                    EWidgetCarouselScrollDirection::Carousel_Right : EWidgetCarouselScrollDirection::Carousel_Left;
 
                SwapBuffer(ScrollDirection, Index);
            }
        }
    }
 
    void SetNextWidget()
    {
        if (!IsInTransition())
        {
            SwapBuffer(EWidgetCarouselScrollDirection::Carousel_Left);
        }
    }
 
    void SetPreviousWidget()
    {
        if (!IsInTransition())
        {
            SwapBuffer(EWidgetCarouselScrollDirection::Carousel_Right);
        }
    }
 
    void Peak(EWidgetCarouselScrollDirection::Type Direction)
    {
        if (!IsInTransition())
        {
            CenterCarouselWidget->PeakIn(Direction);
            RightCarouselWidget->PeakIn(Direction);
            LeftCarouselWidget->PeakIn(Direction);
        }
    }
 
    void SetItemSource( const TArray<ItemType>* InWidgetItemsSource )
    {
        ItemsSource = InWidgetItemsSource;
        if ( ItemsSource->Num() )
        {
            SetActiveWidgetIndex( 0 );
        }
    }
 
    float GetPrimarySlide()
    {
        return CenterCarouselWidget->GetSlideValue();
    }
 
    void SetMoveSpeed(float InMoveSpeed)
    {
        if (!IsInTransition())
        {
            CenterCarouselWidget->SetMoveSpeed(InMoveSpeed);
            RightCarouselWidget->SetMoveSpeed(InMoveSpeed);
            LeftCarouselWidget->SetMoveSpeed(InMoveSpeed);
        }
    }
 
    float GetMoveSpeed() const
    {
        return CenterCarouselWidget->GetMoveSpeed();
    }
 
    void ResetTransition()
    {
        constexpr bool bClearTransition = true;
        CenterCarouselWidget->SetSlide(0.f, bClearTransition);
        LeftCarouselWidget->SetSlide(SlideValueLeftLimit, bClearTransition);
        RightCarouselWidget->SetSlide(SlideValueRightLimit, bClearTransition);
    }
 
protected:
 
    void GenerateWidgets( )
    {
        WidgetDisplayBox->ClearChildren();
        WidgetDisplayBox->AddSlot()
        [
            SNew( SOverlay )
            +SOverlay::Slot()
            [
                LeftCarouselWidget->GetSFXWidget().ToSharedRef()
            ]
            +SOverlay::Slot()
            [
                RightCarouselWidget->GetSFXWidget().ToSharedRef()
            ]
            + SOverlay::Slot()
            [
                CenterCarouselWidget->GetSFXWidget().ToSharedRef()
            ]
        ];
    }
 
    void SwapBuffer(EWidgetCarouselScrollDirection::Type ScrollDirection, int32 OverrideWidgetIndex = INDEX_NONE)
    {
        // Register for an active update every 2.5 seconds
        RegisterActiveTimer(0.0f, FWidgetActiveTimerDelegate::CreateSP(this, &SWidgetCarousel::RegisteredTick));
 
        const TArray<ItemType>& ItemsSourceRef = (*ItemsSource);
        
        TSharedRef<SWidget> LeftWidget = LeftCarouselWidget->GetWidgetContent();
        TSharedRef<SWidget> RightWidget = RightCarouselWidget->GetWidgetContent();
        TSharedRef<SWidget> CenterWidget = CenterCarouselWidget->GetWidgetContent();
 
        const bool bIsScrollingLeft = ScrollDirection == EWidgetCarouselScrollDirection::Carousel_Left;
 
        if (ItemsSourceRef.Num() > 0)
        {
            if (bIsScrollingLeft)
            {
                WidgetIndex = GetLeftWidgetIndex(WidgetIndex);
                TSharedPtr<FCarouselDisplayItem> TempWidget = RightCarouselWidget;
                RightCarouselWidget = CenterCarouselWidget;
                RightWidget = (CenterWidget == SNullWidget::NullWidget) ? OnGenerateWidget.Execute(ItemsSourceRef[GetRightWidgetIndex(WidgetIndex)]) : CenterWidget;
                CenterCarouselWidget = LeftCarouselWidget;
                CenterWidget = (LeftWidget == SNullWidget::NullWidget) ? OnGenerateWidget.Execute(ItemsSourceRef[WidgetIndex]) : LeftWidget;
                LeftCarouselWidget = TempWidget;
                LeftWidget = OnGenerateWidget.Execute(ItemsSourceRef[GetLeftWidgetIndex(WidgetIndex)]);
                LeftCarouselWidget->SetSlide(CenterCarouselWidget->GetSlideValue() + SlideValueLeftLimit, true);
            }
            else
            {
                WidgetIndex = GetRightWidgetIndex(WidgetIndex);
                TSharedPtr<FCarouselDisplayItem> TempWidget = LeftCarouselWidget;
                LeftCarouselWidget = CenterCarouselWidget;
                LeftWidget = (CenterWidget == SNullWidget::NullWidget) ? OnGenerateWidget.Execute(ItemsSourceRef[GetLeftWidgetIndex(WidgetIndex)]) : CenterWidget;
                CenterCarouselWidget = RightCarouselWidget;
                CenterWidget = (RightWidget == SNullWidget::NullWidget) ? OnGenerateWidget.Execute(ItemsSourceRef[WidgetIndex]) : RightWidget;
                RightCarouselWidget = TempWidget;
                RightWidget = OnGenerateWidget.Execute(ItemsSourceRef[GetRightWidgetIndex(WidgetIndex)]);
                RightCarouselWidget->SetSlide(CenterCarouselWidget->GetSlideValue() + SlideValueRightLimit, true);
            }
        }
 
        if (ItemsSourceRef.IsValidIndex(OverrideWidgetIndex))
        {
            // Need to find a way to clear left and right images
            WidgetIndex = OverrideWidgetIndex;
            CenterWidget = OnGenerateWidget.Execute(ItemsSourceRef[OverrideWidgetIndex]);
        }
        
        // Ensure the 3 CarouselWidgets here have unique widgets, if that isn't the case, prioritize the 2 widgets that will display during the transition
        const bool bIsLeftWidgetUnique = (LeftWidget != CenterWidget) && (!bIsScrollingLeft || RightWidget != LeftWidget);
        const bool bIsRightWidgetUnique = (RightWidget != CenterWidget) && (bIsScrollingLeft || RightWidget != LeftWidget);
        LeftCarouselWidget->SetWidgetContent(bIsLeftWidgetUnique ? LeftWidget : SNullWidget::NullWidget);
        RightCarouselWidget->SetWidgetContent(bIsRightWidgetUnique ? RightWidget : SNullWidget::NullWidget);
        CenterCarouselWidget->SetWidgetContent(CenterWidget);
 
        SetSliderLimits();
        GenerateWidgets();
        CenterCarouselWidget->ScrollIn(ScrollDirection);
        RightCarouselWidget->ScrollIn(ScrollDirection);
        LeftCarouselWidget->ScrollIn(ScrollDirection);
 
        OnPageChanged.ExecuteIfBound(WidgetIndex);
    }
 
    void SetSliderLimits()
    {
        LeftCarouselWidget->SetSliderLeftLimit(SlideValueLeftLimit);
        LeftCarouselWidget->SetSliderRightLimit(SlideValueRightLimit);
        LeftCarouselWidget->SetSliderPeakLeftLimit(SlideValueLeftLimit + PeakValueLeftLimit);
        LeftCarouselWidget->SetSliderPeakRightLimit(SlideValueLeftLimit + PeakValueRightLimit);
        LeftCarouselWidget->SetSliderOptimalPostion(SlideValueLeftLimit);
 
        RightCarouselWidget->SetSliderLeftLimit(SlideValueLeftLimit);
        RightCarouselWidget->SetSliderRightLimit(SlideValueRightLimit);
        RightCarouselWidget->SetSliderPeakLeftLimit(SlideValueRightLimit + PeakValueLeftLimit);
        RightCarouselWidget->SetSliderPeakRightLimit(SlideValueRightLimit + PeakValueRightLimit);
        RightCarouselWidget->SetSliderOptimalPostion(SlideValueRightLimit);
 
        CenterCarouselWidget->SetSliderLeftLimit(SlideValueLeftLimit);
        CenterCarouselWidget->SetSliderRightLimit(SlideValueRightLimit);
        CenterCarouselWidget->SetSliderPeakLeftLimit(PeakValueLeftLimit);
        CenterCarouselWidget->SetSliderPeakRightLimit(PeakValueRightLimit);
        CenterCarouselWidget->SetSliderOptimalPostion(0);
    }
 
    int32 GetLeftWidgetIndex(int32 Index)
    {
        int32 LeftWidgetIndex = Index - 1;
        if (LeftWidgetIndex < 0)
        {
            LeftWidgetIndex = FMath::Max(0, ItemsSource->Num() - 1);
        }
        return LeftWidgetIndex;
    }
 
    int32 GetRightWidgetIndex(int32 Index)
    {
        int32 RightWidgetIndex = Index + 1;
        if (RightWidgetIndex >= ItemsSource->Num())
        {
            RightWidgetIndex = 0;
        }
        return RightWidgetIndex;
    }
 
    bool IsInTransition()
    {
        return CenterCarouselWidget->IsInTransition() || LeftCarouselWidget->IsInTransition() || RightCarouselWidget->IsInTransition();
    }
 
    EActiveTimerReturnType RegisteredTick(double InCurrentTime, float InDeltaTime)
    {
        // Tick the widgets to animate them
        LeftCarouselWidget->Tick(InDeltaTime);
        CenterCarouselWidget->Tick(InDeltaTime);
        RightCarouselWidget->Tick(InDeltaTime);
    
        return IsInTransition() ? EActiveTimerReturnType::Continue : EActiveTimerReturnType::Stop;
    }
 
protected:
 
    // Holds the CarouselWidgets
    TSharedPtr< FCarouselDisplayItem > LeftCarouselWidget;
    TSharedPtr< FCarouselDisplayItem > CenterCarouselWidget;
    TSharedPtr< FCarouselDisplayItem > RightCarouselWidget;
 
    // Pointer to the array of data items that we are observing
    const TArray<ItemType>* ItemsSource;
 
    // Hold the delegate to be invoked when a widget changes.
    FOnGenerateWidget OnGenerateWidget;
 
    // Hold the delegate to be invoked when the current page changes.
    FOnCarouselPageChanged OnPageChanged;
 
    // Holds the widget display box.
    TSharedPtr< SHorizontalBox > WidgetDisplayBox;
 
    // Holds the visible widget index.
    int32 WidgetIndex;
 
    // Holds the move speed
    float MoveSpeed;
 
    // Holds The left limit
    float SlideValueLeftLimit;
 
    // The right limit
    float SlideValueRightLimit;
 
    // Holds The peak left limit
    float PeakValueLeftLimit;
 
    // The peak right limit
    float PeakValueRightLimit;
 
    // The fade rate
    float FadeRate;
};