4 #ifdef USE_BINARY_SENSOR 6 #endif // USE_BINARY_SENSOR 9 #endif // USE_LVGL_IMAGE 10 #ifdef USE_LVGL_ROTARY_ENCODER 12 #endif // USE_LVGL_ROTARY_ENCODER 16 #define LV_CONF_SKIP 1 // NOLINT 30 #endif // USE_LVGL_FONT 31 #ifdef USE_LVGL_TOUCHSCREEN 33 #endif // USE_LVGL_TOUCHSCREEN 35 #if defined(USE_LVGL_BUTTONMATRIX) || defined(USE_LVGL_KEYBOARD) 37 #endif // USE_LVGL_BUTTONMATRIX 45 #if LV_COLOR_DEPTH == 16 47 #elif LV_COLOR_DEPTH == 32 49 #else // LV_COLOR_DEPTH 51 #endif // LV_COLOR_DEPTH 66 #ifdef USE_LVGL_CANVAS 68 lv_draw_img_dsc_t *dsc) {
75 lv_coord_t pivot_x, lv_coord_t pivot_y) {
78 #endif // USE_LVGL_METER 79 #endif // USE_LVGL_IMAGE 80 #ifdef USE_LVGL_ANIMIMG 82 auto *dsc =
static_cast<std::vector<lv_img_dsc_t *> *
>(lv_obj_get_user_data(img));
85 dsc =
new std::vector<lv_img_dsc_t *>(images.size());
86 lv_obj_set_user_data(img, dsc);
89 for (
auto &image : images) {
90 dsc->push_back(image->get_lv_img_dsc());
95 #endif // USE_LVGL_ANIMIMG 101 virtual void set_obj(lv_obj_t *lv_obj) { this->
obj = lv_obj; }
113 this->
obj = lv_obj_create(
nullptr);
116 bool is_showing()
const;
132 void play(Ts...
x)
override { this->lamb_(
x...); }
141 const lv_font_t *get_lv_font();
150 uint32_t last_letter_{};
152 lv_font_t lv_font_{};
154 #endif // USE_LVGL_FONT 155 #ifdef USE_LVGL_ANIMIMG 157 #endif // USE_LVGL_ANIMIMG 160 constexpr
static const char *
const TAG =
"lvgl";
163 LvglComponent(std::vector<display::Display *> displays,
float buffer_frac,
bool full_refresh,
int draw_rounding,
164 bool resume_on_input);
165 static void static_flush_cb(lv_disp_drv_t *disp_drv,
const lv_area_t *area, lv_color_t *color_p);
168 void setup()
override;
169 void update()
override;
170 void loop()
override;
172 this->idle_callbacks_.add(std::move(callback));
174 void add_on_pause_callback(std::function<
void(
bool)> &&callback) { this->pause_callbacks_.add(std::move(callback)); }
175 void dump_config()
override;
176 bool is_idle(uint32_t idle_ms) {
return lv_disp_get_inactive_time(this->disp_) > idle_ms; }
178 lv_obj_t *
get_scr_act() {
return lv_disp_get_scr_act(this->disp_); }
182 void set_paused(
bool paused,
bool show_snow);
186 if (this->paused_ && this->resume_on_input_) {
187 this->set_paused(
false,
false);
194 static void esphome_lvgl_init();
195 static void add_event_cb(lv_obj_t *obj,
event_callback_t callback, lv_event_code_t event);
196 static void add_event_cb(lv_obj_t *obj,
event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2);
197 static void add_event_cb(lv_obj_t *obj,
event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2,
198 lv_event_code_t event3);
200 void show_page(
size_t index, lv_scr_load_anim_t anim, uint32_t time);
201 void show_next_page(lv_scr_load_anim_t anim, uint32_t time);
202 void show_prev_page(lv_scr_load_anim_t anim, uint32_t time);
204 size_t get_current_page()
const;
205 void set_focus_mark(lv_group_t *group) { this->focus_marks_[group] = lv_group_get_focused(group); }
207 auto *mark = this->focus_marks_[group];
208 if (mark !=
nullptr) {
209 lv_group_focus_obj(mark);
213 size_t draw_rounding{2};
218 void write_random_();
219 void draw_buffer_(
const lv_area_t *area, lv_color_t *ptr);
220 void flush_cb_(lv_disp_drv_t *disp_drv,
const lv_area_t *area, lv_color_t *color_p);
222 std::vector<display::Display *> displays_{};
223 size_t buffer_frac_{1};
224 bool full_refresh_{};
225 bool resume_on_input_{};
227 lv_disp_draw_buf_t draw_buf_{};
228 lv_disp_drv_t disp_drv_{};
231 std::vector<LvPageType *> pages_{};
232 size_t current_page_{0};
234 bool page_wrap_{
true};
235 std::map<lv_group_t *, lv_obj_t *> focus_marks_{};
239 lv_color_t *rotate_buf_{};
262 void play(Ts...
x)
override { this->action_(this->parent_); }
265 std::function<void(LvglComponent *)> action_{};
270 LvglCondition(std::function<
bool(Tc *)> &&condition_lambda) : condition_lambda_(
std::move(condition_lambda)) {}
271 bool check(Ts...
x)
override {
return this->condition_lambda_(this->parent_); }
274 std::function<bool(Tc *)> condition_lambda_{};
277 #ifdef USE_LVGL_TOUCHSCREEN 283 touch_pressed_ =
false;
284 this->parent_->maybe_wakeup();
286 lv_indev_drv_t *
get_drv() {
return &this->drv_; }
289 lv_indev_drv_t drv_{};
291 bool touch_pressed_{};
293 #endif // USE_LVGL_TOUCHSCREEN 295 #ifdef USE_LVGL_KEY_LISTENER 300 #ifdef USE_BINARY_SENSOR 306 #ifdef USE_LVGL_ROTARY_ENCODER 310 #endif // USE_LVGL_ROTARY_ENCODER 313 if (!this->parent_->is_paused()) {
314 this->pressed_ = pressed;
316 }
else if (!pressed) {
318 this->parent_->maybe_wakeup();
323 if (!this->parent_->is_paused()) {
324 this->count_ = count;
326 this->parent_->maybe_wakeup();
330 lv_indev_drv_t *
get_drv() {
return &this->drv_; }
333 lv_indev_drv_t drv_{};
336 int32_t last_count_{};
339 #endif // USE_LVGL_KEY_LISTENER 344 std::vector<lv_point_t>
get_points() {
return this->points_; }
346 this->points_ = std::move(points);
347 lv_line_set_points(this->obj, this->points_.data(), this->points_.size());
351 std::vector<lv_point_t> points_{};
354 #if defined(USE_LVGL_DROPDOWN) || defined(LV_USE_ROLLER) 357 virtual size_t get_selected_index() = 0;
358 virtual void set_selected_index(
size_t index, lv_anim_enable_t anim) = 0;
359 void set_selected_text(
const std::string &text, lv_anim_enable_t anim);
360 std::string get_selected_text();
362 void set_options(std::vector<std::string>
options);
365 virtual void set_option_string(
const char *options) = 0;
366 std::vector<std::string> options_{};
369 #ifdef USE_LVGL_DROPDOWN 373 void set_selected_index(
size_t index, lv_anim_enable_t anim)
override { lv_dropdown_set_selected(this->obj, index); }
378 #endif // USE_LVGL_DROPDOWN 380 #ifdef USE_LVGL_ROLLER 385 lv_roller_set_selected(this->obj, index, anim);
391 lv_roller_mode_t mode_{LV_ROLLER_MODE_NORMAL};
394 #endif // defined(USE_LVGL_DROPDOWN) || defined(LV_USE_ROLLER) 396 #ifdef USE_LVGL_BUTTONMATRIX 399 void set_obj(lv_obj_t *lv_obj)
override;
400 uint16_t
get_selected() {
return lv_btnmatrix_get_selected_btn(this->obj); }
401 void set_key(
size_t idx, uint8_t key) { this->key_map_[idx] = key; }
404 std::map<size_t, uint8_t> key_map_{};
406 #endif // USE_LVGL_BUTTONMATRIX 408 #ifdef USE_LVGL_KEYBOARD 411 void set_obj(lv_obj_t *lv_obj)
override;
413 #endif // USE_LVGL_KEYBOARD
std::string lv_event_code_name_for(uint8_t event_code)
void add_on_idle_callback(std::function< void(uint32_t)> &&callback)
std::vector< lv_point_t > get_points()
void set_sensor(rotary_encoder::RotaryEncoderSensor *sensor)
void lv_img_set_src(lv_obj_t *obj, esphome::image::Image *image)
void set_points(std::vector< lv_point_t > points)
bool check(Ts... x) override
std::vector< TouchPoint > TouchPoints_t
bool is_idle(uint32_t idle_ms)
void register_listener(std::function< void(uint32_t)> listener)
void set_selected_index(size_t index, lv_anim_enable_t anim) override
LvglCondition(std::function< bool(Tc *)> &&condition_lambda)
interface for components that provide keypresses
float get_setup_priority() const override
void set_option_string(const char *options) override
void lv_disp_set_bg_image(lv_disp_t *disp, esphome::image::Image *image)
lv_indev_drv_t * get_drv()
void lv_obj_set_style_bg_img_src(lv_obj_t *obj, esphome::image::Image *image, lv_style_selector_t selector)
void lv_canvas_draw_img(lv_obj_t *canvas, lv_coord_t x, lv_coord_t y, image::Image *image, lv_draw_img_dsc_t *dsc)
void play(Ts... x) override
Component for rendering LVGL.
This class simplifies creating components that periodically check a state.
void set_mode(lv_roller_mode_t mode)
virtual ~LvCompound()=default
void add_button(binary_sensor::BinarySensor *button, lv_key_t key)
void(_lv_event_t *) event_callback_t
TemplatableValue< bool > paused_
lv_event_code_t lv_update_event
std::function< void(float)> set_value_lambda_t
lv_event_code_t lv_api_event
void restore_focus_mark(lv_group_t *group)
virtual void set_obj(lv_obj_t *lv_obj)
Base class for all automation conditions.
void add_on_pause_callback(std::function< void(bool)> &&callback)
BedjetMode mode
BedJet operating mode.
void set_page_wrap(bool wrap)
std::function< void(Ts...)> lamb_
LvglAction(std::function< void(LvglComponent *)> &&lamb)
const float PROCESSOR
For components that use data from sensors like displays.
lv_meter_indicator_t * lv_meter_add_needle_img(lv_obj_t *obj, lv_meter_scale_t *scale, esphome::image::Image *src, lv_coord_t pivot_x, lv_coord_t pivot_y)
void lv_animimg_set_src(lv_obj_t *img, std::vector< image::Image *> images)
size_t get_selected_index() override
TemplatableValue< uint32_t > timeout_
lv_img_dsc_t * get_lv_img_dsc()
std::function< void(lv_obj_t *)> LvLambdaType
void event(int key, bool pressed)
std::function< const char *()> text_lambda_t
void add_on_state_callback(std::function< void(bool)> &&callback)
Add a callback to be notified of state changes.
void set_focus_mark(lv_group_t *group)
Implementation of SPI Controller mode.
Base class for all binary_sensor-type classes.
std::vector< std::string > get_options()
lv_indev_drv_t * get_drv()
void set_count(int32_t count)
void lv_animimg_stop(lv_obj_t *obj)
size_t get_selected_index() override
ObjUpdateAction(std::function< void(Ts...)> &&lamb)
esphome::sensor::Sensor * sensor
Helper class to easily give an object a parent of type T.
void play(Ts... x) override
void set_selected_index(size_t index, lv_anim_enable_t anim) override
void set_option_string(const char *options) override