//  SPDX-License-Identifier: MIT
//
//  ES-DE Frontend
//  CarouselComponent.h
//
//  Carousel, usable in both the system and gamelist views.
//

#ifndef ES_CORE_COMPONENTS_PRIMARY_CAROUSEL_COMPONENT_H
#define ES_CORE_COMPONENTS_PRIMARY_CAROUSEL_COMPONENT_H

#include "Sound.h"
#include "animations/LambdaAnimation.h"
#include "components/IList.h"
#include "components/primary/PrimaryComponent.h"
#include "resources/Font.h"

struct CarouselEntry {
    std::shared_ptr<GuiComponent> item;
    std::string imagePath;
    std::string defaultImagePath;
};

template <typename T>
class CarouselComponent : public PrimaryComponent<T>, protected IList<CarouselEntry, T>
{
protected:
    using List = IList<CarouselEntry, T>;
    using List::mCursor;
    using List::mEntries;
    using List::mLastCursor;
    using List::mScrollVelocity;
    using List::mSize;
    using List::mWindow;

    using GuiComponent::mDefaultZIndex;
    using GuiComponent::mZIndex;

public:
    using Entry = typename IList<CarouselEntry, T>::Entry;

    enum class CarouselType {
        HORIZONTAL,
        VERTICAL,
        VERTICAL_WHEEL,
        HORIZONTAL_WHEEL,
        NO_CAROUSEL
    };

    enum class ItemStacking {
        CENTERED,
        ASCENDING,
        ASCENDING_RAISED,
        DESCENDING,
        DESCENDING_RAISED
    };

    CarouselComponent();

    void addEntry(Entry& entry, const std::shared_ptr<ThemeData>& theme);
    void updateEntry(Entry& entry, const std::shared_ptr<ThemeData>& theme);
    Entry& getEntry(int index) { return mEntries.at(index); }
    void onDemandTextureLoad() override;
    const CarouselType getType() { return mType; }
    const std::string& getDefaultCarouselImage() const { return mDefaultImagePath; }
    const std::string& getDefaultCarouselFolderImage() const { return mDefaultFolderImagePath; }
    void setDefaultImage(std::string defaultImage) { mDefaultImagePath = defaultImage; }
    void setDefaultFolderImage(std::string defaultImage) { mDefaultFolderImagePath = defaultImage; }
    bool isScrolling() const override { return List::isScrolling(); }
    const LetterCase getLetterCase() const override { return mLetterCase; }
    const LetterCase getLetterCaseAutoCollections() const override
    {
        return mLetterCaseAutoCollections;
    }
    const LetterCase getLetterCaseCustomCollections() const override
    {
        return mLetterCaseCustomCollections;
    }
    const bool getSystemNameSuffix() const override { return mSystemNameSuffix; }
    const LetterCase getLetterCaseSystemNameSuffix() const override
    {
        return mLetterCaseSystemNameSuffix;
    }

    void setCancelTransitionsCallback(const std::function<void()>& func) override
    {
        mCancelTransitionsCallback = func;
    }
    void setCursorChangedCallback(const std::function<void(CursorState state)>& func) override
    {
        mCursorChangedCallback = func;
    }

    bool input(InputConfig* config, Input input) override;
    void update(int deltaTime) override;
    void render(const glm::mat4& parentTrans) override;
    void applyTheme(const std::shared_ptr<ThemeData>& theme,
                    const std::string& view,
                    const std::string& element,
                    unsigned int properties) override;

private:
    void onShowPrimary() override { mEntries.at(mCursor).data.item->resetComponent(); }
    void onCursorChanged(const CursorState& state) override;
    void onScroll() override
    {
        if (mGamelistView)
            NavigationSounds::getInstance().playThemeNavigationSound(SCROLLSOUND);
        else
            NavigationSounds::getInstance().playThemeNavigationSound(SYSTEMBROWSESOUND);
    }

    void stopScrolling() override
    {
        List::stopScrolling();
        // Only finish the animation if we're in the gamelist view.
        if (mGamelistView)
            GuiComponent::finishAnimation(0);
    }
    const int getScrollingVelocity() override { return List::getScrollingVelocity(); }
    void clear() override { List::clear(); }
    const T& getSelected() const override { return List::getSelected(); }
    const T& getNext() const override { return List::getNext(); }
    const T& getPrevious() const override { return List::getPrevious(); }
    const T& getFirst() const override { return List::getFirst(); }
    const T& getLast() const override { return List::getLast(); }
    bool setCursor(const T& obj) override { return List::setCursor(obj); }
    bool remove(const T& obj) override { return List::remove(obj); }
    int size() const override { return List::size(); }

    int getCursor() override { return mCursor; }
    const size_t getNumEntries() override { return mEntries.size(); }
    const bool getFadeAbovePrimary() const override { return mFadeAbovePrimary; }

    enum class ImageFit {
        CONTAIN,
        FILL,
        COVER
    };

    Renderer* mRenderer;
    std::function<void(CursorState state)> mCursorChangedCallback;
    std::function<void()> mCancelTransitionsCallback;

    float mEntryCamOffset;
    float mEntryCamTarget;
    int mPreviousScrollVelocity;
    bool mPositiveDirection;
    bool mTriggerJump;
    bool mGamelistView;

    CarouselType mType;
    std::vector<std::string> mImageTypes;
    std::string mDefaultImagePath;
    std::string mDefaultFolderImagePath;
    std::shared_ptr<ImageComponent> mDefaultImage;
    float mMaxItemCount;
    int mItemsBeforeCenter;
    int mItemsAfterCenter;
    ItemStacking mItemStacking;
    glm::vec2 mSelectedItemMargins;
    glm::vec2 mSelectedItemOffset;
    glm::vec2 mItemSize;
    float mItemScale;
    float mItemRotation;
    glm::vec2 mItemRotationOrigin;
    bool mItemAxisHorizontal;
    float mItemAxisRotation;
    bool mLinearInterpolation;
    float mImageCornerRadius;
    unsigned int mImageColorShift;
    unsigned int mImageColorShiftEnd;
    bool mImageColorGradientHorizontal;
    unsigned int mImageSelectedColor;
    unsigned int mImageSelectedColorEnd;
    bool mImageSelectedColorGradientHorizontal;
    bool mHasImageSelectedColor;
    float mImageBrightness;
    float mImageSaturation;
    float mItemDiagonalOffset;
    bool mInstantItemTransitions;
    Alignment mItemHorizontalAlignment;
    Alignment mItemVerticalAlignment;
    Alignment mWheelHorizontalAlignment;
    Alignment mWheelVerticalAlignment;
    float mHorizontalOffset;
    float mVerticalOffset;
    bool mReflections;
    float mReflectionsOpacity;
    float mReflectionsFalloff;
    float mUnfocusedItemOpacity;
    float mUnfocusedItemSaturation;
    bool mHasUnfocusedItemSaturation;
    float mUnfocusedItemDimming;
    ImageFit mImagefit;
    glm::vec2 mImageCropPos;
    unsigned int mCarouselColor;
    unsigned int mCarouselColorEnd;
    bool mColorGradientHorizontal;
    float mTextRelativeScale;
    float mTextBackgroundCornerRadius;
    unsigned int mTextColor;
    unsigned int mTextBackgroundColor;
    unsigned int mTextSelectedColor;
    unsigned int mTextSelectedBackgroundColor;
    bool mHasTextSelectedColor;
    bool mTextHorizontalScrolling;
    float mTextHorizontalScrollSpeed;
    float mTextHorizontalScrollDelay;
    float mTextHorizontalScrollGap;
    std::shared_ptr<Font> mFont;
    LetterCase mLetterCase;
    LetterCase mLetterCaseAutoCollections;
    LetterCase mLetterCaseCustomCollections;
    float mLineSpacing;
    bool mSystemNameSuffix;
    LetterCase mLetterCaseSystemNameSuffix;
    bool mFadeAbovePrimary;
};

