lvgl.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#include <ove/lvgl.h>
#include <cstdarg>
#include <cstdint>
#include <cstdio>
#include <type_traits>
#include <concepts>
 
namespace ove::lvgl
{
 
/* ================================================================== */
/*  LvglGuard — RAII lock for thread-safe LVGL access                 */
/* ================================================================== */
 
class LvglGuard
{
      public:
    LvglGuard()
    {
        ove_lvgl_lock();
    }
 
    ~LvglGuard() noexcept
    {
        ove_lvgl_unlock();
    }
 
    LvglGuard(const LvglGuard &) = delete;
    LvglGuard &operator=(const LvglGuard &) = delete;
    LvglGuard(LvglGuard &&) = delete;
    LvglGuard &operator=(LvglGuard &&) = delete;
};
 
/* ================================================================== */
/*  ObjectView — non-owning lv_obj_t* wrapper                         */
/* ================================================================== */
 
class ObjectView
{
      public:
    ObjectView() : obj_(nullptr)
    {
    }
 
    explicit ObjectView(lv_obj_t *obj) : obj_(obj)
    {
    }
 
    lv_obj_t *get() const
    {
        return obj_;
    }
 
    operator lv_obj_t *() const
    {
        return obj_;
    }
 
    explicit operator bool() const
    {
        return obj_ != nullptr;
    }
 
    ObjectView parent() const
    {
        return ObjectView(lv_obj_get_parent(obj_));
    }
 
    uint32_t child_count() const
    {
        return lv_obj_get_child_count(obj_);
    }
 
    ObjectView get_child(int32_t idx) const
    {
        return ObjectView(lv_obj_get_child(obj_, idx));
    }
 
    int32_t get_width() const
    {
        return lv_obj_get_width(obj_);
    }
 
    int32_t get_height() const
    {
        return lv_obj_get_height(obj_);
    }
 
    void del()
    {
        lv_obj_delete(obj_);
        obj_ = nullptr;
    }
 
    void clean()
    {
        lv_obj_clean(obj_);
    }
 
    static ObjectView screen_active()
    {
        return ObjectView(lv_screen_active());
    }
 
