Horizon-OC/Source/hoc-clk/overlay/src/ui/gui/ult_ext.h

/*
 * Copyright (c) Souldbminer, Lightos_ and Horizon OC Contributors
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms and conditions of the GNU General Public License,
 * version 2, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#pragma once
#include <tesla.hpp>

#include "../elements/base_frame.h"


class TopAnchoredList : public tsl::elm::List {
    public:
    TopAnchoredList() {
        m_hasSetInitialFocusHack = true;
    }
};
class BoxClippedList : public tsl::elm::List {
    public:
    void draw(tsl::gfx::Renderer *renderer) override {
        renderer->enableScissoring(0, HOC_BOX_BOTTOM, tsl::cfg::FramebufferWidth, tsl::cfg::FramebufferHeight - HOC_BOX_BOTTOM);
        tsl::elm::List::draw(renderer);
        renderer->disableScissoring();
    }
};

class CompactCategoryHeader : public tsl::elm::CategoryHeader {
    public:
    CompactCategoryHeader(const std::string &text) : tsl::elm::CategoryHeader(text) {
    }
    void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
        this->setBoundaries(this->getX(), this->getY(), this->getWidth(), 33);
    }
};

class ImageElement : public tsl::elm::ListItem {
    private:
    const uint8_t *imgData;
    uint32_t imgWidth, imgHeight;
    bool visible;

    public:
    ImageElement(const uint8_t *data, uint32_t w, uint32_t h) : tsl::elm::ListItem(""), imgData(data), imgWidth(w), imgHeight(h), visible(true) {
    }

    void setVisible(bool v) {
        visible = v;
    }

    virtual void draw(tsl::gfx::Renderer *renderer) override {
        if (!visible)
            return;

        // Draw image centered horizontally
        u16 centerX = this->getX() + (this->getWidth() - imgWidth) / 2;
        renderer->drawBitmap(centerX, this->getY() + 10, imgWidth, imgHeight, imgData);
    }

    virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
        if (!visible) {
            // Take up no space when hidden
            this->setBoundaries(parentX, parentY, 0, 0);
        } else {
            // Normal layout when visible
            tsl::elm::ListItem::layout(parentX, parentY, parentWidth, parentHeight);
        }
    }

    virtual void drawHighlight(tsl::gfx::Renderer *renderer) override {
        // Do nothing - no highlight
    }

    virtual bool onClick(u64 keys) override {
        return false;  // Non-clickable
    }

    virtual Element *requestFocus(Element *oldFocus, tsl::FocusDirection direction) override {
        return nullptr;  // Make it non-focusable
    }
};

class HideableCategoryHeader : public tsl::elm::CategoryHeader {
    private:
    bool visible;

    public:
    HideableCategoryHeader(const std::string &title) : tsl::elm::CategoryHeader(title), visible(true) {
    }

    void setVisible(bool v) {
        visible = v;
    }

    virtual void draw(tsl::gfx::Renderer *renderer) override {
        if (!visible)
            return;
        tsl::elm::CategoryHeader::draw(renderer);
    }

    virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
        if (!visible) {
            this->setBoundaries(parentX, parentY, 0, 0);
        } else {
            tsl::elm::CategoryHeader::layout(parentX, parentY, parentWidth, parentHeight);
        }
    }
};

class FocusableDrawer : public tsl::elm::CustomDrawer {
    public:
    template <typename... Args> FocusableDrawer(Args &&...args) : tsl::elm::CustomDrawer(std::forward<Args>(args)...) {
        m_isItem = true;
    }
    Element *requestFocus(Element *, tsl::FocusDirection) override {
        return this;
    }
    void drawHighlight(tsl::gfx::Renderer *) override {
    }
};

class HideableCustomDrawer : public tsl::elm::Element {
    private:
    bool visible;
    u32 height;

    public:
    HideableCustomDrawer(u32 h) : Element(), visible(true), height(h) {
    }

    void setVisible(bool v) {
        visible = v;
    }

    virtual void draw(tsl::gfx::Renderer *renderer) override {
        // Empty drawer - just for spacing
    }

    virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
        if (!visible) {
            this->setBoundaries(parentX, parentY, 0, 0);
        } else {
            this->setBoundaries(parentX, parentY, parentWidth, height);
        }
    }

    virtual Element *requestFocus(Element *oldFocus, tsl::FocusDirection direction) override {
        return nullptr;
    }
};