ui-node.h

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2025-2026 Manuel Osorio
#pragma once
#include "flint/graphics/types/color.h"
#include "flint/math/types.h"
#include "flint/ui/ui-event.h"
#include "flint/ui/ui-types.h"
 
#include <memory>
#include <string>
#include <vector>
 
namespace Flint {
  class UIContext;
  class UICanvas;
 
  class UINode {
    public:
      virtual ~UINode() = default;
 
      void setContext(UIContext *context);
 
      void addChild(std::unique_ptr<UINode> child);
 
      void setPosition(Vec2f position);
 
      Vec2f getPosition() const {
        return m_localPosition;
      }
 
      void setSize(Vec2f size);
 
      Vec2f getSize() const {
        return m_baseSize;
      }
 
      void setVisible(bool visible);
 
      void setEnabled(bool enabled);
 
      void setID(std::string id);
      [[nodiscard]] const std::string &getId() const;
 
      [[nodiscard]] const Rect<float> &getLayoutRect() const;
 
      [[nodiscard]] bool isVisible() const {
        return m_visible;
      }
 
      [[nodiscard]] bool isEnabled() const {
        return m_enabled;
      }
 
      [[nodiscard]] Vec2f getDesiredSize() const {
        return m_desiredSize;
      }
 
      [[nodiscard]] const std::vector<std::unique_ptr<UINode>> &getChildren() const {
        return m_children;
      }
 
      virtual void setFocused(bool focused) {
        m_focused = focused;
      }
 
      void setText(std::string text);
      [[nodiscard]] const std::string &getText() const;
 
      void                   setFontSize(uint16_t fontSize);
      [[nodiscard]] uint16_t getFontSize() const;
 
      void                setColor(Color color);
      [[nodiscard]] Color getColor() const;
 
      virtual void setNormalColor(Color color) {
        m_normalColor = color;
      }
 
      virtual void setActiveColor(Color color) {
        m_activeColor = color;
      }
 
      virtual void measure(UIConstraints constraints);
 
      virtual void arrange(const Rect<float> &rect);
 
      virtual void handleEvent(const UIEvent &event);
 
      virtual void render(UICanvas &canvas) const;
 
      virtual bool isFocusable() const {
        return false;
      }
 
      virtual bool hitTest(Vec2f point) const;
 
      void setFont(std::string name) {
        m_fontName = std::move(name);
      }
 
      void setFontWeight(uint16_t weight) {
        m_fontWeight = weight;
      }
 
      void setTextOpticalBias(float bias) {
        m_textOpticalBias = bias;
      }
 
      [[nodiscard]] float getTextOpticalBias() const {
        return m_textOpticalBias;
      }
 
      virtual bool consumesDirectionalInput() const {
        return false;
      }
 
      [[nodiscard]] bool isFocused() const {
        return m_focused;
      }
 
      void setHorizontalAlign(UIAlign align);
      void setVerticalAlign(UIAlign align);
 
      [[nodiscard]] UIAlign getHorizontalAlign() const;
      [[nodiscard]] UIAlign getVerticalAlign() const;
 
      void setLayoutGrow(float grow);
      [[nodiscard]] float getLayoutGrow() const;
 
    protected:
      std::string                          m_id;
      UINode                              *m_parent = nullptr;
      std::vector<std::unique_ptr<UINode>> m_children;
 
      Vec2f
          m_localPosition{}; 
      Vec2f m_desiredSize{}; 
      Vec2f m_baseSize{};    
      Rect<float>
          m_layoutRect{}; 
      bool  m_visible = true;
      bool  m_enabled = true;
      float m_displayScale = 1.0f;
 
      std::string m_fontName;
      uint16_t    m_fontWeight = 400;
      uint16_t    m_fontSize = 16;
      float       m_textOpticalBias = 0.f;
 
      std::string m_text;
 
      Color m_normalColor = Colors::white;
      Color m_activeColor = {0, 255, 0, 255};
 
      virtual const Color &currentColor() const {
        return (m_hovered || m_focused) ? m_activeColor : m_normalColor;
      }
 
      bool m_hovered = false;
      bool m_focused = false;
 
      UIAlign m_horizontalAlign = UIAlign::Stretch;
      UIAlign m_verticalAlign = UIAlign::Start;
      float   m_layoutGrow = 0.f;
 
    private:
      UIContext *m_context = nullptr;
 
      bool idExists(const std::string &id) const;
  };
}