      protected:
    lv_obj_t *obj_;
};
 
static_assert(sizeof(ObjectView) == sizeof(void *), "ObjectView must be pointer-sized");
 
/* Forward declaration so ObjectMixin::add_style can reference Style,
 * whose full definition appears further below. */
class Style;
 
/* ================================================================== */
/*  ObjectMixin<Derived> — fluent setters via CRTP                    */
/* ================================================================== */
 
template <typename Derived> class ObjectMixin
{
      public:
    Derived &size(int32_t w, int32_t h)
    {
        lv_obj_set_size(self().get(), w, h);
        return self();
    }
 
    Derived &width(int32_t w)
    {
        lv_obj_set_width(self().get(), w);
        return self();
    }
 
    Derived &height(int32_t h)
    {
        lv_obj_set_height(self().get(), h);
        return self();
    }
 
    Derived &pos(int32_t x, int32_t y)
    {
        lv_obj_set_pos(self().get(), x, y);
        return self();
    }
 
    Derived &center()
    {
        lv_obj_center(self().get());
        return self();
    }
 
    Derived &align(lv_align_t a, int32_t x_ofs = 0, int32_t y_ofs = 0)
    {
        lv_obj_align(self().get(), a, x_ofs, y_ofs);
        return self();
    }
 
    Derived &hide()
    {
        lv_obj_add_flag(self().get(), LV_OBJ_FLAG_HIDDEN);
        return self();
    }
 
    Derived &show()
    {
        lv_obj_remove_flag(self().get(), LV_OBJ_FLAG_HIDDEN);
        return self();
    }
 
    Derived &visible(bool v)
    {
        return v ? show() : hide();
    }
 
    Derived &add_flag(lv_obj_flag_t f)
    {
        lv_obj_add_flag(self().get(), f);
        return self();
    }
 
    Derived &remove_flag(lv_obj_flag_t f)
    {
        lv_obj_remove_flag(self().get(), f);
        return self();
    }
 
    Derived &add_state(lv_state_t s)
    {
        lv_obj_add_state(self().get(), s);
        return self();
    }
 
    Derived &remove_state(lv_state_t s)
    {
        lv_obj_remove_state(self().get(), s);
        return self();
    }
 
    Derived &user_data(void *data)
    {
        lv_obj_set_user_data(self().get(), data);
        return self();
    }
 
    Derived &clickable(bool on)
    {
        if (on)
            lv_obj_add_flag(self().get(), LV_OBJ_FLAG_CLICKABLE);
        else
            lv_obj_remove_flag(self().get(), LV_OBJ_FLAG_CLICKABLE);
        return self();
    }
 
    Derived &grid_dsc(const int32_t *cols, const int32_t *rows)
    {
        lv_obj_set_grid_dsc_array(self().get(), cols, rows);
        return self();
    }
 
    Derived &flex_flow(lv_flex_flow_t flow)
    {
        lv_obj_set_flex_flow(self().get(), flow);
        return self();
    }
 
    Derived &flex_align(lv_flex_align_t main, lv_flex_align_t cross, lv_flex_align_t track)
    {
        lv_obj_set_flex_align(self().get(), main, cross, track);
        return self();
    }
 
    Derived &flex_grow(uint8_t grow)
    {
        lv_obj_set_flex_grow(self().get(), grow);
        return self();
    }
 
    Derived &layout(uint32_t kind)
    {
        lv_obj_set_layout(self().get(), kind);
        return self();
    }
 
    Derived &scroll_to_y(int32_t y, bool anim)
    {
        lv_obj_scroll_to_y(self().get(), y, anim);
        return self();
    }
 
    Derived &update_layout()
    {
        lv_obj_update_layout(self().get());
        return self();
    }
 
    int32_t get_content_width() const
    {
        return lv_obj_get_content_width(
            const_cast<lv_obj_t *>(static_cast<const Derived &>(*this).get()));
    }
 
    int32_t get_scroll_bottom() const
    {
        return lv_obj_get_scroll_bottom(
            const_cast<lv_obj_t *>(static_cast<const Derived &>(*this).get()));
    }
 
    Derived &remove_style_all()
    {
        lv_obj_remove_style_all(self().get());
        return self();
    }
 
    Derived &grid_cell(lv_grid_align_t col_align, int32_t col_pos, int32_t col_span,
               lv_grid_align_t row_align, int32_t row_pos, int32_t row_span)
    {
        lv_obj_set_grid_cell(self().get(), col_align, col_pos, col_span, row_align, row_pos,
                     row_span);
        return self();
    }
 
    Derived &add_style(Style &style, lv_style_selector_t selector);
 
      private:
    Derived &self()
    {
        return static_cast<Derived &>(*this);
    }
};
 
/* ================================================================== */
/*  EventMixin<Derived> — type-safe event callbacks via CRTP          */
/* ================================================================== */
 
namespace detail
{
 
template <typename F>
concept StatelessCallable = std::is_convertible_v<F, void (*)(lv_event_t *)>;
 
} /* namespace detail */
 
template <typename Derived> class EventMixin
{
      public:
    template <detail::StatelessCallable F> Derived &on(lv_event_code_t code, F &&fn)
    {
        lv_obj_add_event_cb(self().get(), static_cast<lv_event_cb_t>(fn), code, nullptr);
        return self();
    }
 
    template <auto MemFn, typename T> Derived &on(lv_event_code_t code, T *instance)
    {
        lv_obj_add_event_cb(
            self().get(),
            [](lv_event_t *e) {
                auto *self = static_cast<T *>(lv_event_get_user_data(e));
                (self->*MemFn)(e);
            },
            code, instance);
        return self();
    }
 
    template <detail::StatelessCallable F> Derived &on_click(F &&fn)
    {
        return on(LV_EVENT_CLICKED, static_cast<F &&>(fn));
    }
 
    template <auto MemFn, typename T> Derived &on_click(T *instance)
    {
        return on<MemFn>(LV_EVENT_CLICKED, instance);
    }
 
    template <detail::StatelessCallable F> Derived &on_value_changed(F &&fn)
    {
        return on(LV_EVENT_VALUE_CHANGED, static_cast<F &&>(fn));
    }
 
    template <auto MemFn, typename T> Derived &on_value_changed(T *instance)
    {
        return on<MemFn>(LV_EVENT_VALUE_CHANGED, instance);
    }
 
      private:
    Derived &self()
    {
        return static_cast<Derived &>(*this);
    }
};
 
/* ================================================================== */
/*  StyleMixin<Derived> — inline style setters via CRTP               */
/* ================================================================== */
 
template <typename Derived> class StyleMixin
{
      public:
    Derived &bg_color(lv_color_t c)
    {
        lv_obj_set_style_bg_color(self().get(), c, LV_PART_MAIN);
        return self();
    }
 
    Derived &bg_color(lv_color_t c, lv_style_selector_t part)
    {
        lv_obj_set_style_bg_color(self().get(), c, part);
        return self();
    }
 
    Derived &bg_opa(lv_opa_t opa)
    {
        lv_obj_set_style_bg_opa(self().get(), opa, LV_PART_MAIN);
        return self();
    }
 
    Derived &bg_opa(lv_opa_t opa, lv_style_selector_t part)
    {
        lv_obj_set_style_bg_opa(self().get(), opa, part);
        return self();
    }
 
    Derived &border_color(lv_color_t c)
    {
        lv_obj_set_style_border_color(self().get(), c, LV_PART_MAIN);
        return self();
    }
 
    Derived &border_width(int32_t w)
    {
        lv_obj_set_style_border_width(self().get(), w, LV_PART_MAIN);
        return self();
    }
 
    Derived &border_width(int32_t w, lv_style_selector_t part)
    {
        lv_obj_set_style_border_width(self().get(), w, part);
        return self();
    }
 
    Derived &radius(int32_t r)
    {
        lv_obj_set_style_radius(self().get(), r, LV_PART_MAIN);
        return self();
    }
 
    Derived &radius(int32_t r, lv_style_selector_t part)
    {
        lv_obj_set_style_radius(self().get(), r, part);
        return self();
    }
 
    Derived &pad_all(int32_t p)
    {
        lv_obj_set_style_pad_all(self().get(), p, LV_PART_MAIN);
        return self();
    }
 
    Derived &pad_hor(int32_t p)
    {
        lv_obj_set_style_pad_hor(self().get(), p, LV_PART_MAIN);
        return self();
    }
 
    Derived &pad_ver(int32_t p)
    {
        lv_obj_set_style_pad_ver(self().get(), p, LV_PART_MAIN);
        return self();
    }
 
    Derived &pad_gap(int32_t g)
    {
        lv_obj_set_style_pad_gap(self().get(), g, LV_PART_MAIN);
        return self();
    }
 
    Derived &text_color(lv_color_t c)
    {
        lv_obj_set_style_text_color(self().get(), c, LV_PART_MAIN);
        return self();
    }
 
    Derived &text_font(const lv_font_t *f)
    {
        lv_obj_set_style_text_font(self().get(), f, LV_PART_MAIN);
        return self();
    }
 
    // ---- Per-side paddings + row/column gaps ----
    Derived &pad_top(int32_t p)
    {
        lv_obj_set_style_pad_top(self().get(), p, LV_PART_MAIN);
        return self();
    }
    Derived &pad_bottom(int32_t p)
    {
        lv_obj_set_style_pad_bottom(self().get(), p, LV_PART_MAIN);
        return self();
    }
    Derived &pad_left(int32_t p)
    {
        lv_obj_set_style_pad_left(self().get(), p, LV_PART_MAIN);
        return self();
    }
    Derived &pad_right(int32_t p)
    {
        lv_obj_set_style_pad_right(self().get(), p, LV_PART_MAIN);
        return self();
    }
    Derived &pad_row(int32_t p)
    {
        lv_obj_set_style_pad_row(self().get(), p, LV_PART_MAIN);
        return self();
    }
    Derived &pad_column(int32_t p)
    {
        lv_obj_set_style_pad_column(self().get(), p, LV_PART_MAIN);
        return self();
    }
 
    // ---- Text alignment + overall opacity ----
    Derived &text_align(uint32_t align, lv_style_selector_t part = LV_PART_MAIN)
    {
        lv_obj_set_style_text_align(self().get(), static_cast<lv_text_align_t>(align),
                        part);
        return self();
    }
    Derived &set_opa(lv_opa_t opa)
    {
        lv_obj_set_style_opa(self().get(), opa, LV_PART_MAIN);
        return self();
    }
 
    // ---- Selector variants ----
    Derived &text_color(lv_color_t c, lv_style_selector_t part)
    {
        lv_obj_set_style_text_color(self().get(), c, part);
        return self();
    }
    Derived &border_color(lv_color_t c, lv_style_selector_t part)
    {
        lv_obj_set_style_border_color(self().get(), c, part);
        return self();
    }
    Derived &arc_color(lv_color_t c, lv_style_selector_t part)
    {
        lv_obj_set_style_arc_color(self().get(), c, part);
        return self();
    }
    Derived &arc_width(int32_t w, lv_style_selector_t part)
    {
        lv_obj_set_style_arc_width(self().get(), w, part);
        return self();
    }
    Derived &arc_opa(lv_opa_t opa, lv_style_selector_t part)
    {
        lv_obj_set_style_arc_opa(self().get(), opa, part);
        return self();
    }
    Derived &arc_rounded(bool rounded, lv_style_selector_t part)
    {
        lv_obj_set_style_arc_rounded(self().get(), rounded, part);
        return self();
    }
 
    // ---- Advanced layout/compositing styles ----
    Derived &translate_y(int32_t v, lv_style_selector_t part = LV_PART_MAIN)
    {
        lv_obj_set_style_translate_y(self().get(), v, part);
        return self();
    }
    Derived &margin_top(int32_t v, lv_style_selector_t part = LV_PART_MAIN)
    {
        lv_obj_set_style_margin_top(self().get(), v, part);
        return self();
    }
    Derived &margin_bottom(int32_t v, lv_style_selector_t part = LV_PART_MAIN)
    {
        lv_obj_set_style_margin_bottom(self().get(), v, part);
        return self();
    }
    Derived &margin_left(int32_t v, lv_style_selector_t part = LV_PART_MAIN)
    {
        lv_obj_set_style_margin_left(self().get(), v, part);
        return self();
    }
    Derived &margin_right(int32_t v, lv_style_selector_t part = LV_PART_MAIN)
    {
        lv_obj_set_style_margin_right(self().get(), v, part);
        return self();
    }
    Derived &max_height(int32_t v, lv_style_selector_t part = LV_PART_MAIN)
    {
        lv_obj_set_style_max_height(self().get(), v, part);
        return self();
    }
    Derived &opa_layered(lv_opa_t opa, lv_style_selector_t part = LV_PART_MAIN)
    {
        lv_obj_set_style_opa_layered(self().get(), opa, part);
        return self();
    }
 
      private:
    Derived &self()
    {
        return static_cast<Derived &>(*this);
    }
};
 
 
/* ================================================================== */
/*  Style — RAII style object                                         */
/* ================================================================== */
 
class Style
{
      public:
    Style()
    {
        lv_style_init(&style_);
    }
 