template <typename T>
CarouselComponent<T>::CarouselComponent()
    : IList<CarouselEntry, T> {IList<CarouselEntry, T>::LIST_SCROLL_STYLE_SLOW,
                               (std::is_same_v<T, SystemData*> ?
                                    ListLoopType::LIST_ALWAYS_LOOP :
                                    ListLoopType::LIST_PAUSE_AT_END_ON_JUMP)}
    , mRenderer {Renderer::getInstance()}
    , mEntryCamOffset {0.0f}
    , mEntryCamTarget {0.0f}
    , mPreviousScrollVelocity {0}
    , mPositiveDirection {false}
    , mTriggerJump {false}
    , mGamelistView {std::is_same_v<T, FileData*> ? true : false}
    , mType {CarouselType::HORIZONTAL}
    , mMaxItemCount {3.0f}
    , mItemsBeforeCenter {8}
    , mItemsAfterCenter {8}
    , mItemStacking {ItemStacking::CENTERED}
    , mSelectedItemMargins {0.0f, 0.0f}
    , mSelectedItemOffset {0.0f, 0.0f}
    , mItemSize {glm::vec2 {Renderer::getScreenWidth() * 0.25f,
                            Renderer::getScreenHeight() * 0.155f}}
    , mItemScale {1.2f}
    , mItemRotation {7.5f}
    , mItemRotationOrigin {-3.0f, 0.5f}
    , mItemAxisHorizontal {false}
    , mItemAxisRotation {0.0f}
    , mLinearInterpolation {false}
    , mImageCornerRadius {0.0f}
    , mImageColorShift {0xFFFFFFFF}
    , mImageColorShiftEnd {0xFFFFFFFF}
    , mImageColorGradientHorizontal {true}
    , mImageSelectedColor {0xFFFFFFFF}
    , mImageSelectedColorEnd {0xFFFFFFFF}
    , mImageSelectedColorGradientHorizontal {true}
    , mHasImageSelectedColor {false}
    , mImageBrightness {0.0f}
    , mImageSaturation {1.0f}
    , mItemDiagonalOffset {0.0f}
    , mInstantItemTransitions {false}
    , mItemHorizontalAlignment {ALIGN_CENTER}
    , mItemVerticalAlignment {ALIGN_CENTER}
    , mWheelHorizontalAlignment {ALIGN_CENTER}
    , mWheelVerticalAlignment {ALIGN_CENTER}
    , mHorizontalOffset {0.0f}
    , mVerticalOffset {0.0f}
    , mReflections {false}
    , mReflectionsOpacity {0.5f}
    , mReflectionsFalloff {1.0f}
    , mUnfocusedItemOpacity {0.5f}
    , mUnfocusedItemSaturation {1.0f}
    , mHasUnfocusedItemSaturation {false}
    , mUnfocusedItemDimming {1.0f}
    , mImagefit {ImageFit::CONTAIN}
    , mImageCropPos {0.5f, 0.5f}
    , mCarouselColor {0}
    , mCarouselColorEnd {0}
    , mColorGradientHorizontal {true}
    , mTextRelativeScale {1.0f}
    , mTextBackgroundCornerRadius {0.0f}
    , mTextColor {0x000000FF}
    , mTextBackgroundColor {0xFFFFFF00}
    , mTextSelectedColor {0x000000FF}
    , mTextSelectedBackgroundColor {0xFFFFFF00}
    , mHasTextSelectedColor {false}
    , mTextHorizontalScrolling {false}
    , mTextHorizontalScrollSpeed {1.0f}
    , mTextHorizontalScrollDelay {3000.0f}
    , mTextHorizontalScrollGap {1.5f}
    , mFont {Font::get(FONT_SIZE_LARGE_FIXED)}
    , mLetterCase {LetterCase::NONE}
    , mLetterCaseAutoCollections {LetterCase::UNDEFINED}
    , mLetterCaseCustomCollections {LetterCase::UNDEFINED}
    , mLineSpacing {1.5f}
    , mSystemNameSuffix {true}
    , mLetterCaseSystemNameSuffix {LetterCase::UPPERCASE}
    , mFadeAbovePrimary {false}
{
}

