4 #ifdef USE_BINARY_SENSOR 6 #endif // USE_BINARY_SENSOR 7 #ifdef USE_LVGL_ROTARY_ENCODER 9 #endif // USE_LVGL_ROTARY_ENCODER 13 #define LV_CONF_SKIP 1 // NOLINT 25 #endif // USE_LVGL_IMAGE 29 #endif // USE_LVGL_FONT 30 #ifdef USE_LVGL_TOUCHSCREEN 32 #endif // USE_LVGL_TOUCHSCREEN 34 #if defined(USE_LVGL_BUTTONMATRIX) || defined(USE_LVGL_KEYBOARD) 36 #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 56 virtual void set_obj(lv_obj_t *lv_obj) { this->
obj = lv_obj; }
66 this->
obj = lv_obj_create(
nullptr);
82 void play(Ts...
x)
override { this->lamb_(
x...); }
85 std::function<void(Ts...)>
lamb_;
91 const lv_font_t *get_lv_font();
100 uint32_t last_letter_{};
102 lv_font_t lv_font_{};
104 #endif // USE_LVGL_FONT 105 #ifdef USE_LVGL_IMAGE 107 #endif // USE_LVGL_IMAGE 109 #ifdef USE_LVGL_ANIMIMG 111 #endif // USE_LVGL_ANIMIMG 114 constexpr
static const char *
const TAG =
"lvgl";
117 static void static_flush_cb(lv_disp_drv_t *disp_drv,
const lv_area_t *area, lv_color_t *color_p);
120 void setup()
override;
121 void update()
override;
122 void loop()
override;
124 this->idle_callbacks_.add(std::move(callback));
128 void dump_config()
override;
130 bool is_idle(uint32_t idle_ms) {
return lv_disp_get_inactive_time(this->disp_) > idle_ms; }
133 void set_paused(
bool paused,
bool show_snow);
134 void add_event_cb(lv_obj_t *obj,
event_callback_t callback, lv_event_code_t event);
135 void add_event_cb(lv_obj_t *obj,
event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2);
136 void add_event_cb(lv_obj_t *obj,
event_callback_t callback, lv_event_code_t event1, lv_event_code_t event2,
137 lv_event_code_t event3);
140 void show_page(
size_t index, lv_scr_load_anim_t anim, uint32_t time);
141 void show_next_page(lv_scr_load_anim_t anim, uint32_t time);
142 void show_prev_page(lv_scr_load_anim_t anim, uint32_t time);
144 void set_focus_mark(lv_group_t *group) { this->focus_marks_[group] = lv_group_get_focused(group); }
146 auto *mark = this->focus_marks_[group];
147 if (mark !=
nullptr) {
148 lv_group_focus_obj(mark);
153 void write_random_();
154 void draw_buffer_(
const lv_area_t *area,
const uint8_t *ptr);
155 void flush_cb_(lv_disp_drv_t *disp_drv,
const lv_area_t *area, lv_color_t *color_p);
156 std::vector<display::Display *> displays_{};
157 lv_disp_draw_buf_t draw_buf_{};
158 lv_disp_drv_t disp_drv_{};
161 std::vector<LvPageType *> pages_{};
162 size_t current_page_{0};
164 lv_coord_t snow_line_{};
165 bool page_wrap_{
true};
166 std::map<lv_group_t *, lv_obj_t *> focus_marks_{};
168 std::vector<std::function<void(LvglComponent *lv_component)>>
init_lambdas_;
170 size_t buffer_frac_{1};
171 bool full_refresh_{};
186 void play(Ts...
x)
override { this->action_(this->parent_); }
189 std::function<void(LvglComponent *)> action_{};
195 : condition_lambda_(
std::move(condition_lambda)) {}
196 bool check(Ts...
x)
override {
return this->condition_lambda_(this->parent_); }
199 std::function<bool(LvglComponent *)> condition_lambda_{};
202 #ifdef USE_LVGL_TOUCHSCREEN 205 LVTouchListener(uint16_t long_press_time, uint16_t long_press_repeat_time);
207 void release()
override { touch_pressed_ =
false; }
208 lv_indev_drv_t *
get_drv() {
return &this->drv_; }
211 lv_indev_drv_t drv_{};
213 bool touch_pressed_{};
215 #endif // USE_LVGL_TOUCHSCREEN 217 #ifdef USE_LVGL_KEY_LISTENER 233 #ifdef USE_LVGL_ROTARY_ENCODER 237 #endif // USE_LVGL_ROTARY_ENCODER 240 if (!this->parent_->is_paused()) {
241 this->pressed_ = pressed;
247 if (!this->parent_->is_paused())
248 this->count_ = count;
251 lv_indev_drv_t *
get_drv() {
return &this->drv_; }
254 lv_indev_drv_t drv_{};
257 int32_t last_count_{};
260 #endif // USE_LVGL_KEY_LISTENER 262 #ifdef USE_LVGL_BUTTONMATRIX 265 void set_obj(lv_obj_t *lv_obj)
override;
266 uint16_t
get_selected() {
return lv_btnmatrix_get_selected_btn(this->obj); }
267 void set_key(
size_t idx, uint8_t key) { this->key_map_[idx] = key; }
270 std::map<size_t, uint8_t> key_map_{};
272 #endif // USE_LVGL_BUTTONMATRIX 274 #ifdef USE_LVGL_KEYBOARD 277 void set_obj(lv_obj_t *lv_obj)
override;
279 #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)
void set_sensor(rotary_encoder::RotaryEncoderSensor *sensor)
LvglCondition(std::function< bool(LvglComponent *)> &&condition_lambda)
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)
interface for components that provide keypresses
float get_setup_priority() const override
void set_full_refresh(bool full_refresh)
lv_indev_drv_t * get_drv()
void play(Ts... x) override
This class simplifies creating components that periodically check a state.
void add_display(display::Display *display)
std::vector< std::function< void(LvglComponent *lv_component)> > init_lambdas_
void(_lv_event_t *) event_callback_t
void set_left_button(binary_sensor::BinarySensor *left_button)
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)
void set_right_button(binary_sensor::BinarySensor *right_button)
void set_enter_button(binary_sensor::BinarySensor *enter_button)
virtual void set_obj(lv_obj_t *lv_obj)
lv_img_dsc_t * lv_img_from(image::Image *src, lv_img_dsc_t *img_dsc)
Base class for all automation conditions.
void set_page_wrap(bool wrap)
std::function< void(Ts...)> lamb_
LvglAction(std::function< void(LvglComponent *)> &&lamb)
bool lv_is_pre_initialise()
const float PROCESSOR
For components that use data from sensors like displays.
TemplatableValue< uint32_t > timeout_
std::function< void(lv_obj_t *)> LvLambdaType
void event(int key, bool pressed)
void add_init_lambda(const std::function< void(LvglComponent *)> &lamb)
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.
lv_indev_drv_t * get_drv()
void set_count(int32_t count)
void set_buffer_frac(size_t frac)
void lv_animimg_stop(lv_obj_t *obj)
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