    ~Style() noexcept
    {
        lv_style_reset(&style_);
    }
 
    Style(const Style &) = delete;
    Style &operator=(const Style &) = delete;
 
    Style(Style &&other) noexcept : style_(other.style_)
    {
        lv_style_init(&other.style_);
    }
 
    Style &operator=(Style &&other) noexcept
    {
        if (this != &other) {
            lv_style_reset(&style_);
            style_ = other.style_;
            lv_style_init(&other.style_);
        }
        return *this;
    }
 
    lv_style_t *get()
    {
        return &style_;
    }
 
    const lv_style_t *get() const
    {
        return &style_;
    }
 
    Style &bg_color(lv_color_t c)
    {
        lv_style_set_bg_color(&style_, c);
        return *this;
    }
 
    Style &bg_opa(lv_opa_t opa)
    {
        lv_style_set_bg_opa(&style_, opa);
        return *this;
    }
 
    Style &radius(int32_t r)
    {
        lv_style_set_radius(&style_, r);
        return *this;
    }
 
    Style &border_color(lv_color_t c)
    {
        lv_style_set_border_color(&style_, c);
        return *this;
    }
 
    Style &border_width(int32_t w)
    {
        lv_style_set_border_width(&style_, w);
        return *this;
    }
 
    Style &pad_all(int32_t p)
    {
        lv_style_set_pad_all(&style_, p);
        return *this;
    }
 
    Style &text_color(lv_color_t c)
    {
        lv_style_set_text_color(&style_, c);
        return *this;
    }
 
    Style &text_font(const lv_font_t *f)
    {
        lv_style_set_text_font(&style_, f);
        return *this;
    }
 