template <typename T>
void CarouselComponent<T>::addEntry(Entry& entry, const std::shared_ptr<ThemeData>& theme)
{
    bool dynamic {true};

    if (!mGamelistView)
        dynamic = false;

    if (entry.data.imagePath != "" &&
        ResourceManager::getInstance().fileExists(entry.data.imagePath)) {
        auto item = std::make_shared<ImageComponent>(false, dynamic);
        item->setLinearInterpolation(mLinearInterpolation);
        item->setMipmapping(true);
        if (mImagefit == ImageFit::CONTAIN) {
            item->setMaxSize(glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
        }
        else if (mImagefit == ImageFit::FILL) {
            item->setResize(glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
        }
        else if (mImagefit == ImageFit::COVER) {
            item->setCropPos(mImageCropPos);
            item->setCroppedSize(glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
        }
        item->setCornerRadius(mImageCornerRadius);
        item->setImage(entry.data.imagePath);
        if (mImageBrightness != 0.0)
            item->setBrightness(mImageBrightness);
        if (mImageSaturation != 1.0)
            item->setSaturation(mImageSaturation);
        if (mImageColorShift != 0xFFFFFFFF)
            item->setColorShift(mImageColorShift);
        if (mImageColorShiftEnd != mImageColorShift)
            item->setColorShiftEnd(mImageColorShiftEnd);
        if (!mImageColorGradientHorizontal)
            item->setColorGradientHorizontal(false);
        item->setRotateByTargetSize(true);
        entry.data.item = item;
    }
    else if (entry.data.defaultImagePath != "" &&
             ResourceManager::getInstance().fileExists(entry.data.defaultImagePath)) {
        if (mDefaultImage.get() == nullptr || !mGamelistView) {
            mDefaultImage = std::make_shared<ImageComponent>(false, dynamic);
            mDefaultImage->setLinearInterpolation(mLinearInterpolation);
            mDefaultImage->setMipmapping(true);
            if (mImagefit == ImageFit::CONTAIN) {
                mDefaultImage->setMaxSize(
                    glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
            }
            else if (mImagefit == ImageFit::FILL) {
                mDefaultImage->setResize(
                    glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
            }
            else if (mImagefit == ImageFit::COVER) {
                mDefaultImage->setCropPos(mImageCropPos);
                mDefaultImage->setCroppedSize(
                    glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
            }
            mDefaultImage->setCornerRadius(mImageCornerRadius);
            mDefaultImage->setImage(entry.data.defaultImagePath);
            if (mImageBrightness != 0.0)
                mDefaultImage->setBrightness(mImageBrightness);
            if (mImageSaturation != 1.0)
                mDefaultImage->setSaturation(mImageSaturation);
            if (mImageColorShift != 0xFFFFFFFF)
                mDefaultImage->setColorShift(mImageColorShift);
            if (mImageColorShiftEnd != mImageColorShift)
                mDefaultImage->setColorShiftEnd(mImageColorShiftEnd);
            if (!mImageColorGradientHorizontal)
                mDefaultImage->setColorGradientHorizontal(false);
            mDefaultImage->setRotateByTargetSize(true);
        }
        // For the gamelist view the default image is applied in onDemandTextureLoad().
        if (!mGamelistView)
            entry.data.item = mDefaultImage;
    }
    else if (!mGamelistView) {
        entry.data.imagePath = "";
    }

    if (!entry.data.item) {
        // Always add the item text as fallback in case there is no image. This is also displayed
        // when quick-jumping as textures are not loaded in this case.
        auto text = std::make_shared<TextComponent>(
            entry.name, mFont, 0x000000FF, mItemHorizontalAlignment, mItemVerticalAlignment,
            glm::ivec2 {0, 0}, glm::vec3 {0.0f, 0.0f, 0.0f},
            glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)), 0x00000000,
            mLineSpacing, mTextRelativeScale, mTextHorizontalScrolling, mTextHorizontalScrollSpeed,
            mTextHorizontalScrollDelay, mTextHorizontalScrollGap);
        if (!mGamelistView)
            text->setValue(entry.name);
        text->setBackgroundCornerRadius(mTextBackgroundCornerRadius);
        text->setColor(mTextColor);
        text->setBackgroundColor(mTextBackgroundColor);
        text->setRenderBackground(true);

        entry.data.item = text;
    }

    // Set origin for the items based on their alignment so they line up properly.
    if (mItemHorizontalAlignment == ALIGN_LEFT)
        entry.data.item->setOrigin(0.0f, 0.5f);
    else if (mItemHorizontalAlignment == ALIGN_RIGHT)
        entry.data.item->setOrigin(1.0f, 0.5f);
    else
        entry.data.item->setOrigin(0.5f, 0.5f);

    if (mItemVerticalAlignment == ALIGN_TOP)
        entry.data.item->setOrigin(entry.data.item->getOrigin().x, 0.0f);
    else if (mItemVerticalAlignment == ALIGN_BOTTOM)
        entry.data.item->setOrigin(entry.data.item->getOrigin().x, 1.0f);
    else
        entry.data.item->setOrigin(entry.data.item->getOrigin().x, 0.5f);

    glm::vec2 denormalized {glm::round(mItemSize * entry.data.item->getOrigin())};
    entry.data.item->setPosition(glm::vec3 {denormalized.x, denormalized.y, 0.0f});

    List::add(entry);
}

template <typename T>
void CarouselComponent<T>::updateEntry(Entry& entry, const std::shared_ptr<ThemeData>& theme)
{
    if (entry.data.imagePath != "") {
        auto item = std::make_shared<ImageComponent>(false, true);
        item->setLinearInterpolation(mLinearInterpolation);
        item->setMipmapping(true);
        if (mImagefit == ImageFit::CONTAIN) {
            item->setMaxSize(glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
        }
        else if (mImagefit == ImageFit::FILL) {
            item->setResize(glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
        }
        else if (mImagefit == ImageFit::COVER) {
            item->setCropPos(mImageCropPos);
            item->setCroppedSize(glm::round(mItemSize * (mItemScale >= 1.0f ? mItemScale : 1.0f)));
        }
        item->setCornerRadius(mImageCornerRadius);
        item->setImage(entry.data.imagePath);
        if (mImageBrightness != 0.0)
            item->setBrightness(mImageBrightness);
        if (mImageSaturation != 1.0)
            item->setSaturation(mImageSaturation);
        if (mImageColorShift != 0xFFFFFFFF)
            item->setColorShift(mImageColorShift);
        if (mImageColorShiftEnd != mImageColorShift)
            item->setColorShiftEnd(mImageColorShiftEnd);
        if (!mImageColorGradientHorizontal)
            item->setColorGradientHorizontal(false);
        item->setRotateByTargetSize(true);
        entry.data.item = item;
    }
    else {
        return;
    }

    // Set origin for the items based on their alignment so they line up properly.
    if (mItemHorizontalAlignment == ALIGN_LEFT)
        entry.data.item->setOrigin(0.0f, 0.5f);
    else if (mItemHorizontalAlignment == ALIGN_RIGHT)
        entry.data.item->setOrigin(1.0f, 0.5f);
    else
        entry.data.item->setOrigin(0.5f, 0.5f);

    if (mItemVerticalAlignment == ALIGN_TOP)
        entry.data.item->setOrigin(entry.data.item->getOrigin().x, 0.0f);
    else if (mItemVerticalAlignment == ALIGN_BOTTOM)
        entry.data.item->setOrigin(entry.data.item->getOrigin().x, 1.0f);
    else
        entry.data.item->setOrigin(entry.data.item->getOrigin().x, 0.5f);

    glm::vec2 denormalized {glm::round(mItemSize * entry.data.item->getOrigin())};
    entry.data.item->setPosition(glm::vec3 {denormalized.x, denormalized.y, 0.0f});
}

template <typename T> void CarouselComponent<T>::onDemandTextureLoad()
{
    if constexpr (std::is_same_v<T, FileData*>) {
        if (size() == 0)
            return;

        if (mImageTypes.empty())
            mImageTypes.emplace_back("marquee");

        const int numEntries {size()};
        const int center {getCursor()};
        const bool isWheel {mType == CarouselType::VERTICAL_WHEEL ||
                            mType == CarouselType::HORIZONTAL_WHEEL};
        int centerOffset {0};
        int itemInclusion {0};
        int itemInclusionBefore {0};
        int itemInclusionAfter {0};

        if (isWheel) {
            itemInclusion = 1;
            itemInclusionBefore = mItemsBeforeCenter - 1;
            itemInclusionAfter = mItemsAfterCenter;
        }
        else {
            itemInclusion = static_cast<int>(std::ceil((mMaxItemCount + 1) / 2.0f));
            itemInclusionBefore = -1;
            // If the carousel is offset we need to load additional textures to fully populate
            // the visible entries.
            if (mType == CarouselType::HORIZONTAL && mHorizontalOffset != 0.0f) {
                const float itemSpacing {
                    ((mSize.x - (mItemSize.x * mMaxItemCount)) / mMaxItemCount) + mItemSize.x};

                centerOffset = static_cast<int>(std::ceil(mSize.x * std::fabs(mHorizontalOffset) /
                                                          std::min(mItemSize.x, itemSpacing)));
                if (mHorizontalOffset < 0.0f)
                    itemInclusionAfter += centerOffset;
                else
                    itemInclusionBefore += centerOffset;

                if (mHorizontalOffset > 0.0f)
                    centerOffset = -centerOffset;
            }
            else if (mType == CarouselType::VERTICAL && mVerticalOffset != 0.0f) {
                const float itemSpacing {
                    ((mSize.y - (mItemSize.y * mMaxItemCount)) / mMaxItemCount) + mItemSize.y};

                centerOffset = static_cast<int>(std::ceil(mSize.y * std::fabs(mVerticalOffset) /
                                                          std::min(mItemSize.y, itemSpacing)));
                if (mVerticalOffset < 0.0f)
                    itemInclusionAfter += centerOffset;
                else
                    itemInclusionBefore += centerOffset;

                if (mVerticalOffset > 0.0f)
                    centerOffset = -centerOffset;
            }
            itemInclusion += 1;
        }

        for (int i {center - itemInclusion - itemInclusionBefore};
             i < center + itemInclusion + itemInclusionAfter; ++i) {
            int cursor {i};

            while (cursor < 0)
                cursor += numEntries;
            while (cursor >= numEntries)
                cursor -= numEntries;

            auto& entry = mEntries.at(cursor);

            if (entry.data.imagePath == "") {
                FileData* game {entry.object};

                for (auto& imageType : mImageTypes) {
                    if (imageType == "marquee")
                        entry.data.imagePath = game->getMarqueePath();
                    else if (imageType == "cover")
                        entry.data.imagePath = game->getCoverPath();
                    else if (imageType == "backcover")
                        entry.data.imagePath = game->getBackCoverPath();
                    else if (imageType == "3dbox")
                        entry.data.imagePath = game->get3DBoxPath();
                    else if (imageType == "physicalmedia")
                        entry.data.imagePath = game->getPhysicalMediaPath();
                    else if (imageType == "screenshot")
                        entry.data.imagePath = game->getScreenshotPath();
                    else if (imageType == "titlescreen")
                        entry.data.imagePath = game->getTitleScreenPath();
                    else if (imageType == "miximage")
                        entry.data.imagePath = game->getMiximagePath();
                    else if (imageType == "fanart")
                        entry.data.imagePath = game->getFanArtPath();
                    else if (imageType == "none") // Display the game name as text.
                        break;

                    if (entry.data.imagePath != "")
                        break;
                }

                if (entry.data.imagePath == "")
                    entry.data.imagePath = entry.data.defaultImagePath;

                auto theme = game->getSystem()->getTheme();
                updateEntry(entry, theme);
            }
        }
    }
}

template <typename T> bool CarouselComponent<T>::input(InputConfig* config, Input input)
{
    if (input.value != 0) {
        switch (mType) {
            case CarouselType::VERTICAL:
            case CarouselType::VERTICAL_WHEEL:
                if (config->isMappedLike("up", input)) {
                    if (mCancelTransitionsCallback)
                        mCancelTransitionsCallback();
                    List::listInput(-1);
                    return true;
                }
                if (config->isMappedLike("down", input)) {
                    if (mCancelTransitionsCallback)
                        mCancelTransitionsCallback();
                    List::listInput(1);
                    return true;
                }
                break;
            case CarouselType::HORIZONTAL:
            case CarouselType::HORIZONTAL_WHEEL:
            default:
                if (config->isMappedLike("left", input)) {
                    if (mCancelTransitionsCallback)
                        mCancelTransitionsCallback();
                    List::listInput(-1);
                    return true;
                }
                if (config->isMappedLike("right", input)) {
                    if (mCancelTransitionsCallback)
                        mCancelTransitionsCallback();
                    List::listInput(1);
                    return true;
                }
                break;
        }
        if (mGamelistView) {
            if (config->isMappedLike("leftshoulder", input)) {
                if (mCancelTransitionsCallback)
                    mCancelTransitionsCallback();
                if (mEntries.size() < 10 && getCursor() != 0) {
                    mTriggerJump = true;
                    return this->listFirstRow();
                }
                else {
                    List::listInput(-10);
                    return true;
                }
            }
            if (config->isMappedLike("rightshoulder", input)) {
                if (mCancelTransitionsCallback)
                    mCancelTransitionsCallback();
                if (mEntries.size() < 10 && getCursor() != static_cast<int>(mEntries.size()) - 1) {
                    mTriggerJump = true;
                    return this->listLastRow();
                }
                else {
                    List::listInput(10);
                    return true;
                }
            }
            if (config->isMappedLike("lefttrigger", input)) {
                if (getCursor() == 0)
                    return true;
                mTriggerJump = true;
                if (mCancelTransitionsCallback)
                    mCancelTransitionsCallback();
                return this->listFirstRow();
            }
            if (config->isMappedLike("righttrigger", input)) {
                if (getCursor() == static_cast<int>(mEntries.size()) - 1)
                    return true;
                mTriggerJump = true;
                if (mCancelTransitionsCallback)
                    mCancelTransitionsCallback();
                return this->listLastRow();
            }
        }
    }
    else {
        if (mGamelistView) {
            if (config->isMappedLike("up", input) || config->isMappedLike("down", input) ||
                config->isMappedLike("left", input) || config->isMappedLike("right", input) ||
                config->isMappedLike("leftshoulder", input) ||
                config->isMappedLike("rightshoulder", input) ||
                config->isMappedLike("lefttrigger", input) ||
                config->isMappedLike("righttrigger", input)) {
                if (isScrolling())
                    onCursorChanged(CursorState::CURSOR_STOPPED);
                List::listInput(0);
                mTriggerJump = false;
            }
        }
        else {
            if (config->isMappedLike("up", input) || config->isMappedLike("down", input) ||
                config->isMappedLike("left", input) || config->isMappedLike("right", input)) {
                if (isScrolling())
                    onCursorChanged(CursorState::CURSOR_STOPPED);
                List::listInput(0);
            }
        }
    }

    return GuiComponent::input(config, input);
}

template <typename T> void CarouselComponent<T>::update(int deltaTime)
{
    mEntries.at(mCursor).data.item->update(deltaTime);
    List::listUpdate(deltaTime);
    GuiComponent::update(deltaTime);
}

template <typename T> void CarouselComponent<T>::render(const glm::mat4& parentTrans)
{
    const float camOffset {mInstantItemTransitions ? mEntryCamTarget : mEntryCamOffset};

    int numEntries {static_cast<int>(mEntries.size())};
    if (numEntries == 0)
        return;

    glm::mat4 carouselTrans {parentTrans};
    carouselTrans = glm::translate(
        carouselTrans, glm::vec3 {GuiComponent::mPosition.x, GuiComponent::mPosition.y, 0.0f});
    carouselTrans =
        glm::translate(carouselTrans, glm::vec3 {GuiComponent::mOrigin.x * mSize.x * -1.0f,
                                                 GuiComponent::mOrigin.y * mSize.y * -1.0f, 0.0f});

    if (carouselTrans[3].x + mSize.x <= 0.0f || carouselTrans[3].y + mSize.y <= 0.0f)
        return;

    const float sizeX {carouselTrans[3].x < 0.0f ? mSize.x + carouselTrans[3].x : mSize.x};
    const float sizeY {carouselTrans[3].y < 0.0f ? mSize.y + carouselTrans[3].y : mSize.y};

    glm::ivec2 clipPos {static_cast<int>(glm::clamp(std::round(carouselTrans[3].x), 0.0f,
                                                    mRenderer->getScreenWidth())),
                        static_cast<int>(glm::clamp(std::round(carouselTrans[3].y), 0.0f,
                                                    mRenderer->getScreenHeight()))};
    glm::ivec2 clipDim {
        static_cast<int>(std::min(std::round(sizeX), mRenderer->getScreenWidth())),
        static_cast<int>(std::min(std::round(sizeY), mRenderer->getScreenHeight()))};

    mRenderer->pushClipRect(clipPos, clipDim);
    mRenderer->setMatrix(carouselTrans);

    // In image debug mode, draw a green rectangle covering the entire carousel area.
    if (Settings::getInstance()->getBool("DebugImage"))
        mRenderer->drawRect(0.0f, 0.0f, mSize.x, mSize.y, 0x00FF0033, 0x00FF0033);

    // Background box behind the items.
    mRenderer->drawRect(0.0f, 0.0f, mSize.x, mSize.y, mCarouselColor, mCarouselColorEnd,
                        mColorGradientHorizontal);

    const bool isWheel {mType == CarouselType::VERTICAL_WHEEL ||
                        mType == CarouselType::HORIZONTAL_WHEEL};

    // Draw the items.
    // itemSpacing will also include the size of the item itself.
    glm::vec2 itemSpacing {0.0f, 0.0f};
    float xOff {0.0f};
    float yOff {0.0f};
    float scaleSize {0.0f};

    if (mType == CarouselType::HORIZONTAL_WHEEL)
        scaleSize = mItemSize.y * mItemScale - mItemSize.y;
    else
        scaleSize = mItemSize.x * mItemScale - mItemSize.x;

    if (isWheel) {
        // Alignment of the actual carousel inside to the overall component area.
        if (mType == CarouselType::HORIZONTAL_WHEEL) {
            xOff = (mSize.x / 2.0f) - (mItemSize.y / 2.0f);
            if (mWheelVerticalAlignment == ALIGN_CENTER) {
                yOff = (mSize.y / 2.0f) + (mItemSize.x / 2.0f);
                if (mItemVerticalAlignment == ALIGN_TOP)
                    yOff -= scaleSize / 2.0f;
                else if (mItemVerticalAlignment == ALIGN_BOTTOM)
                    yOff += scaleSize / 2.0f;
            }
            else if (mWheelVerticalAlignment == ALIGN_TOP) {
                yOff = mItemSize.x - ((mItemSize.x - mItemSize.y) / 2.0f);
                if (mItemVerticalAlignment == ALIGN_CENTER)
                    yOff += scaleSize / 2.0f;
                else if (mItemVerticalAlignment == ALIGN_BOTTOM)
                    yOff += scaleSize;
            }
            else if (mWheelVerticalAlignment == ALIGN_BOTTOM) {
                yOff = mSize.y + ((mItemSize.x - mItemSize.y) / 2.0f);
                if (mItemVerticalAlignment == ALIGN_CENTER)
                    yOff -= scaleSize / 2.0f;
                else if (mItemVerticalAlignment == ALIGN_TOP)
                    yOff -= scaleSize / 1.0f;
            }
        }
        else {
            xOff = (mSize.x - mItemSize.x) / 2.0f;
            yOff = (mSize.y - mItemSize.y) / 2.0f;
            if (mWheelHorizontalAlignment == ALIGN_RIGHT) {
                xOff += mSize.x / 2.0f;
                if (mItemHorizontalAlignment == ALIGN_LEFT)
                    xOff -= mItemSize.x / 2.0f + scaleSize;
                else if (mItemHorizontalAlignment == ALIGN_RIGHT)
                    xOff -= mItemSize.x / 2.0f;
                else
                    xOff -= mItemSize.x / 2.0f + scaleSize / 2.0f;
            }
            else if (mWheelHorizontalAlignment == ALIGN_LEFT) {
                xOff -= (mSize.x / 2.0f);
                if (mItemHorizontalAlignment == ALIGN_LEFT)
                    xOff += mItemSize.x / 2.0f;
                else if (mItemHorizontalAlignment == ALIGN_RIGHT)
                    xOff += mItemSize.x / 2.0f + scaleSize;
                else
                    xOff += mItemSize.x / 2.0f + scaleSize / 2.0f;
            }
            else if (mWheelHorizontalAlignment == ALIGN_CENTER &&
                     mItemHorizontalAlignment != ALIGN_CENTER) {
                if (mItemHorizontalAlignment == ALIGN_RIGHT)
                    xOff += scaleSize / 2.0f;
                else if (mItemHorizontalAlignment == ALIGN_LEFT)
                    xOff -= scaleSize / 2.0f;
            }
        }
    }
    else if (mType == CarouselType::VERTICAL) {
        itemSpacing.y = ((mSize.y - (mItemSize.y * mMaxItemCount)) / mMaxItemCount) + mItemSize.y;
        yOff = (mSize.y - mItemSize.y) / 2.0f - (camOffset * itemSpacing.y);
        if (mItemHorizontalAlignment == ALIGN_LEFT)
            xOff = 0.0f;
        else if (mItemHorizontalAlignment == ALIGN_RIGHT)
            xOff = mSize.x - mItemSize.x;
        else
            xOff = (mSize.x - mItemSize.x) / 2.0f;
    }
    else { // HORIZONTAL.
        itemSpacing.x = ((mSize.x - (mItemSize.x * mMaxItemCount)) / mMaxItemCount) + mItemSize.x;
        xOff = (mSize.x - mItemSize.x) / 2.0f - (camOffset * itemSpacing.x);
        if (mItemVerticalAlignment == ALIGN_TOP)
            yOff = 0.0f;
        else if (mItemVerticalAlignment == ALIGN_BOTTOM)
            yOff = mSize.y - mItemSize.y - (mReflections ? ((mItemSize.y * mItemScale)) : 0.0f);
        else
            yOff = (mSize.y - (mItemSize.y * (mReflections ? 2.0f : 1.0f))) / 2.0f;
    }

    xOff += mSize.x * mHorizontalOffset;
    yOff += mSize.y * mVerticalOffset;

    int center {0};
    int centerOffset {0};
    // Needed to make sure that overlapping items are renderered correctly.
    if (mPositiveDirection)
        center = static_cast<int>(std::floor(camOffset));
    else
        center = static_cast<int>(std::ceil(camOffset));

    int itemInclusion {0};
    int itemInclusionBefore {0};
    int itemInclusionAfter {0};

    if (mType == CarouselType::HORIZONTAL || mType == CarouselType::VERTICAL) {
        itemInclusion = static_cast<int>(std::ceil(mMaxItemCount / 2.0f)) + 1;
        itemInclusionAfter = 2;
        // If the carousel is offset we need to calculate the center offset so the items are
        // rendered in the correct order (as seen when overlapping).
        if (mType == CarouselType::HORIZONTAL && mHorizontalOffset != 0.0f) {
            centerOffset = static_cast<int>(std::ceil(mSize.x * std::fabs(mHorizontalOffset) /
                                                      std::min(mItemSize.x, itemSpacing.x)));
            if (mHorizontalOffset < 0.0f)
                itemInclusionAfter += centerOffset;
            else
                itemInclusionBefore += centerOffset;

            if (mHorizontalOffset > 0.0f)
                centerOffset = -centerOffset;
        }
        else if (mType == CarouselType::VERTICAL && mVerticalOffset != 0.0f) {
            centerOffset = static_cast<int>(std::ceil(mSize.y * std::fabs(mVerticalOffset) /
                                                      std::min(mItemSize.y, itemSpacing.y)));
            if (mVerticalOffset < 0.0f)
                itemInclusionAfter += centerOffset;
            else
                itemInclusionBefore += centerOffset;

            if (mVerticalOffset > 0.0f)
                centerOffset = -centerOffset;
        }
    }
    else {
        // For the wheel types.
        itemInclusion = 1;
        itemInclusionBefore = mItemsBeforeCenter - 1;
        itemInclusionAfter = mItemsAfterCenter;
    }

    const bool singleEntry {numEntries == 1};

    struct renderStruct {
        int index;
        float distance;
        float scale;
        float opacity;
        float saturation;
        float dimming;
        glm::mat4 trans;
    };

    std::vector<renderStruct> renderItems;
    std::vector<renderStruct> renderItemsSorted;

    for (int i {center - itemInclusion - itemInclusionBefore};
         i < center + itemInclusion + itemInclusionAfter; ++i) {
        int index {i};

        while (index < 0)
            index += numEntries;
        while (index >= numEntries)
            index -= numEntries;

        float distance {i - camOffset};

        if (singleEntry)
            distance = 0.0f;

        float scale {0.0f};

        if (mItemScale >= 1.0f) {
            scale = 1.0f + ((mItemScale - 1.0f) * (1.0f - fabsf(distance)));
            scale = std::min(mItemScale, std::max(1.0f, scale));
            scale /= mItemScale;
        }
        else {
            scale = 1.0f + ((1.0f - mItemScale) * (fabsf(distance) - 1.0f));
            scale = std::max(mItemScale, std::min(1.0f, scale));
        }

        glm::vec2 selectedItemMargins {0.0f, 0.0f};

        if (mSelectedItemMargins != glm::vec2 {0.0f, 0.0f}) {
            if (i < camOffset) {
                if (mType == CarouselType::HORIZONTAL)
                    selectedItemMargins.x = -mSelectedItemMargins.x;
                else
                    selectedItemMargins.y = -mSelectedItemMargins.x;
            }
            else if (i > camOffset) {
                if (mType == CarouselType::HORIZONTAL)
                    selectedItemMargins.x = mSelectedItemMargins.y;
                else
                    selectedItemMargins.y = mSelectedItemMargins.y;
            }

            if (std::fabs(distance) < 1.0f)
                selectedItemMargins *= std::fabs(distance);
        }

        float itemHorizontalOffset {0.0f};
        float itemVerticallOffset {0.0f};

        if ((mSelectedItemOffset.x != 0.0f || mSelectedItemOffset.y != 0.0f) &&
            std::fabs(distance) < 1.0f) {
            itemHorizontalOffset = (1.0f - std::fabs(distance)) * mSelectedItemOffset.x;
            itemVerticallOffset = (1.0f - std::fabs(distance)) * mSelectedItemOffset.y;
        }

        glm::mat4 itemTrans {carouselTrans};
        if (singleEntry)
            itemTrans = glm::translate(carouselTrans, glm::vec3 {xOff, yOff, 0.0f});
        else
            itemTrans = glm::translate(
                itemTrans,
                glm::vec3 {(i * itemSpacing.x) + xOff + itemHorizontalOffset +
                               selectedItemMargins.x,
                           (i * itemSpacing.y) + yOff + itemVerticallOffset + selectedItemMargins.y,
                           0.0f});

        if (mType == CarouselType::HORIZONTAL_WHEEL)
            itemTrans = glm::rotate(itemTrans, glm::radians(-90.0f), glm::vec3 {0.0f, 0.0f, 1.0f});

        float opacity {0.0f};
        float saturation {0.0f};
        float dimming {0.0f};

        if (distance == 0.0f || mUnfocusedItemOpacity == 1.0f) {
            opacity = 1.0f;
        }
        else if (fabsf(distance) >= 1.0f) {
            opacity = mUnfocusedItemOpacity;
        }
        else {
            const float maxDiff {1.0f - mUnfocusedItemOpacity};
            opacity = mUnfocusedItemOpacity + (maxDiff - (maxDiff * fabsf(distance)));
        }

        if (mHasUnfocusedItemSaturation) {
            if (distance == 0.0f) {
                saturation = mImageSaturation;
            }
            else if (fabsf(distance) >= 1.0f) {
                saturation = mUnfocusedItemSaturation;
            }
            else {
                const float maxDiff {mImageSaturation - mUnfocusedItemSaturation};
                saturation = mUnfocusedItemSaturation + (maxDiff - (maxDiff * fabsf(distance)));
            }
        }

        if (distance == 0.0f || mUnfocusedItemDimming == 1.0f) {
            dimming = 1.0f;
        }
        else if (fabsf(distance) >= 1.0f) {
            dimming = mUnfocusedItemDimming;
        }
        else {
            const float maxDiff {1.0f - mUnfocusedItemDimming};
            dimming = mUnfocusedItemDimming + (maxDiff - (maxDiff * fabsf(distance)));
        }

        renderStruct renderItem;
        renderItem.index = index;
        renderItem.distance = distance;
        renderItem.scale = scale;
        renderItem.opacity = opacity;
        renderItem.saturation = saturation;
        renderItem.dimming = dimming;
        renderItem.trans = itemTrans;

        renderItems.emplace_back(renderItem);

        if (singleEntry)
            break;
    }

    int belowCenter {static_cast<int>(std::round((renderItems.size() - centerOffset - 1) / 2))};
    if (renderItems.size() == 1) {
        renderItemsSorted.emplace_back(renderItems.front());
    }
    else if (!isWheel && mItemStacking != ItemStacking::CENTERED) {
        if (mItemStacking == ItemStacking::ASCENDING) {
            renderItemsSorted.insert(renderItemsSorted.begin(),
                                     std::make_move_iterator(renderItems.begin()),
                                     std::make_move_iterator(renderItems.end()));
        }
        else if (mItemStacking == ItemStacking::ASCENDING_RAISED) {
            for (size_t i {0}; i < renderItems.size(); ++i) {
                if (i == static_cast<size_t>(belowCenter))
                    continue;
                renderItemsSorted.emplace_back(std::move(renderItems[i]));
            }
            renderItemsSorted.emplace_back(std::move(renderItems[belowCenter]));
        }
        else if (mItemStacking == ItemStacking::DESCENDING) {
            for (size_t i {renderItems.size()}; i > 0; --i)
                renderItemsSorted.emplace_back(std::move(renderItems[i - 1]));
        }
        else if (mItemStacking == ItemStacking::DESCENDING_RAISED) {
            for (size_t i {renderItems.size()}; i > 0; --i) {
                if (i - 1 == static_cast<size_t>(belowCenter))
                    continue;
                renderItemsSorted.emplace_back(std::move(renderItems[i - 1]));
            }
            renderItemsSorted.emplace_back(std::move(renderItems[belowCenter]));
        }
    }
    else {
        // Make sure that overlapping items are rendered in the correct order.
        size_t zeroDistanceEntry {0};

        for (int i = 0; i < belowCenter; ++i)
            renderItemsSorted.emplace_back(renderItems[i]);

        for (int i = static_cast<int>(renderItems.size()) - 1; i > belowCenter - 1; --i) {
            if (isWheel && (mPositiveDirection ? std::ceil(renderItems[i].distance) :
                                                 std::floor(renderItems[i].distance)) == 0) {
                zeroDistanceEntry = i;
                continue;
            }
            renderItemsSorted.emplace_back(renderItems[i]);
        }

        if (isWheel)
            renderItemsSorted.emplace_back(renderItems[zeroDistanceEntry]);
    }

    for (auto& renderItem : renderItemsSorted) {
        const std::shared_ptr<GuiComponent>& comp {mEntries.at(renderItem.index).data.item};

        if (comp == nullptr)
            continue;

        if (isWheel) {
            glm::mat4 positionCalc {renderItem.trans};
            const float xOffTrans {-mItemRotationOrigin.x * mItemSize.x};
            const float yOffTrans {mItemAxisHorizontal ? 0.0f :
                                                         -mItemRotationOrigin.y * mItemSize.y};

            // Transform to offset point.
            positionCalc = glm::translate(positionCalc,
                                          glm::vec3 {xOffTrans * -1.0f, yOffTrans * -1.0f, 0.0f});

            // Apply rotation transform.
            positionCalc =
                glm::rotate(positionCalc, glm::radians(mItemRotation * renderItem.distance),
                            glm::vec3 {0.0f, 0.0f, 1.0f});

            // Transform back to original point.
            positionCalc = glm::translate(positionCalc, glm::vec3 {xOffTrans, yOffTrans, 0.0f});

            if (mItemAxisHorizontal) {
                // Only keep position and discard the rotation data.
                renderItem.trans[3].x = positionCalc[3].x;
                renderItem.trans[3].y = positionCalc[3].y;

                if (mType == CarouselType::HORIZONTAL_WHEEL) {
                    // For horizontal wheels we need to rotate all items 90 degrees around their
                    // own axis.
                    const float xOffTransRotate {-(mItemSize.x / 2.0f)};
                    const float yOffTransRotate {-(mItemSize.y / 2.0f)};

                    renderItem.trans =
                        glm::translate(renderItem.trans, glm::vec3 {xOffTransRotate * -1.0f,
                                                                    yOffTransRotate * -1.0f, 0.0f});

                    renderItem.trans = glm::rotate(renderItem.trans, glm::radians(90.0f),
                                                   glm::vec3 {0.0f, 0.0f, 1.0f});

                    renderItem.trans = glm::translate(
                        renderItem.trans, glm::vec3 {xOffTransRotate, yOffTransRotate, 0.0f});
                }
            }
            else if (mType == CarouselType::HORIZONTAL_WHEEL) {
                renderItem.trans = positionCalc;
                renderItem.trans = positionCalc;
                const float xOffTransRotate {-(mItemSize.x / 2.0f)};
                const float yOffTransRotate {-(mItemSize.y / 2.0f)};

                renderItem.trans =
                    glm::translate(renderItem.trans, glm::vec3 {xOffTransRotate * -1.0f,
                                                                yOffTransRotate * -1.0f, 0.0f});

                renderItem.trans = glm::rotate(renderItem.trans, glm::radians(90.0f),
                                               glm::vec3 {0.0f, 0.0f, 1.0f});

                renderItem.trans = glm::translate(
                    renderItem.trans, glm::vec3 {xOffTransRotate, yOffTransRotate, 0.0f});
            }
            else {
                renderItem.trans = positionCalc;
                renderItem.trans = positionCalc;
            }
        }
        else if (mItemAxisRotation != 0.0f) {
            // Rotate items around their own axis.
            const float xOffTransRotate {-(mItemSize.x / 2.0f)};
            const float yOffTransRotate {-(mItemSize.y / 2.0f)};

            renderItem.trans =
                glm::translate(renderItem.trans,
                               glm::vec3 {xOffTransRotate * -1.0f, yOffTransRotate * -1.0f, 0.0f});

            renderItem.trans = glm::rotate(renderItem.trans, glm::radians(mItemAxisRotation),
                                           glm::vec3 {0.0f, 0.0f, 1.0f});

            renderItem.trans = glm::translate(renderItem.trans,
                                              glm::vec3 {xOffTransRotate, yOffTransRotate, 0.0f});
        }

        float metadataOpacity {1.0f};

        if constexpr (std::is_same_v<T, FileData*>) {
            // If a game is marked as hidden, lower the opacity a lot.
            // If a game is marked to not be counted, lower the opacity a moderate amount.
            if (mEntries.at(renderItem.index).object->getHidden())
                metadataOpacity = 0.4f;
            else if (!mEntries.at(renderItem.index).object->getCountAsGame())
                metadataOpacity = 0.7f;
        }

        const glm::vec3 origPos {comp->getPosition()};
        if (mItemDiagonalOffset != 0.0f) {
            if (mType == CarouselType::HORIZONTAL)
                comp->setPosition(
                    origPos.x, origPos.y - (mItemDiagonalOffset * renderItem.distance), origPos.z);
            else
                comp->setPosition(origPos.x - (mItemDiagonalOffset * renderItem.distance),
                                  origPos.y, origPos.z);
        }

        comp->setScale(renderItem.scale);
        comp->setOpacity(renderItem.opacity * metadataOpacity);
        if (mHasUnfocusedItemSaturation)
            comp->setSaturation(renderItem.saturation);
        if (mUnfocusedItemDimming != 1.0f)
            comp->setDimming(renderItem.dimming);
        if (renderItem.index == mCursor && std::abs(renderItem.distance) < 1.0f &&
            (mHasImageSelectedColor || mHasTextSelectedColor)) {
            if (mHasTextSelectedColor && mEntries.at(renderItem.index).data.imagePath == "" &&
                mEntries.at(renderItem.index).data.defaultImagePath == "") {
                comp->setColor(mTextSelectedColor);
                if (mTextSelectedBackgroundColor != mTextBackgroundColor)
                    comp->setBackgroundColor(mTextSelectedBackgroundColor);
                comp->render(renderItem.trans);
                comp->setColor(mTextColor);
                if (mTextSelectedBackgroundColor != mTextBackgroundColor)
                    comp->setBackgroundColor(mTextBackgroundColor);
            }
            else if (mHasImageSelectedColor) {
                comp->setColorShift(mImageSelectedColor);
                if (mImageSelectedColorEnd != mImageSelectedColor)
                    comp->setColorShiftEnd(mImageSelectedColorEnd);
                if (mImageSelectedColorGradientHorizontal != mImageColorGradientHorizontal)
                    comp->setColorGradientHorizontal(mImageSelectedColorGradientHorizontal);
                comp->render(renderItem.trans);
                if (mImageSelectedColorGradientHorizontal != mImageColorGradientHorizontal)
                    comp->setColorGradientHorizontal(mImageColorGradientHorizontal);
                comp->setColorShift(mImageColorShift);
                if (mImageColorShiftEnd != mImageColorShift)
                    comp->setColorShiftEnd(mImageColorShiftEnd);
            }
            else {
                comp->render(renderItem.trans);
            }
        }
        else {
            comp->render(renderItem.trans);
        }

        if (mItemDiagonalOffset != 0.0f)
            comp->setPosition(origPos);

        // TODO: Rewrite to use "real" reflections instead of this hack.
        // Don't attempt to add reflections for text entries.
        if (mReflections && (mEntries.at(renderItem.index).data.imagePath != "" ||
                             mEntries.at(renderItem.index).data.defaultImagePath != "")) {
            glm::mat4 reflectionTrans {glm::translate(
                renderItem.trans, glm::vec3 {0.0f, comp->getSize().y * renderItem.scale, 0.0f})};
            float falloff {glm::clamp(mReflectionsFalloff, 0.0f, 1.0f)};
            falloff = mReflectionsOpacity * (1.0f - falloff);
            comp->setOpacity(comp->getOpacity() * mReflectionsOpacity);
            if (mHasUnfocusedItemSaturation)
                comp->setSaturation(renderItem.saturation);
            if (mUnfocusedItemDimming != 1.0f)
                comp->setDimming(renderItem.dimming);
            if (mReflectionsFalloff > 0.0f)
                comp->setReflectionsFalloff(comp->getSize().y / mReflectionsFalloff);
            comp->setFlipY(true);
            if (renderItem.index == mCursor && mHasImageSelectedColor) {
                comp->setColorShift(mImageSelectedColorGradientHorizontal ? mImageSelectedColor :
                                                                            mImageSelectedColorEnd);
                if (mImageSelectedColorEnd != mImageSelectedColor)
                    comp->setColorShiftEnd(mImageSelectedColorGradientHorizontal ?
                                               mImageSelectedColorEnd :
                                               mImageSelectedColor);
                if (mImageSelectedColorGradientHorizontal != mImageColorGradientHorizontal)
                    comp->setColorGradientHorizontal(mImageSelectedColorGradientHorizontal);
                comp->render(reflectionTrans);
                if (mImageSelectedColorGradientHorizontal != mImageColorGradientHorizontal)
                    comp->setColorGradientHorizontal(mImageColorGradientHorizontal);
                comp->setColorShift(mImageColorShift);
                if (mImageColorShiftEnd != mImageColorShift)
                    comp->setColorShiftEnd(mImageColorShiftEnd);
            }
            else {
                if ((mImageColorShift != 0xFFFFFFFF || mImageColorShiftEnd != 0xFFFFFFFF) &&
                    !mImageColorGradientHorizontal) {
                    // We need to reverse the color shift if a vertical gradient is applied.
                    comp->setColorShift(mImageColorShiftEnd);
                    comp->setColorShiftEnd(mImageColorShift);
                    comp->render(reflectionTrans);
                    comp->setColorShift(mImageColorShift);
                    comp->setColorShiftEnd(mImageColorShiftEnd);
                }
                else {
                    comp->render(reflectionTrans);
                }
            }
            comp->setFlipY(false);
            comp->setReflectionsFalloff(0.0f);
        }

        if (singleEntry)
            break;
    }
    mRenderer->popClipRect();
}

template <typename T>
void CarouselComponent<T>::applyTheme(const std::shared_ptr<ThemeData>& theme,
                                      const std::string& view,
                                      const std::string& element,
                                      unsigned int properties)
{
    mSize.x = Renderer::getScreenWidth();
    mSize.y = Renderer::getScreenHeight() * 0.23240f;
    GuiComponent::mPosition.x = 0.0f;
    GuiComponent::mPosition.y = Renderer::getScreenHeight() * 0.38378f;
    mCarouselColor = 0xFFFFFFD8;
    mCarouselColorEnd = 0xFFFFFFD8;
    mZIndex = mDefaultZIndex;

    using namespace ThemeFlags;
    const ThemeData::ThemeElement* elem {theme->getElement(view, element, "carousel")};

    if (!elem)
        return;

    if (elem->has("type")) {
        std::string type {elem->get<std::string>("type")};
        if (type == "horizontal") {
            mType = CarouselType::HORIZONTAL;
        }
        else if (type == "horizontalWheel") {
            mType = CarouselType::HORIZONTAL_WHEEL;
        }
        else if (type == "vertical") {
            mType = CarouselType::VERTICAL;
        }
        else if (type == "verticalWheel") {
            mType = CarouselType::VERTICAL_WHEEL;
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property \"type\" "
                               "for element \""
                            << element.substr(9) << "\" defined as \"" << type << "\"";
            mType = CarouselType::HORIZONTAL;
        }
    }

    if (mGamelistView && properties && elem->has("imageType")) {
        const std::vector<std::string> supportedImageTypes {
            "marquee",    "cover",       "backcover", "3dbox",  "physicalmedia",
            "screenshot", "titlescreen", "miximage",  "fanart", "none"};
        std::string imageTypesString {elem->get<std::string>("imageType")};

        for (auto& character : imageTypesString) {
            if (std::isspace(character))
                character = ',';
        }
        imageTypesString = Utils::String::replace(imageTypesString, ",,", ",");
        mImageTypes = Utils::String::delimitedStringToVector(imageTypesString, ",");

        // Only allow two imageType entries due to performance reasons.
        if (mImageTypes.size() > 2)
            mImageTypes.erase(mImageTypes.begin() + 2, mImageTypes.end());

        if (mImageTypes.empty()) {
            LOG(LogWarning)
                << "CarouselComponent: Invalid theme configuration, property \"imageType\" "
                   "for element \""
                << element.substr(9) << "\" contains no values";
        }

        for (std::string& type : mImageTypes) {
            if (std::find(supportedImageTypes.cbegin(), supportedImageTypes.cend(), type) ==
                supportedImageTypes.cend()) {
                LOG(LogWarning)
                    << "CarouselComponent: Invalid theme configuration, property \"imageType\" "
                       "for element \""
                    << element.substr(9) << "\" defined as \"" << type << "\"";
                mImageTypes.clear();
                break;
            }
        }

        if (mImageTypes.size() == 2 && mImageTypes.front() == mImageTypes.back()) {
            LOG(LogError)
                << "CarouselComponent: Invalid theme configuration, property \"imageType\" "
                   "for element \""
                << element.substr(9) << "\" contains duplicate values";
            mImageTypes.clear();
        }
    }

    if (elem->has("color")) {
        mCarouselColor = elem->get<unsigned int>("color");
        mCarouselColorEnd = mCarouselColor;
    }
    if (elem->has("colorEnd"))
        mCarouselColorEnd = elem->get<unsigned int>("colorEnd");

    if (elem->has("gradientType")) {
        const std::string& gradientType {elem->get<std::string>("gradientType")};
        if (gradientType == "horizontal") {
            mColorGradientHorizontal = true;
        }
        else if (gradientType == "vertical") {
            mColorGradientHorizontal = false;
        }
        else {
            mColorGradientHorizontal = true;
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"gradientType\" for element \""
                            << element.substr(9) << "\" defined as \"" << gradientType << "\"";
        }
    }

    mLinearInterpolation = true;

    if (elem->has("maxItemCount")) {
        mMaxItemCount = glm::clamp(elem->get<float>("maxItemCount"), 0.5f, 30.0f);
        if (mType == CarouselType::HORIZONTAL_WHEEL || mType == CarouselType::VERTICAL_WHEEL) {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"maxItemCount\" for element \""
                            << element.substr(9) << "\" not applicable to the "
                            << (mType == CarouselType::HORIZONTAL_WHEEL ? "\"horizontalWheel\"" :
                                                                          "\"verticalWheel\"")
                            << " type";
        }
    }

    if (elem->has("itemsBeforeCenter"))
        mItemsBeforeCenter =
            glm::clamp(static_cast<int>(elem->get<unsigned int>("itemsBeforeCenter")), 0, 20);

    if (elem->has("itemsAfterCenter"))
        mItemsAfterCenter =
            glm::clamp(static_cast<int>(elem->get<unsigned int>("itemsAfterCenter")), 0, 20);

    if (mType == CarouselType::HORIZONTAL || mType == CarouselType::VERTICAL) {
        if (elem->has("selectedItemMargins")) {
            const glm::vec2 selectedItemMargins {
                glm::clamp(elem->get<glm::vec2>("selectedItemMargins"), -1.0f, 1.0f)};
            if (mType == CarouselType::HORIZONTAL)
                mSelectedItemMargins = selectedItemMargins * Renderer::getScreenWidth();
            else
                mSelectedItemMargins = selectedItemMargins * Renderer::getScreenHeight();
        }
        if (elem->has("selectedItemOffset")) {
            const glm::vec2 selectedItemOffset {
                glm::clamp(elem->get<glm::vec2>("selectedItemOffset"), -1.0f, 1.0f)};
            if (mType == CarouselType::HORIZONTAL)
                mSelectedItemOffset = selectedItemOffset * Renderer::getScreenWidth();
            else
                mSelectedItemOffset = selectedItemOffset * Renderer::getScreenHeight();
        }
    }

    if (elem->has("itemSize")) {
        const glm::vec2 itemSize {glm::clamp(elem->get<glm::vec2>("itemSize"), 0.05f, 1.0f)};
        mItemSize = itemSize * glm::vec2(Renderer::getScreenWidth(), Renderer::getScreenHeight());
    }

    if (elem->has("itemStacking")) {
        const std::string& itemStacking {elem->get<std::string>("itemStacking")};
        if (itemStacking == "ascending") {
            mItemStacking = ItemStacking::ASCENDING;
        }
        else if (itemStacking == "ascendingRaised") {
            mItemStacking = ItemStacking::ASCENDING_RAISED;
        }
        else if (itemStacking == "descending") {
            mItemStacking = ItemStacking::DESCENDING;
        }
        else if (itemStacking == "descendingRaised") {
            mItemStacking = ItemStacking::DESCENDING_RAISED;
        }
        else if (itemStacking == "centered") {
            mItemStacking = ItemStacking::CENTERED;
        }
        else {
            mItemStacking = ItemStacking::CENTERED;
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"itemStacking\" for element \""
                            << element.substr(9) << "\" defined as \"" << itemStacking << "\"";
        }
    }

    if (elem->has("itemScale"))
        mItemScale = glm::clamp(elem->get<float>("itemScale"), 0.2f, 3.0f);

    if (elem->has("imageFit")) {
        const std::string& imageFit {elem->get<std::string>("imageFit")};
        if (imageFit == "contain") {
            mImagefit = ImageFit::CONTAIN;
        }
        else if (imageFit == "fill") {
            mImagefit = ImageFit::FILL;
        }
        else if (imageFit == "cover") {
            mImagefit = ImageFit::COVER;
            if (elem->has("imageCropPos"))
                mImageCropPos = glm::clamp(elem->get<glm::vec2>("imageCropPos"), 0.0f, 1.0f);
        }
        else {
            mImagefit = ImageFit::CONTAIN;
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"imageFit\" for element \""
                            << element.substr(9) << "\" defined as \"" << imageFit << "\"";
        }
    }

    if (elem->has("imageCornerRadius"))
        mImageCornerRadius = glm::clamp(elem->get<float>("imageCornerRadius"), 0.0f, 0.5f) *
                             (mItemScale >= 1.0f ? mItemScale : 1.0f) * mRenderer->getScreenWidth();

    mImageSelectedColor = mImageColorShift;
    mImageSelectedColorEnd = mImageColorShiftEnd;

    if (elem->has("imageSelectedColor")) {
        mImageSelectedColor = elem->get<unsigned int>("imageSelectedColor");
        mImageSelectedColorEnd = mImageSelectedColor;
        mHasImageSelectedColor = true;
    }
    if (elem->has("imageSelectedColorEnd")) {
        mImageSelectedColorEnd = elem->get<unsigned int>("imageSelectedColorEnd");
        mHasImageSelectedColor = true;
    }
    if (elem->has("imageSelectedGradientType")) {
        const std::string& gradientType {elem->get<std::string>("imageSelectedGradientType")};
        if (gradientType == "horizontal") {
            mImageSelectedColorGradientHorizontal = true;
        }
        else if (gradientType == "vertical") {
            mImageSelectedColorGradientHorizontal = false;
        }
        else {
            mImageSelectedColorGradientHorizontal = true;
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"imageSelectedGradientType\" for element \""
                            << element.substr(9) << "\" defined as \"" << gradientType << "\"";
        }
    }

    if (elem->has("imageBrightness"))
        mImageBrightness = glm::clamp(elem->get<float>("imageBrightness"), -2.0f, 2.0f);

    if (elem->has("imageSaturation"))
        mImageSaturation = glm::clamp(elem->get<float>("imageSaturation"), 0.0f, 1.0f);

    if (elem->has("itemDiagonalOffset") &&
        (mType == CarouselType::HORIZONTAL || mType == CarouselType::VERTICAL)) {
        const float diagonalOffset {
            glm::clamp(elem->get<float>("itemDiagonalOffset"), -0.5f, 0.5f)};
        if (mType == CarouselType::HORIZONTAL)
            mItemDiagonalOffset = diagonalOffset * Renderer::getScreenHeight();
        else
            mItemDiagonalOffset = diagonalOffset * Renderer::getScreenWidth();
    }

    if (elem->has("imageInterpolation")) {
        const std::string& imageInterpolation {elem->get<std::string>("imageInterpolation")};
        if (imageInterpolation == "linear") {
            mLinearInterpolation = true;
        }
        else if (imageInterpolation == "nearest") {
            mLinearInterpolation = false;
        }
        else {
            mLinearInterpolation = true;
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"imageInterpolation\" for element \""
                            << element.substr(9) << "\" defined as \"" << imageInterpolation
                            << "\"";
        }
    }

    if (elem->has("itemTransitions")) {
        const std::string& itemTransitions {elem->get<std::string>("itemTransitions")};
        if (itemTransitions == "animate") {
            mInstantItemTransitions = false;
        }
        else if (itemTransitions == "instant") {
            mInstantItemTransitions = true;
        }
        else {
            mInstantItemTransitions = false;
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"itemTransitions\" for element \""
                            << element.substr(9) << "\" defined as \"" << itemTransitions << "\"";
        }
    }

    if (elem->has("itemRotation"))
        mItemRotation = elem->get<float>("itemRotation");

    if (elem->has("itemRotationOrigin"))
        mItemRotationOrigin = elem->get<glm::vec2>("itemRotationOrigin");

    mItemAxisHorizontal =
        (elem->has("itemAxisHorizontal") && elem->get<bool>("itemAxisHorizontal"));

    if (elem->has("itemAxisRotation"))
        mItemAxisRotation = elem->get<float>("itemAxisRotation");

    if (elem->has("imageColor")) {
        mImageColorShift = elem->get<unsigned int>("imageColor");
        mImageColorShiftEnd = mImageColorShift;
    }
    if (elem->has("imageColorEnd"))
        mImageColorShiftEnd = elem->get<unsigned int>("imageColorEnd");

    if (elem->has("imageGradientType")) {
        const std::string& gradientType {elem->get<std::string>("imageGradientType")};
        if (gradientType == "horizontal") {
            mImageColorGradientHorizontal = true;
        }
        else if (gradientType == "vertical") {
            mImageColorGradientHorizontal = false;
        }
        else {
            mImageColorGradientHorizontal = true;
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"imageGradientType\" for element \""
                            << element.substr(9) << "\" defined as \"" << gradientType << "\"";
        }
    }

    if (elem->has("itemHorizontalAlignment") && mType != CarouselType::HORIZONTAL &&
        mType != CarouselType::HORIZONTAL_WHEEL) {
        const std::string& alignment {elem->get<std::string>("itemHorizontalAlignment")};
        if (alignment == "left") {
            mItemHorizontalAlignment = ALIGN_LEFT;
        }
        else if (alignment == "right") {
            mItemHorizontalAlignment = ALIGN_RIGHT;
        }
        else if (alignment == "center") {
            mItemHorizontalAlignment = ALIGN_CENTER;
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"itemHorizontalAlignment\" for element \""
                            << element.substr(9) << "\" defined as \"" << alignment << "\"";
            mItemHorizontalAlignment = ALIGN_CENTER;
        }
    }

    if (elem->has("itemVerticalAlignment") && mType != CarouselType::VERTICAL) {
        const std::string& alignment {elem->get<std::string>("itemVerticalAlignment")};
        if (alignment == "top") {
            mItemVerticalAlignment = ALIGN_TOP;
        }
        else if (alignment == "bottom") {
            mItemVerticalAlignment = ALIGN_BOTTOM;
        }
        else if (alignment == "center") {
            mItemVerticalAlignment = ALIGN_CENTER;
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"itemVerticalAlignment\" for element \""
                            << element.substr(9) << "\" defined as \"" << alignment << "\"";
            mItemVerticalAlignment = ALIGN_CENTER;
        }
    }

    if (elem->has("wheelHorizontalAlignment") && mType == CarouselType::VERTICAL_WHEEL) {
        const std::string& alignment {elem->get<std::string>("wheelHorizontalAlignment")};
        if (alignment == "left") {
            mWheelHorizontalAlignment = ALIGN_LEFT;
        }
        else if (alignment == "right") {
            mWheelHorizontalAlignment = ALIGN_RIGHT;
        }
        else if (alignment == "center") {
            mWheelHorizontalAlignment = ALIGN_CENTER;
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"wheelHorizontalAlignment\" for element \""
                            << element.substr(9) << "\" defined as \"" << alignment << "\"";
            mWheelHorizontalAlignment = ALIGN_CENTER;
        }
    }

    if (elem->has("wheelVerticalAlignment") && mType == CarouselType::HORIZONTAL_WHEEL) {
        const std::string& alignment {elem->get<std::string>("wheelVerticalAlignment")};
        if (alignment == "top") {
            mWheelVerticalAlignment = ALIGN_TOP;
        }
        else if (alignment == "bottom") {
            mWheelVerticalAlignment = ALIGN_BOTTOM;
        }
        else if (alignment == "center") {
            mWheelVerticalAlignment = ALIGN_CENTER;
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"wheelVerticalAlignment\" for element \""
                            << element.substr(9) << "\" defined as \"" << alignment << "\"";
            mWheelVerticalAlignment = ALIGN_CENTER;
        }
    }

    if (elem->has("horizontalOffset"))
        mHorizontalOffset = glm::clamp(elem->get<float>("horizontalOffset"), -1.0f, 1.0f);

    if (elem->has("verticalOffset"))
        mVerticalOffset = glm::clamp(elem->get<float>("verticalOffset"), -1.0f, 1.0f);

    if (elem->has("reflections") && elem->get<bool>("reflections")) {
        if (mType == CarouselType::HORIZONTAL) {
            mReflections = elem->get<bool>("reflections");
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"reflections\" for element \""
                            << element.substr(9)
                            << "\" only supported for horizontal carousel type";
        }
    }

    if (elem->has("reflectionsOpacity"))
        mReflectionsOpacity = glm::clamp(elem->get<float>("reflectionsOpacity"), 0.1f, 1.0f);

    if (elem->has("reflectionsFalloff"))
        mReflectionsFalloff = glm::clamp(elem->get<float>("reflectionsFalloff"), 0.0f, 10.0f);

    if (elem->has("unfocusedItemOpacity"))
        mUnfocusedItemOpacity = glm::clamp(elem->get<float>("unfocusedItemOpacity"), 0.1f, 1.0f);

    if (elem->has("unfocusedItemSaturation")) {
        mUnfocusedItemSaturation =
            glm::clamp(elem->get<float>("unfocusedItemSaturation"), 0.0f, 1.0f);
        mHasUnfocusedItemSaturation = true;
    }

    if (elem->has("unfocusedItemDimming"))
        mUnfocusedItemDimming = glm::clamp(elem->get<float>("unfocusedItemDimming"), 0.0f, 1.0f);

    if (elem->has("fastScrolling") && elem->get<bool>("fastScrolling"))
        List::mTierList = IList<CarouselEntry, T>::LIST_SCROLL_STYLE_MEDIUM;

    // Ccale the font size with the itemScale property value.
    mFont =
        Font::getFromTheme(elem, properties, mFont, 0.0f, (mItemScale >= 1.0f ? mItemScale : 1.0f));

    if (elem->has("textRelativeScale"))
        mTextRelativeScale = glm::clamp(elem->get<float>("textRelativeScale"), 0.2f, 1.0f);

    if (elem->has("textBackgroundCornerRadius")) {
        mTextBackgroundCornerRadius =
            glm::clamp(elem->get<float>("textBackgroundCornerRadius"), 0.0f, 0.5f) *
            (mItemScale >= 1.0f ? mItemScale : 1.0f) * mRenderer->getScreenWidth();
    }

    if (elem->has("textColor"))
        mTextColor = elem->get<unsigned int>("textColor");
    if (elem->has("textBackgroundColor"))
        mTextBackgroundColor = elem->get<unsigned int>("textBackgroundColor");

    mTextSelectedColor = mTextColor;
    mTextSelectedBackgroundColor = mTextBackgroundColor;

    if (elem->has("textSelectedColor")) {
        mTextSelectedColor = elem->get<unsigned int>("textSelectedColor");
        mHasTextSelectedColor = true;
    }
    if (elem->has("textSelectedBackgroundColor")) {
        mTextSelectedBackgroundColor = elem->get<unsigned int>("textSelectedBackgroundColor");
        mHasTextSelectedColor = true;
    }

    if (elem->has("textHorizontalScrolling"))
        mTextHorizontalScrolling = elem->get<bool>("textHorizontalScrolling");

    if (elem->has("textHorizontalScrollSpeed")) {
        mTextHorizontalScrollSpeed =
            glm::clamp(elem->get<float>("textHorizontalScrollSpeed"), 0.1f, 10.0f);
    }

    if (elem->has("textHorizontalScrollDelay")) {
        mTextHorizontalScrollDelay =
            glm::clamp(elem->get<float>("textHorizontalScrollDelay"), 0.0f, 10.0f) * 1000.0f;
    }

    if (elem->has("textHorizontalScrollGap")) {
        mTextHorizontalScrollGap =
            glm::clamp(elem->get<float>("textHorizontalScrollGap"), 0.1f, 5.0f);
    }

    if (elem->has("lineSpacing"))
        mLineSpacing = glm::clamp(elem->get<float>("lineSpacing"), 0.5f, 3.0f);

    if (elem->has("letterCase")) {
        const std::string& letterCase {elem->get<std::string>("letterCase")};

        if (letterCase == "uppercase") {
            mLetterCase = LetterCase::UPPERCASE;
        }
        else if (letterCase == "lowercase") {
            mLetterCase = LetterCase::LOWERCASE;
        }
        else if (letterCase == "capitalize") {
            mLetterCase = LetterCase::CAPITALIZE;
        }
        else if (letterCase != "none") {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"letterCase\" for element \""
                            << element.substr(9) << "\" defined as \"" << letterCase << "\"";
        }
    }

    if (elem->has("letterCaseAutoCollections")) {
        const std::string& letterCase {elem->get<std::string>("letterCaseAutoCollections")};

        if (letterCase == "uppercase") {
            mLetterCaseAutoCollections = LetterCase::UPPERCASE;
        }
        else if (letterCase == "lowercase") {
            mLetterCaseAutoCollections = LetterCase::LOWERCASE;
        }
        else if (letterCase == "capitalize") {
            mLetterCaseAutoCollections = LetterCase::CAPITALIZE;
        }
        else if (letterCase == "none") {
            mLetterCaseAutoCollections = LetterCase::NONE;
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"letterCaseAutoCollections\" for element \""
                            << element.substr(9) << "\" defined as \"" << letterCase << "\"";
        }
    }

    if (elem->has("letterCaseCustomCollections")) {
        const std::string& letterCase {elem->get<std::string>("letterCaseCustomCollections")};

        if (letterCase == "uppercase") {
            mLetterCaseCustomCollections = LetterCase::UPPERCASE;
        }
        else if (letterCase == "lowercase") {
            mLetterCaseCustomCollections = LetterCase::LOWERCASE;
        }
        else if (letterCase == "capitalize") {
            mLetterCaseCustomCollections = LetterCase::CAPITALIZE;
        }
        else if (letterCase == "none") {
            mLetterCaseCustomCollections = LetterCase::NONE;
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"letterCaseCustomCollections\" for element \""
                            << element.substr(9) << "\" defined as \"" << letterCase << "\"";
        }
    }

    if (mGamelistView && elem->has("systemNameSuffix"))
        mSystemNameSuffix = elem->get<bool>("systemNameSuffix");

    if (mGamelistView && properties & LETTER_CASE && elem->has("letterCaseSystemNameSuffix")) {
        const std::string& letterCase {elem->get<std::string>("letterCaseSystemNameSuffix")};
        if (letterCase == "uppercase") {
            mLetterCaseSystemNameSuffix = LetterCase::UPPERCASE;
        }
        else if (letterCase == "lowercase") {
            mLetterCaseSystemNameSuffix = LetterCase::LOWERCASE;
        }
        else if (letterCase == "capitalize") {
            mLetterCaseSystemNameSuffix = LetterCase::CAPITALIZE;
        }
        else {
            LOG(LogWarning) << "CarouselComponent: Invalid theme configuration, property "
                               "\"letterCaseSystemNameSuffix\" for element \""
                            << element.substr(9) << "\" defined as \"" << letterCase << "\"";
        }
    }

    if (elem->has("fadeAbovePrimary"))
        mFadeAbovePrimary = elem->get<bool>("fadeAbovePrimary");

    GuiComponent::applyTheme(theme, view, element, ALL);

    mSize.x = glm::clamp(mSize.x, mRenderer->getScreenWidth() * 0.05f,
                         mRenderer->getScreenWidth() * 2.0f);
    mSize.y = glm::clamp(mSize.y, mRenderer->getScreenHeight() * 0.05f,
                         mRenderer->getScreenHeight() * 2.0f);
}

template <typename T> void CarouselComponent<T>::onCursorChanged(const CursorState& state)
{
    if (mEntries.size() > static_cast<size_t>(mLastCursor))
        mEntries.at(mLastCursor).data.item->resetComponent();

    float startPos {mEntryCamOffset};
    float posMax {static_cast<float>(mEntries.size())};
    float target {static_cast<float>(mCursor)};

    // Find the shortest path to the target.
    float endPos {target}; // Directly.

    if (mPreviousScrollVelocity > 0 && mScrollVelocity == 0 && mEntryCamOffset > posMax - 1.0f)
        startPos = 0.0f;

    // If quick jumping to the start or end of the list using the trigger button when in
    // the gamelist view, then always animate in the requested direction.
    if (!mTriggerJump) {
        float dist {fabsf(endPos - startPos)};

        if (fabsf(target + posMax - startPos - mScrollVelocity) < dist)
            endPos = target + posMax; // Loop around the end (0 -> max).
        if (fabsf(target - posMax - startPos - mScrollVelocity) < dist)
            endPos = target - posMax; // Loop around the start (max - 1 -> -1).
    }

    // Make sure there are no reverse jumps between items.
    bool changedDirection {false};
    if (mPreviousScrollVelocity != 0 && mPreviousScrollVelocity != mScrollVelocity)
        changedDirection = true;

    if (!changedDirection && mScrollVelocity > 0 && endPos < startPos)
        endPos = endPos + posMax;

    if (!changedDirection && mScrollVelocity < 0 && endPos > startPos)
        endPos = endPos - posMax;

    if (mScrollVelocity != 0)
        mPreviousScrollVelocity = mScrollVelocity;

    // Needed to make sure that overlapping items are renderered correctly.
    if (startPos > endPos)
        mPositiveDirection = true;
    else
        mPositiveDirection = false;

    mEntryCamTarget = endPos;
    float animTime {400.0f};
    float timeDiff {1.0f};

    // If startPos is inbetween two positions then reduce the time slightly as the distance will
    // be shorter meaning the animation would play for too long if not compensated for.
    if (mScrollVelocity == 1)
        timeDiff = endPos - startPos;
    else if (mScrollVelocity == -1)
        timeDiff = startPos - endPos;

    if (timeDiff != 1.0f)
        animTime =
            glm::clamp(std::fabs(glm::mix(0.0f, animTime, timeDiff * 1.5f)), 200.0f, animTime);

    Animation* anim {new LambdaAnimation(
        [this, startPos, endPos, posMax](float t) {
            // Non-linear interpolation.
            t = 1.0f - (1.0f - t) * (1.0f - t);
            float f {(endPos * t) + (startPos * (1.0f - t))};
            if (f < 0)
                f += posMax;
            if (f >= posMax)
                f -= posMax;

            mEntryCamOffset = f;
        },
        static_cast<int>(animTime))};

    GuiComponent::setAnimation(anim, 0, nullptr, false, 0);

    if (mCursorChangedCallback)
        mCursorChangedCallback(state);
}

#endif // ES_CORE_COMPONENTS_PRIMARY_CAROUSEL_COMPONENT_H