      private:
    lv_style_t style_;
};
 
/* Out-of-line definition: now that `Style` is complete, `style.get()` is
 * a valid call. (Declared inside ObjectMixin above.) */
template <typename Derived>
Derived &ObjectMixin<Derived>::add_style(Style &style, lv_style_selector_t selector)
{
    lv_obj_add_style(self().get(), style.get(), selector);
    return self();
}
 
/* ================================================================== */
/*  State<T> — reactive state (requires LV_USE_OBSERVER)              */
/* ================================================================== */
 
#if LV_USE_OBSERVER
 
template <std::integral T> class State
{
      public:
    explicit State(T initial = 0)
    {
        lv_subject_init_int(&subject_, static_cast<int32_t>(initial));
    }
 
    ~State() noexcept
    {
        lv_subject_deinit(&subject_);
    }
 
    State(const State &) = delete;
    State &operator=(const State &) = delete;
 
    void set(T val)
    {
        lv_subject_set_int(&subject_, static_cast<int32_t>(val));
    }
 
    T get() const
    {
        return static_cast<T>(lv_subject_get_int(const_cast<lv_subject_t *>(&subject_)));
    }
 
    operator T() const
    {
        return get();
    }
 
    State &operator++()
    {
        set(get() + 1);
        return *this;
    }
 
    State &operator--()
    {
        set(get() - 1);
        return *this;
    }
 
    lv_subject_t *subject()
    {
        return &subject_;
    }
 
      private:
    lv_subject_t subject_;
};
 
#endif /* LV_USE_OBSERVER */
 
 
/* ================================================================== */
/*  Widget wrappers — Label, Bar, Box                                 */
/* ================================================================== */
 
class Label : public ObjectView,
          public ObjectMixin<Label>,
          public EventMixin<Label>,
          public StyleMixin<Label>
{
      public:
    explicit Label(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Label create(ObjectView parent)
    {
        return Label(lv_label_create(parent));
    }
 
    Label &text(const char *txt)
    {
        lv_label_set_text(obj_, txt);
        return *this;
    }
 
    Label &text_static(const char *txt)
    {
        lv_label_set_text_static(obj_, txt);
        return *this;
    }
 
    Label &text_fmt(const char *fmt, ...)
    {
        va_list args;
        va_start(args, fmt);
        /* LVGL doesn't have a va_list variant, use snprintf + set */
        char buf[128];
        vsnprintf(buf, sizeof(buf), fmt, args);
        va_end(args);
        lv_label_set_text(obj_, buf);
        return *this;
    }
 
    Label &font(const lv_font_t *f)
    {
        lv_obj_set_style_text_font(obj_, f, LV_PART_MAIN);
        return *this;
    }
 
    Label &color(lv_color_t c)
    {
        lv_obj_set_style_text_color(obj_, c, LV_PART_MAIN);
        return *this;
    }
 
    Label &long_mode(lv_label_long_mode_t mode)
    {
        lv_label_set_long_mode(obj_, mode);
        return *this;
    }
 
#if LV_USE_OBSERVER
    template <std::integral T> Label &bind_text(State<T> &state, const char *fmt)
    {
        lv_label_bind_text(obj_, state.subject(), fmt);
        return *this;
    }
#endif
};
 
static_assert(sizeof(Label) == sizeof(void *), "Label must be pointer-sized");
 
class Bar : public ObjectView,
        public ObjectMixin<Bar>,
        public EventMixin<Bar>,
        public StyleMixin<Bar>
{
      public:
    explicit Bar(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Bar create(ObjectView parent)
    {
        return Bar(lv_bar_create(parent));
    }
 
    Bar &value(int32_t val)
    {
        lv_bar_set_value(obj_, val, LV_ANIM_ON);
        return *this;
    }
 
    Bar &value(int32_t val, lv_anim_enable_t anim)
    {
        lv_bar_set_value(obj_, val, anim);
        return *this;
    }
 
    Bar &range(int32_t min, int32_t max)
    {
        lv_bar_set_range(obj_, min, max);
        return *this;
    }
 
    Bar &indicator_color(lv_color_t c)
    {
        lv_obj_set_style_bg_color(obj_, c, LV_PART_INDICATOR);
        return *this;
    }
 
    Bar &bar_color(lv_color_t c)
    {
        lv_obj_set_style_bg_color(obj_, c, LV_PART_MAIN);
        return *this;
    }
 
    /* Note: lv_bar_bind_value() does NOT exist in LVGL 9.2-9.3 */
};
 
static_assert(sizeof(Bar) == sizeof(void *), "Bar must be pointer-sized");
 
class Box : public ObjectView,
        public ObjectMixin<Box>,
        public EventMixin<Box>,
        public StyleMixin<Box>
{
      public:
    explicit Box(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Box create(ObjectView parent)
    {
        lv_obj_t *obj = lv_obj_create(parent);
        lv_obj_remove_flag(obj, LV_OBJ_FLAG_SCROLLABLE);
        return Box(obj);
    }
};
 
static_assert(sizeof(Box) == sizeof(void *), "Box must be pointer-sized");
 
class Button : public ObjectView,
           public ObjectMixin<Button>,
           public EventMixin<Button>,
           public StyleMixin<Button>
{
      public:
    explicit Button(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Button create(ObjectView parent)
    {
        return Button(lv_button_create(parent));
    }
 
    Button &toggle_mode(bool on)
    {
        if (on)
            lv_obj_add_flag(obj_, LV_OBJ_FLAG_CHECKABLE);
        else
            lv_obj_remove_flag(obj_, LV_OBJ_FLAG_CHECKABLE);
        return *this;
    }
 
    Button &checked(bool v)
    {
        if (v)
            lv_obj_add_state(obj_, LV_STATE_CHECKED);
        else
            lv_obj_remove_state(obj_, LV_STATE_CHECKED);
        return *this;
    }
 
    bool is_checked() const
    {
        return lv_obj_has_state(obj_, LV_STATE_CHECKED);
    }
};
 
static_assert(sizeof(Button) == sizeof(void *), "Button must be pointer-sized");
 
class Slider : public ObjectView,
           public ObjectMixin<Slider>,
           public EventMixin<Slider>,
           public StyleMixin<Slider>
{
      public:
    explicit Slider(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Slider create(ObjectView parent)
    {
        return Slider(lv_slider_create(parent));
    }
 
    Slider &value(int32_t val)
    {
        lv_slider_set_value(obj_, val, LV_ANIM_ON);
        return *this;
    }
 
    Slider &value(int32_t val, lv_anim_enable_t anim)
    {
        lv_slider_set_value(obj_, val, anim);
        return *this;
    }
 
    Slider &range(int32_t min, int32_t max)
    {
        lv_slider_set_range(obj_, min, max);
        return *this;
    }
 
    int32_t get_value() const
    {
        return lv_slider_get_value(obj_);
    }
 
    Slider &indicator_color(lv_color_t c)
    {
        lv_obj_set_style_bg_color(obj_, c, LV_PART_INDICATOR);
        return *this;
    }
 
    Slider &knob_color(lv_color_t c)
    {
        lv_obj_set_style_bg_color(obj_, c, LV_PART_KNOB);
        return *this;
    }
};
 
static_assert(sizeof(Slider) == sizeof(void *), "Slider must be pointer-sized");
 
class Switch : public ObjectView,
           public ObjectMixin<Switch>,
           public EventMixin<Switch>,
           public StyleMixin<Switch>
{
      public:
    explicit Switch(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Switch create(ObjectView parent)
    {
        return Switch(lv_switch_create(parent));
    }
 
    Switch &checked(bool v)
    {
        if (v)
            lv_obj_add_state(obj_, LV_STATE_CHECKED);
        else
            lv_obj_remove_state(obj_, LV_STATE_CHECKED);
        return *this;
    }
 
    bool is_checked() const
    {
        return lv_obj_has_state(obj_, LV_STATE_CHECKED);
    }
};
 
static_assert(sizeof(Switch) == sizeof(void *), "Switch must be pointer-sized");
 
class Checkbox : public ObjectView,
         public ObjectMixin<Checkbox>,
         public EventMixin<Checkbox>,
         public StyleMixin<Checkbox>
{
      public:
    explicit Checkbox(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Checkbox create(ObjectView parent)
    {
        return Checkbox(lv_checkbox_create(parent));
    }
 
    Checkbox &text(const char *txt)
    {
        lv_checkbox_set_text(obj_, txt);
        return *this;
    }
 
    Checkbox &text_static(const char *txt)
    {
        lv_checkbox_set_text_static(obj_, txt);
        return *this;
    }
 
    Checkbox &checked(bool v)
    {
        if (v)
            lv_obj_add_state(obj_, LV_STATE_CHECKED);
        else
            lv_obj_remove_state(obj_, LV_STATE_CHECKED);
        return *this;
    }
 
    bool is_checked() const
    {
        return lv_obj_has_state(obj_, LV_STATE_CHECKED);
    }
};
 
static_assert(sizeof(Checkbox) == sizeof(void *), "Checkbox must be pointer-sized");
 
class Arc : public ObjectView,
        public ObjectMixin<Arc>,
        public EventMixin<Arc>,
        public StyleMixin<Arc>
{
      public:
    explicit Arc(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Arc create(ObjectView parent)
    {
        return Arc(lv_arc_create(parent));
    }
 
    Arc &value(int32_t val)
    {
        lv_arc_set_value(obj_, val);
        return *this;
    }
 
    Arc &range(int32_t min, int32_t max)
    {
        lv_arc_set_range(obj_, min, max);
        return *this;
    }
 
    Arc &bg_angles(uint32_t start, uint32_t end)
    {
        lv_arc_set_bg_angles(obj_, start, end);
        return *this;
    }
 
    Arc &angles(uint32_t start, uint32_t end)
    {
        lv_arc_set_angles(obj_, start, end);
        return *this;
    }
 
    Arc &rotation(uint32_t rot)
    {
        lv_arc_set_rotation(obj_, rot);
        return *this;
    }
 
    int32_t get_value() const
    {
        return lv_arc_get_value(obj_);
    }
 
    Arc &track_color(lv_color_t c)
    {
        lv_obj_set_style_arc_color(obj_, c, LV_PART_MAIN);
        return *this;
    }
 
    Arc &indicator_color(lv_color_t c)
    {
        lv_obj_set_style_arc_color(obj_, c, LV_PART_INDICATOR);
        return *this;
    }
 
    Arc &indicator_width(int32_t w)
    {
        lv_obj_set_style_arc_width(obj_, w, LV_PART_INDICATOR);
        return *this;
    }
 
    Arc &knob_color(lv_color_t c)
    {
        lv_obj_set_style_bg_color(obj_, c, LV_PART_KNOB);
        return *this;
    }
};
 
static_assert(sizeof(Arc) == sizeof(void *), "Arc must be pointer-sized");
 
class Image : public ObjectView,
          public ObjectMixin<Image>,
          public EventMixin<Image>,
          public StyleMixin<Image>
{
      public:
    explicit Image(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Image create(ObjectView parent)
    {
        return Image(lv_image_create(parent));
    }
 
    Image &src(const void *src)
    {
        lv_image_set_src(obj_, src);
        return *this;
    }
 
    Image &rotation(int32_t angle)
    {
        lv_image_set_rotation(obj_, angle);
        return *this;
    }
 
    Image &scale(uint32_t zoom)
    {
        lv_image_set_scale(obj_, zoom);
        return *this;
    }
 
    Image &pivot(int32_t x, int32_t y)
    {
        lv_image_set_pivot(obj_, x, y);
        return *this;
    }
 
    Image &inner_align(lv_image_align_t align)
    {
        lv_image_set_inner_align(obj_, align);
        return *this;
    }
};
 
static_assert(sizeof(Image) == sizeof(void *), "Image must be pointer-sized");
 
class Msgbox : public ObjectView,
           public ObjectMixin<Msgbox>,
           public EventMixin<Msgbox>,
           public StyleMixin<Msgbox>
{
      public:
    explicit Msgbox(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Msgbox create(ObjectView parent)
    {
        return Msgbox(lv_msgbox_create(parent));
    }
 
    Msgbox &add_title(const char *txt)
    {
        lv_msgbox_add_title(obj_, txt);
        return *this;
    }
 
    Msgbox &add_text(const char *txt)
    {
        lv_msgbox_add_text(obj_, txt);
        return *this;
    }
 
    Msgbox &add_close_button()
    {
        lv_msgbox_add_close_button(obj_);
        return *this;
    }
 
    ObjectView add_footer_button(const char *txt)
    {
        return ObjectView(lv_msgbox_add_footer_button(obj_, txt));
    }
 
    ObjectView get_content() const
    {
        return ObjectView(lv_msgbox_get_content(obj_));
    }
 
    ObjectView get_header() const
    {
        return ObjectView(lv_msgbox_get_header(obj_));
    }
 
    ObjectView get_footer() const
    {
        return ObjectView(lv_msgbox_get_footer(obj_));
    }
 
    void close()
    {
        lv_msgbox_close(obj_);
    }
};
 
static_assert(sizeof(Msgbox) == sizeof(void *), "Msgbox must be pointer-sized");
 
class Spinner : public ObjectView,
        public ObjectMixin<Spinner>,
        public EventMixin<Spinner>,
        public StyleMixin<Spinner>
{
      public:
    explicit Spinner(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Spinner create(ObjectView parent)
    {
        return Spinner(lv_spinner_create(parent));
    }
 
    Spinner &anim_params(uint32_t time_ms, uint32_t angle_deg)
    {
        lv_spinner_set_anim_params(obj_, time_ms, angle_deg);
        return *this;
    }
};
 
static_assert(sizeof(Spinner) == sizeof(void *), "Spinner must be pointer-sized");
 
class Led : public ObjectView,
        public ObjectMixin<Led>,
        public EventMixin<Led>,
        public StyleMixin<Led>
{
      public:
    explicit Led(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Led create(ObjectView parent)
    {
        return Led(lv_led_create(parent));
    }
 
    Led &color(lv_color_t c)
    {
        lv_led_set_color(obj_, c);
        return *this;
    }
 
    Led &brightness(uint8_t bright)
    {
        lv_led_set_brightness(obj_, bright);
        return *this;
    }
 
    Led &on()
    {
        lv_led_on(obj_);
        return *this;
    }
 
    Led &off()
    {
        lv_led_off(obj_);
        return *this;
    }
 
    Led &toggle()
    {
        lv_led_toggle(obj_);
        return *this;
    }
 
    uint8_t get_brightness() const
    {
        return lv_led_get_brightness(obj_);
    }
};
 
static_assert(sizeof(Led) == sizeof(void *), "Led must be pointer-sized");
 
class Textarea : public ObjectView,
         public ObjectMixin<Textarea>,
         public EventMixin<Textarea>,
         public StyleMixin<Textarea>
{
      public:
    explicit Textarea(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Textarea create(ObjectView parent)
    {
        return Textarea(lv_textarea_create(parent));
    }
 
    Textarea &text(const char *txt)
    {
        lv_textarea_set_text(obj_, txt);
        return *this;
    }
 
    Textarea &add_text(const char *txt)
    {
        lv_textarea_add_text(obj_, txt);
        return *this;
    }
 
    Textarea &placeholder(const char *txt)
    {
        lv_textarea_set_placeholder_text(obj_, txt);
        return *this;
    }
 
    Textarea &one_line(bool en)
    {
        lv_textarea_set_one_line(obj_, en);
        return *this;
    }
 
    Textarea &password_mode(bool en)
    {
        lv_textarea_set_password_mode(obj_, en);
        return *this;
    }
 
    Textarea &max_length(uint32_t n)
    {
        lv_textarea_set_max_length(obj_, n);
        return *this;
    }
 
    Textarea &accepted_chars(const char *list)
    {
        lv_textarea_set_accepted_chars(obj_, list);
        return *this;
    }
 
    Textarea &cursor_pos(int32_t pos)
    {
        lv_textarea_set_cursor_pos(obj_, pos);
        return *this;
    }
 
    Textarea &cursor_click_pos(bool en)
    {
        lv_textarea_set_cursor_click_pos(obj_, en);
        return *this;
    }
 
    const char *get_text() const
    {
        return lv_textarea_get_text(obj_);
    }
 
    uint32_t get_cursor_pos() const
    {
        return lv_textarea_get_cursor_pos(obj_);
    }
 
    bool is_password_mode() const
    {
        return lv_textarea_get_password_mode(obj_);
    }
 
    bool is_one_line() const
    {
        return lv_textarea_get_one_line(obj_);
    }
 
    Textarea &add_char(uint32_t c)
    {
        lv_textarea_add_char(obj_, c);
        return *this;
    }
 
    Textarea &delete_char()
    {
        lv_textarea_delete_char(obj_);
        return *this;
    }
};
 
static_assert(sizeof(Textarea) == sizeof(void *), "Textarea must be pointer-sized");
 
class Dropdown : public ObjectView,
         public ObjectMixin<Dropdown>,
         public EventMixin<Dropdown>,
         public StyleMixin<Dropdown>
{
      public:
    explicit Dropdown(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Dropdown create(ObjectView parent)
    {
        return Dropdown(lv_dropdown_create(parent));
    }
 
    Dropdown &options(const char *opts)
    {
        lv_dropdown_set_options(obj_, opts);
        return *this;
    }
 
    Dropdown &options_static(const char *opts)
    {
        lv_dropdown_set_options_static(obj_, opts);
        return *this;
    }
 
    Dropdown &add_option(const char *opt, uint32_t pos)
    {
        lv_dropdown_add_option(obj_, opt, pos);
        return *this;
    }
 
    Dropdown &clear_options()
    {
        lv_dropdown_clear_options(obj_);
        return *this;
    }
 
    Dropdown &selected(uint32_t sel)
    {
        lv_dropdown_set_selected(obj_, sel);
        return *this;
    }
 
    Dropdown &dir(lv_dir_t d)
    {
        lv_dropdown_set_dir(obj_, d);
        return *this;
    }
 
    Dropdown &symbol(const void *sym)
    {
        lv_dropdown_set_symbol(obj_, sym);
        return *this;
    }
 
    uint32_t get_selected() const
    {
        return lv_dropdown_get_selected(obj_);
    }
 
    uint32_t get_option_count() const
    {
        return lv_dropdown_get_option_count(obj_);
    }
 
    void get_selected_str(char *buf, uint32_t size) const
    {
        lv_dropdown_get_selected_str(obj_, buf, size);
    }
 
    const char *get_options() const
    {
        return lv_dropdown_get_options(obj_);
    }
 
    bool is_open() const
    {
        return lv_dropdown_is_open(const_cast<lv_obj_t *>(obj_));
    }
 
    void open()
    {
        lv_dropdown_open(obj_);
    }
 
    void close()
    {
        lv_dropdown_close(obj_);
    }
};
 
static_assert(sizeof(Dropdown) == sizeof(void *), "Dropdown must be pointer-sized");
 
class Roller : public ObjectView,
           public ObjectMixin<Roller>,
           public EventMixin<Roller>,
           public StyleMixin<Roller>
{
      public:
    explicit Roller(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Roller create(ObjectView parent)
    {
        return Roller(lv_roller_create(parent));
    }
 
    Roller &options(const char *opts, lv_roller_mode_t mode = LV_ROLLER_MODE_NORMAL)
    {
        lv_roller_set_options(obj_, opts, mode);
        return *this;
    }
 
    Roller &selected(uint32_t sel, lv_anim_enable_t anim = LV_ANIM_OFF)
    {
        lv_roller_set_selected(obj_, sel, anim);
        return *this;
    }
 
    Roller &visible_row_count(uint32_t rows)
    {
        lv_roller_set_visible_row_count(obj_, rows);
        return *this;
    }
 
    uint32_t get_selected() const
    {
        return lv_roller_get_selected(obj_);
    }
 
    uint32_t get_option_count() const
    {
        return lv_roller_get_option_count(obj_);
    }
 
    void get_selected_str(char *buf, uint32_t size) const
    {
        lv_roller_get_selected_str(obj_, buf, size);
    }
 
    const char *get_options() const
    {
        return lv_roller_get_options(obj_);
    }
};
 
static_assert(sizeof(Roller) == sizeof(void *), "Roller must be pointer-sized");
 
class Spinbox : public ObjectView,
        public ObjectMixin<Spinbox>,
        public EventMixin<Spinbox>,
        public StyleMixin<Spinbox>
{
      public:
    explicit Spinbox(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Spinbox create(ObjectView parent)
    {
        return Spinbox(lv_spinbox_create(parent));
    }
 
    Spinbox &value(int32_t v)
    {
        lv_spinbox_set_value(obj_, v);
        return *this;
    }
 
    Spinbox &range(int32_t min, int32_t max)
    {
        lv_spinbox_set_range(obj_, min, max);
        return *this;
    }
 
    Spinbox &step(uint32_t s)
    {
        lv_spinbox_set_step(obj_, s);
        return *this;
    }
 
    Spinbox &digit_format(uint32_t digit_count, uint32_t sep_pos)
    {
        lv_spinbox_set_digit_format(obj_, digit_count, sep_pos);
        return *this;
    }
 
    Spinbox &rollover(bool on)
    {
        lv_spinbox_set_rollover(obj_, on);
        return *this;
    }
 
    Spinbox &cursor_pos(uint32_t pos)
    {
        lv_spinbox_set_cursor_pos(obj_, pos);
        return *this;
    }
 
    int32_t get_value() const
    {
        return lv_spinbox_get_value(const_cast<lv_obj_t *>(obj_));
    }
 
    int32_t get_step() const
    {
        return lv_spinbox_get_step(const_cast<lv_obj_t *>(obj_));
    }
 
    Spinbox &increment()
    {
        lv_spinbox_increment(obj_);
        return *this;
    }
 
    Spinbox &decrement()
    {
        lv_spinbox_decrement(obj_);
        return *this;
    }
};
 
static_assert(sizeof(Spinbox) == sizeof(void *), "Spinbox must be pointer-sized");
 
class Keyboard : public ObjectView,
         public ObjectMixin<Keyboard>,
         public EventMixin<Keyboard>,
         public StyleMixin<Keyboard>
{
      public:
    explicit Keyboard(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Keyboard create(ObjectView parent)
    {
        return Keyboard(lv_keyboard_create(parent));
    }
 
    Keyboard &attach(Textarea ta)
    {
        lv_keyboard_set_textarea(obj_, ta.get());
        return *this;
    }
 
    Keyboard &mode(lv_keyboard_mode_t m)
    {
        lv_keyboard_set_mode(obj_, m);
        return *this;
    }
 
    Keyboard &popovers(bool en)
    {
        lv_keyboard_set_popovers(obj_, en);
        return *this;
    }
 
    ObjectView get_textarea() const
    {
        return ObjectView(lv_keyboard_get_textarea(obj_));
    }
};
 
static_assert(sizeof(Keyboard) == sizeof(void *), "Keyboard must be pointer-sized");
 
class Chart : public ObjectView,
          public ObjectMixin<Chart>,
          public EventMixin<Chart>,
          public StyleMixin<Chart>
{
      public:
    class Series
    {
          public:
        Series() : chart_(nullptr), ser_(nullptr)
        {
        }
        Series(lv_obj_t *chart, lv_chart_series_t *ser) : chart_(chart), ser_(ser)
        {
        }
 
        lv_chart_series_t *get() const
        {
            return ser_;
        }
        explicit operator bool() const
        {
            return ser_ != nullptr;
        }
 
        Series &next_value(int32_t v)
        {
            lv_chart_set_next_value(chart_, ser_, v);
            return *this;
        }
 
        Series &set_value_by_idx(uint32_t idx, int32_t v)
        {
            lv_chart_set_value_by_id(chart_, ser_, idx, v);
            return *this;
        }
 
          private:
        lv_obj_t *chart_;
        lv_chart_series_t *ser_;
    };
 
    explicit Chart(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Chart create(ObjectView parent)
    {
        return Chart(lv_chart_create(parent));
    }
 
    Chart &type(lv_chart_type_t t)
    {
        lv_chart_set_type(obj_, t);
        return *this;
    }
 
    Chart &point_count(uint32_t count)
    {
        lv_chart_set_point_count(obj_, count);
        return *this;
    }
 
    Chart &range(lv_chart_axis_t axis, int32_t min, int32_t max)
    {
        lv_chart_set_range(obj_, axis, min, max);
        return *this;
    }
 
    Chart &update_mode(lv_chart_update_mode_t mode)
    {
        lv_chart_set_update_mode(obj_, mode);
        return *this;
    }
 
    Chart &div_line_count(uint8_t hdiv, uint8_t vdiv)
    {
        lv_chart_set_div_line_count(obj_, hdiv, vdiv);
        return *this;
    }
 
    Series add_series(lv_color_t color, lv_chart_axis_t axis)
    {
        lv_chart_series_t *s = lv_chart_add_series(obj_, color, axis);
        return Series(obj_, s);
    }
 
    Chart &remove_series(Series s)
    {
        lv_chart_remove_series(obj_, s.get());
        return *this;
    }
};
 
static_assert(sizeof(Chart) == sizeof(void *), "Chart must be pointer-sized");
 
class Table : public ObjectView,
          public ObjectMixin<Table>,
          public EventMixin<Table>,
          public StyleMixin<Table>
{
      public:
    explicit Table(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Table create(ObjectView parent)
    {
        return Table(lv_table_create(parent));
    }
 
    Table &cell_value(uint32_t row, uint32_t col, const char *txt)
    {
        lv_table_set_cell_value(obj_, row, col, txt);
        return *this;
    }
 
    Table &row_count(uint32_t n)
    {
        lv_table_set_row_count(obj_, n);
        return *this;
    }
 
    Table &column_count(uint32_t n)
    {
        lv_table_set_column_count(obj_, n);
        return *this;
    }
 
    Table &column_width(uint32_t col, int32_t w)
    {
        lv_table_set_column_width(obj_, col, w);
        return *this;
    }
 
    const char *get_cell_value(uint32_t row, uint32_t col) const
    {
        return lv_table_get_cell_value(obj_, row, col);
    }
 
    uint32_t get_row_count() const
    {
        return lv_table_get_row_count(obj_);
    }
 
    uint32_t get_column_count() const
    {
        return lv_table_get_column_count(obj_);
    }
 
    int32_t get_column_width(uint32_t col) const
    {
        return lv_table_get_column_width(obj_, col);
    }
};
 
static_assert(sizeof(Table) == sizeof(void *), "Table must be pointer-sized");
 
class Tabview : public ObjectView,
        public ObjectMixin<Tabview>,
        public EventMixin<Tabview>,
        public StyleMixin<Tabview>
{
      public:
    explicit Tabview(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Tabview create(ObjectView parent)
    {
        return Tabview(lv_tabview_create(parent));
    }
 
    ObjectView add_tab(const char *name)
    {
        return ObjectView(lv_tabview_add_tab(obj_, name));
    }
 
    Tabview &rename_tab(uint32_t idx, const char *name)
    {
        lv_tabview_set_tab_text(obj_, idx, name);
        return *this;
    }
 
    Tabview &set_active_tab(uint32_t idx, lv_anim_enable_t anim)
    {
        lv_tabview_set_active(obj_, idx, anim);
        return *this;
    }
 
    Tabview &tab_bar_position(lv_dir_t dir)
    {
        lv_tabview_set_tab_bar_position(obj_, dir);
        return *this;
    }
 
    Tabview &tab_bar_size(int32_t size)
    {
        lv_tabview_set_tab_bar_size(obj_, size);
        return *this;
    }
 
    uint32_t get_tab_count() const
    {
        return lv_tabview_get_tab_count(obj_);
    }
 
    uint32_t get_tab_active() const
    {
        return lv_tabview_get_tab_active(obj_);
    }
 
    ObjectView get_content() const
    {
        return ObjectView(lv_tabview_get_content(obj_));
    }
};
 
static_assert(sizeof(Tabview) == sizeof(void *), "Tabview must be pointer-sized");
 
class List : public ObjectView,
         public ObjectMixin<List>,
         public EventMixin<List>,
         public StyleMixin<List>
{
      public:
    explicit List(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static List create(ObjectView parent)
    {
        return List(lv_list_create(parent));
    }
 
    ObjectView add_text(const char *text)
    {
        return ObjectView(lv_list_add_text(obj_, text));
    }
 
    ObjectView add_button(const void *icon, const char *text)
    {
        return ObjectView(lv_list_add_button(obj_, icon, text));
    }
 
    const char *get_button_text(ObjectView btn) const
    {
        return lv_list_get_button_text(obj_, btn);
    }
};
 
static_assert(sizeof(List) == sizeof(void *), "List must be pointer-sized");
 
class Canvas : public ObjectView,
           public ObjectMixin<Canvas>,
           public EventMixin<Canvas>,
           public StyleMixin<Canvas>
{
      public:
    explicit Canvas(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Canvas create(ObjectView parent)
    {
        return Canvas(lv_canvas_create(parent));
    }
 
    Canvas &buffer(void *buf, int32_t w, int32_t h, lv_color_format_t cf)
    {
        lv_canvas_set_buffer(obj_, buf, w, h, cf);
        return *this;
    }
 
    Canvas &fill_bg(lv_color_t color, lv_opa_t opa)
    {
        lv_canvas_fill_bg(obj_, color, opa);
        return *this;
    }
 
    Canvas &set_pixel(int32_t x, int32_t y, lv_color_t color)
    {
        lv_canvas_set_px(obj_, x, y, color, LV_OPA_COVER);
        return *this;
    }
 
    Canvas &init_layer(lv_layer_t *layer)
    {
        lv_canvas_init_layer(obj_, layer);
        return *this;
    }
 
    Canvas &finish_layer(lv_layer_t *layer)
    {
        lv_canvas_finish_layer(obj_, layer);
        return *this;
    }
};
 
static_assert(sizeof(Canvas) == sizeof(void *), "Canvas must be pointer-sized");
 
class Calendar : public ObjectView,
         public ObjectMixin<Calendar>,
         public EventMixin<Calendar>,
         public StyleMixin<Calendar>
{
      public:
    explicit Calendar(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Calendar create(ObjectView parent)
    {
        return Calendar(lv_calendar_create(parent));
    }
 
    Calendar &today(uint32_t year, uint32_t month, uint32_t day)
    {
        lv_calendar_set_today_date(obj_, year, month, day);
        return *this;
    }
 
    Calendar &showed(uint32_t year, uint32_t month)
    {
        lv_calendar_set_showed_date(obj_, year, month);
        return *this;
    }
 
    Calendar &highlighted_dates(lv_calendar_date_t *dates, size_t count)
    {
        lv_calendar_set_highlighted_dates(obj_, dates, static_cast<uint16_t>(count));
        return *this;
    }
 
    bool get_pressed_date(lv_calendar_date_t *out) const
    {
        return lv_calendar_get_pressed_date(obj_, out);
    }
 
    ObjectView add_header_arrow()
    {
        return ObjectView(lv_calendar_header_arrow_create(obj_));
    }
 
    ObjectView add_header_dropdown()
    {
        return ObjectView(lv_calendar_header_dropdown_create(obj_));
    }
};
 
static_assert(sizeof(Calendar) == sizeof(void *), "Calendar must be pointer-sized");
 
 
/* ================================================================== */
/*  Layout helpers                                                    */
/* ================================================================== */
 
inline Box vbox(ObjectView parent)
{
    auto b = Box::create(parent);
    lv_obj_set_flex_flow(b.get(), LV_FLEX_FLOW_COLUMN);
    lv_obj_set_size(b.get(), LV_SIZE_CONTENT, LV_SIZE_CONTENT);
    return b;
}
 
inline Box hbox(ObjectView parent)
{
    auto b = Box::create(parent);
    lv_obj_set_flex_flow(b.get(), LV_FLEX_FLOW_ROW);
    lv_obj_set_size(b.get(), LV_SIZE_CONTENT, LV_SIZE_CONTENT);
    return b;
}
 
/* ================================================================== */
/*  Group — keyboard / encoder focus groups                           */
/* ================================================================== */
 
class Group
{
      public:
    Group() : group_(nullptr)
    {
    }
    explicit Group(lv_group_t *g) : group_(g)
    {
    }
 
    ~Group() noexcept
    {
        if (group_)
            lv_group_delete(group_);
    }
 
    Group(const Group &) = delete;
    Group &operator=(const Group &) = delete;
 
    Group(Group &&other) noexcept : group_(other.group_)
    {
        other.group_ = nullptr;
    }
 
    Group &operator=(Group &&other) noexcept
    {
        if (this != &other) {
            if (group_)
                lv_group_delete(group_);
            group_ = other.group_;
            other.group_ = nullptr;
        }
        return *this;
    }
 
    static Group create()
    {
        return Group(lv_group_create());
    }
 
    static lv_group_t *get_default()
    {
        return lv_group_get_default();
    }
 
    lv_group_t *get() const
    {
        return group_;
    }
 
    Group &set_as_default()
    {
        lv_group_set_default(group_);
        return *this;
    }
 
    Group &add(ObjectView obj)
    {
        lv_group_add_obj(group_, obj);
        return *this;
    }
 
    Group &remove_all()
    {
        lv_group_remove_all_objs(group_);
        return *this;
    }
 
    Group &focus_next()
    {
        lv_group_focus_next(group_);
        return *this;
    }
 
    Group &focus_prev()
    {
        lv_group_focus_prev(group_);
        return *this;
    }
 
    Group &focus_freeze(bool freeze)
    {
        lv_group_focus_freeze(group_, freeze);
        return *this;
    }
 
    ObjectView focused() const
    {
        return ObjectView(lv_group_get_focused(group_));
    }
 
    Group &edit_mode(bool enable)
    {
        lv_group_set_editing(group_, enable);
        return *this;
    }
 
    bool is_editing() const
    {
        return lv_group_get_editing(group_);
    }
 
    uint32_t obj_count() const
    {
        return lv_group_get_obj_count(group_);
    }
 
    static void focus_obj(ObjectView obj)
    {
        lv_group_focus_obj(obj);
    }
 
    static void remove_obj(ObjectView obj)
    {
        lv_group_remove_obj(obj);
    }
 
      private:
    lv_group_t *group_;
};
 
/* ================================================================== */
/*  Screen — top-level display root with load/load_anim               */
/* ================================================================== */
 
class Screen : public ObjectView,
           public ObjectMixin<Screen>,
           public EventMixin<Screen>,
           public StyleMixin<Screen>
{
      public:
    explicit Screen(lv_obj_t *obj) : ObjectView(obj)
    {
    }
 
    static Screen create()
    {
        return Screen(lv_obj_create(nullptr));
    }
 
    static Screen active()
    {
        return Screen(lv_screen_active());
    }
 
    void load()
    {
        lv_screen_load(obj_);
    }
 
    void load_anim(lv_screen_load_anim_t anim, uint32_t time_ms, uint32_t delay_ms = 0,
               bool auto_del = false)
    {
        lv_screen_load_anim(obj_, anim, time_ms, delay_ms, auto_del);
    }
};
 
static_assert(sizeof(Screen) == sizeof(void *), "Screen must be pointer-sized");
 
 
/* ================================================================== */
/*  Timer — RAII wrapper around lv_timer_t                            */
/* ================================================================== */
 
class Timer
{
      public:
    Timer() : timer_(nullptr)
    {
    }
 
    Timer(lv_timer_cb_t cb, uint32_t period_ms, void *user_data = nullptr)
        : timer_(lv_timer_create(cb, period_ms, user_data))
    {
    }
 
    ~Timer() noexcept
    {
        if (timer_)
            lv_timer_delete(timer_);
    }
 
    Timer(const Timer &) = delete;
    Timer &operator=(const Timer &) = delete;
 
    Timer(Timer &&other) noexcept : timer_(other.timer_)
    {
        other.timer_ = nullptr;
    }
 
    Timer &operator=(Timer &&other) noexcept
    {
        if (this != &other) {
            if (timer_)
                lv_timer_delete(timer_);
            timer_ = other.timer_;
            other.timer_ = nullptr;
        }
        return *this;
    }
 
    lv_timer_t *get() const
    {
        return timer_;
    }
 
    explicit operator bool() const
    {
        return timer_ != nullptr;
    }
 
    Timer &period(uint32_t ms)
    {
        if (timer_)
            lv_timer_set_period(timer_, ms);
        return *this;
    }
 
    Timer &pause()
    {
        if (timer_)
            lv_timer_pause(timer_);
        return *this;
    }
 
    Timer &resume()
    {
        if (timer_)
            lv_timer_resume(timer_);
        return *this;
    }
 
    Timer &repeat_count(int32_t count)
    {
        if (timer_)
            lv_timer_set_repeat_count(timer_, count);
        return *this;
    }
 
    Timer &reset()
    {
        if (timer_)
            lv_timer_reset(timer_);
        return *this;
    }
 
    Timer &ready()
    {
        if (timer_)
            lv_timer_ready(timer_);
        return *this;
    }
 
      private:
    lv_timer_t *timer_;
};
 
/* ================================================================== */
/*  Animation — builder for lv_anim_t                                 */
/* ================================================================== */
 
class Animation
{
      public:
    Animation()
    {
        lv_anim_init(&anim_);
    }
 
    Animation &target(void *var)
    {
        lv_anim_set_var(&anim_, var);
        return *this;
    }
 
    Animation &target(ObjectView obj)
    {
        return target(obj.get());
    }
 
    Animation &values(int32_t from, int32_t to)
    {
        lv_anim_set_values(&anim_, from, to);
        return *this;
    }
 
    Animation &duration(uint32_t ms)
    {
        lv_anim_set_duration(&anim_, ms);
        return *this;
    }
 
    Animation &delay(uint32_t ms)
    {
        lv_anim_set_delay(&anim_, ms);
        return *this;
    }
 
    Animation &path(lv_anim_path_cb_t cb)
    {
        lv_anim_set_path_cb(&anim_, cb);
        return *this;
    }
 
    Animation &repeat_count(uint32_t count)
    {
        lv_anim_set_repeat_count(&anim_, count);
        return *this;
    }
 
    Animation &repeat_delay(uint32_t ms)
    {
        lv_anim_set_repeat_delay(&anim_, ms);
        return *this;
    }
 
    Animation &playback_duration(uint32_t ms)
    {
        lv_anim_set_playback_duration(&anim_, ms);
        return *this;
    }
 
    Animation &playback_delay(uint32_t ms)
    {
        lv_anim_set_playback_delay(&anim_, ms);
        return *this;
    }
 
    Animation &exec_cb(lv_anim_exec_xcb_t cb)
    {
        lv_anim_set_exec_cb(&anim_, cb);
        return *this;
    }
 
    Animation &ready_cb(lv_anim_ready_cb_t cb)
    {
        lv_anim_set_ready_cb(&anim_, cb);
        return *this;
    }
 
    void start()
    {
        lv_anim_start(&anim_);
    }
 
    static bool stop(void *var, lv_anim_exec_xcb_t exec_cb)
    {
        return lv_anim_delete(var, exec_cb);
    }
 
    static uint32_t duration_for_speed(uint32_t speed)
    {
        return lv_anim_speed(speed);
    }
 
      private:
    lv_anim_t anim_;
};
 
inline void animate_x(ObjectView obj, int32_t to, uint32_t duration_ms)
{
    Animation()
        .target(obj)
        .values(lv_obj_get_x(obj), to)
        .duration(duration_ms)
        .path(lv_anim_path_ease_out)
        .exec_cb(reinterpret_cast<lv_anim_exec_xcb_t>(lv_obj_set_x))
        .start();
}
 
inline void animate_y(ObjectView obj, int32_t to, uint32_t duration_ms)
{
    Animation()
        .target(obj)
        .values(lv_obj_get_y(obj), to)
        .duration(duration_ms)
        .path(lv_anim_path_ease_out)
        .exec_cb(reinterpret_cast<lv_anim_exec_xcb_t>(lv_obj_set_y))
        .start();
}
 
inline void animate_width(ObjectView obj, int32_t to, uint32_t duration_ms)
{
    Animation()
        .target(obj)
        .values(lv_obj_get_width(obj), to)
        .duration(duration_ms)
        .path(lv_anim_path_ease_out)
        .exec_cb(reinterpret_cast<lv_anim_exec_xcb_t>(lv_obj_set_width))
        .start();
}
 
namespace detail
{
inline void anim_set_opa_shim(void *var, int32_t v)
{
    lv_obj_set_style_opa(static_cast<lv_obj_t *>(var), static_cast<lv_opa_t>(v), LV_PART_MAIN);
}
} // namespace detail
 
inline void animate_opa(ObjectView obj, lv_opa_t to, uint32_t duration_ms)
{
    lv_opa_t from = lv_obj_get_style_opa(obj, LV_PART_MAIN);
    Animation()
        .target(obj)
        .values(from, to)
        .duration(duration_ms)
        .path(lv_anim_path_ease_in_out)
        .exec_cb(detail::anim_set_opa_shim)
        .start();
}
 
/* ================================================================== */
/*  Component<Derived> — CRTP UI composition base                     */
/* ================================================================== */
 
template <typename Derived> class Component
{
      public:
    Component() = default;
    ~Component() = default;
 
    Component(const Component &) = delete;
    Component &operator=(const Component &) = delete;
 
    void mount(ObjectView parent)
    {
        if (root_)
            return;
        root_ = static_cast<Derived *>(this)->build(parent);
        /* Store 'this' in root's user data for from_event() */
        lv_obj_set_user_data(root_.get(), this);
        /* Track external deletion (e.g. screen auto_del) */
        lv_obj_add_event_cb(root_.get(), delete_cb, LV_EVENT_DELETE, this);
    }
 
    void unmount()
    {
        if (!root_)
            return;
        /* Remove the delete callback before we delete, to avoid
         * the callback nulling root_ and then us using it. */
        lv_obj_t *obj = root_.get();
        root_ = ObjectView();
        lv_obj_delete(obj);
    }
 
    bool is_mounted() const
    {
        return static_cast<bool>(root_);
    }
 
    ObjectView root() const
    {
        return root_;
    }
 
    void hide()
    {
        if (root_)
            lv_obj_add_flag(root_.get(), LV_OBJ_FLAG_HIDDEN);
    }
 
    void show()
    {
        if (root_)
            lv_obj_remove_flag(root_.get(), LV_OBJ_FLAG_HIDDEN);
    }
 
    static Derived *from_event(lv_event_t *e)
    {
        lv_obj_t *target = static_cast<lv_obj_t *>(lv_event_get_target(e));
        while (target) {
            void *ud = lv_obj_get_user_data(target);
            if (ud)
                return static_cast<Derived *>(static_cast<Component *>(ud));
            target = lv_obj_get_parent(target);
        }
        return nullptr;
    }
 
      protected:
    ObjectView root_;
 
      private:
    static void delete_cb(lv_event_t *e)
    {
        auto *self = static_cast<Component *>(lv_event_get_user_data(e));
        /* Object is being deleted externally — just clear our ref */
        self->root_ = ObjectView();
    }
};
 
/* ================================================================== */
/*  Display info + top layer helpers                                  */
/* ================================================================== */
 
inline int32_t display_width()
{
    return lv_display_get_horizontal_resolution(nullptr);
}
 
inline int32_t display_height()
{
    return lv_display_get_vertical_resolution(nullptr);
}
 
inline int32_t display_dpi()
{
    return lv_display_get_dpi(nullptr);
}
 
inline ObjectView layer_top()
{
    return ObjectView(lv_layer_top());
}
 
 
} /* namespace ove::lvgl */