From 6b141102d62930778552db1f2bdf23bdc20b1d86 Mon Sep 17 00:00:00 2001 From: Clyde Stubbs <2366188+clydebarrow@users.noreply.github.com> Date: Tue, 6 Aug 2024 11:17:29 +1000 Subject: [PATCH] [lvgl] Stage 5 (#7191) Co-authored-by: Jesse Hills <3060199+jesserockz@users.noreply.github.com> --- esphome/components/lvgl/__init__.py | 25 +- esphome/components/lvgl/animimg.py | 2 +- esphome/components/lvgl/automation.py | 2 +- esphome/components/lvgl/{btn.py => button.py} | 8 +- esphome/components/lvgl/buttonmatrix.py | 277 ++++++++++++++++ esphome/components/lvgl/checkbox.py | 2 +- esphome/components/lvgl/defines.py | 2 +- esphome/components/lvgl/dropdown.py | 76 +++++ esphome/components/lvgl/img.py | 8 +- esphome/components/lvgl/keyboard.py | 49 +++ esphome/components/lvgl/led.py | 4 +- esphome/components/lvgl/lvgl_esphome.cpp | 4 +- esphome/components/lvgl/lvgl_esphome.h | 2 +- esphome/components/lvgl/meter.py | 302 ++++++++++++++++++ esphome/components/lvgl/msgbox.py | 127 ++++++++ esphome/components/lvgl/roller.py | 77 +++++ esphome/components/lvgl/spinbox.py | 178 +++++++++++ esphome/components/lvgl/styles.py | 2 +- esphome/components/lvgl/tabview.py | 114 +++++++ esphome/components/lvgl/textarea.py | 67 ++++ esphome/components/lvgl/tileview.py | 128 ++++++++ esphome/components/lvgl/widget.py | 8 +- esphome/core/defines.h | 3 + tests/components/lvgl/.gitattributes | 2 + tests/components/lvgl/common.yaml | 46 +++ tests/components/lvgl/helvetica.ttf | Bin 0 -> 83644 bytes tests/components/lvgl/lvgl-package.yaml | 228 ++++++++++++- .../lvgl/materialdesignicons-webfont.ttf | Bin 0 -> 1307419 bytes tests/components/lvgl/roboto.ttf | Bin 0 -> 171676 bytes 29 files changed, 1716 insertions(+), 27 deletions(-) rename esphome/components/lvgl/{btn.py => button.py} (58%) create mode 100644 esphome/components/lvgl/buttonmatrix.py create mode 100644 esphome/components/lvgl/dropdown.py create mode 100644 esphome/components/lvgl/keyboard.py create mode 100644 esphome/components/lvgl/meter.py create mode 100644 esphome/components/lvgl/msgbox.py create mode 100644 esphome/components/lvgl/roller.py create mode 100644 esphome/components/lvgl/spinbox.py create mode 100644 esphome/components/lvgl/tabview.py create mode 100644 esphome/components/lvgl/textarea.py create mode 100644 esphome/components/lvgl/tileview.py create mode 100644 tests/components/lvgl/.gitattributes create mode 100644 tests/components/lvgl/helvetica.ttf create mode 100644 tests/components/lvgl/materialdesignicons-webfont.ttf create mode 100644 tests/components/lvgl/roboto.ttf diff --git a/esphome/components/lvgl/__init__.py b/esphome/components/lvgl/__init__.py index c154689199..a963fca98b 100644 --- a/esphome/components/lvgl/__init__.py +++ b/esphome/components/lvgl/__init__.py @@ -24,10 +24,13 @@ from . import defines as df, helpers, lv_validation as lvalid from .animimg import animimg_spec from .arc import arc_spec from .automation import disp_update, update_to_code -from .btn import btn_spec +from .button import button_spec +from .buttonmatrix import buttonmatrix_spec from .checkbox import checkbox_spec from .defines import CONF_SKIP +from .dropdown import dropdown_spec from .img import img_spec +from .keyboard import keyboard_spec from .label import label_spec from .led import led_spec from .line import line_spec @@ -35,8 +38,11 @@ from .lv_bar import bar_spec from .lv_switch import switch_spec from .lv_validation import lv_bool, lv_images_used from .lvcode import LvContext, LvglComponent +from .meter import meter_spec +from .msgbox import MSGBOX_SCHEMA, msgboxes_to_code from .obj import obj_spec from .page import add_pages, page_spec +from .roller import roller_spec from .rotary_encoders import ROTARY_ENCODER_CONFIG, rotary_encoders_to_code from .schemas import ( DISP_BG_SCHEMA, @@ -52,8 +58,12 @@ from .schemas import ( obj_schema, ) from .slider import slider_spec +from .spinbox import spinbox_spec from .spinner import spinner_spec from .styles import add_top_layer, styles_to_code, theme_to_code +from .tabview import tabview_spec +from .textarea import textarea_spec +from .tileview import tileview_spec from .touchscreens import touchscreen_schema, touchscreens_to_code from .trigger import generate_triggers from .types import ( @@ -75,7 +85,7 @@ LOGGER = logging.getLogger(__name__) for w_type in ( label_spec, obj_spec, - btn_spec, + button_spec, bar_spec, slider_spec, arc_spec, @@ -86,6 +96,15 @@ for w_type in ( checkbox_spec, img_spec, switch_spec, + tabview_spec, + buttonmatrix_spec, + meter_spec, + dropdown_spec, + roller_spec, + textarea_spec, + spinbox_spec, + keyboard_spec, + tileview_spec, ): WIDGET_TYPES[w_type.name] = w_type @@ -244,6 +263,7 @@ async def to_code(config): await add_widgets(lv_scr_act, config) await add_pages(lv_component, config) await add_top_layer(config) + await msgboxes_to_code(config) await disp_update(f"{lv_component}->get_disp()", config) Widget.set_completed() await generate_triggers(lv_component) @@ -308,6 +328,7 @@ CONFIG_SCHEMA = ( cv.Exclusive(CONF_PAGES, CONF_PAGES): cv.ensure_list( container_schema(page_spec) ), + cv.Optional(df.CONF_MSGBOXES): cv.ensure_list(MSGBOX_SCHEMA), cv.Optional(df.CONF_PAGE_WRAP, default=True): lv_bool, cv.Optional(df.CONF_TOP_LAYER): container_schema(obj_spec), cv.Optional(df.CONF_TRANSPARENCY_KEY, default=0x000400): lvalid.lv_color, diff --git a/esphome/components/lvgl/animimg.py b/esphome/components/lvgl/animimg.py index 20b85b019c..ad84713d7f 100644 --- a/esphome/components/lvgl/animimg.py +++ b/esphome/components/lvgl/animimg.py @@ -2,8 +2,8 @@ from esphome import automation import esphome.codegen as cg import esphome.config_validation as cv from esphome.const import CONF_DURATION, CONF_ID +from esphome.cpp_generator import MockObj -from ...cpp_generator import MockObj from .automation import action_to_code from .defines import CONF_AUTO_START, CONF_MAIN, CONF_REPEAT_COUNT, CONF_SRC from .helpers import lvgl_components_required diff --git a/esphome/components/lvgl/automation.py b/esphome/components/lvgl/automation.py index ffa25783ad..7a862fb58b 100644 --- a/esphome/components/lvgl/automation.py +++ b/esphome/components/lvgl/automation.py @@ -109,7 +109,7 @@ async def disp_update(disp, config: dict): if CONF_DISP_BG_COLOR not in config and CONF_DISP_BG_IMAGE not in config: return with LocalVariable("lv_disp_tmp", lv_disp_t, literal(disp)) as disp_temp: - if bg_color := config.get(CONF_DISP_BG_COLOR): + if (bg_color := config.get(CONF_DISP_BG_COLOR)) is not None: lv.disp_set_bg_color(disp_temp, await lv_color.process(bg_color)) if bg_image := config.get(CONF_DISP_BG_IMAGE): lv.disp_set_bg_image(disp_temp, await lv_image.process(bg_image)) diff --git a/esphome/components/lvgl/btn.py b/esphome/components/lvgl/button.py similarity index 58% rename from esphome/components/lvgl/btn.py rename to esphome/components/lvgl/button.py index 2a2a53e1e2..96329b3fa9 100644 --- a/esphome/components/lvgl/btn.py +++ b/esphome/components/lvgl/button.py @@ -3,12 +3,12 @@ from esphome.const import CONF_BUTTON from .defines import CONF_MAIN from .types import LvBoolean, WidgetType -lv_btn_t = LvBoolean("lv_btn_t") +lv_button_t = LvBoolean("lv_btn_t") -class BtnType(WidgetType): +class ButtonType(WidgetType): def __init__(self): - super().__init__(CONF_BUTTON, lv_btn_t, (CONF_MAIN,), lv_name="btn") + super().__init__(CONF_BUTTON, lv_button_t, (CONF_MAIN,), lv_name="btn") def get_uses(self): return ("btn",) @@ -17,4 +17,4 @@ class BtnType(WidgetType): return [] -btn_spec = BtnType() +button_spec = ButtonType() diff --git a/esphome/components/lvgl/buttonmatrix.py b/esphome/components/lvgl/buttonmatrix.py new file mode 100644 index 0000000000..75ed43f909 --- /dev/null +++ b/esphome/components/lvgl/buttonmatrix.py @@ -0,0 +1,277 @@ +from esphome import automation +import esphome.codegen as cg +from esphome.components.key_provider import KeyProvider +import esphome.config_validation as cv +from esphome.const import CONF_ID, CONF_WIDTH +from esphome.cpp_generator import MockObj + +from .automation import action_to_code +from .button import lv_button_t +from .defines import ( + BUTTONMATRIX_CTRLS, + CONF_BUTTONS, + CONF_CONTROL, + CONF_ITEMS, + CONF_KEY_CODE, + CONF_MAIN, + CONF_ONE_CHECKED, + CONF_ROWS, + CONF_SELECTED, + CONF_TEXT, +) +from .helpers import lvgl_components_required +from .lv_validation import key_code, lv_bool +from .lvcode import lv, lv_add, lv_expr +from .schemas import automation_schema +from .types import ( + LV_BTNMATRIX_CTRL, + LV_STATE, + LvBoolean, + LvCompound, + LvType, + ObjUpdateAction, + char_ptr, + lv_pseudo_button_t, +) +from .widget import Widget, WidgetType, get_widgets, widget_map + +CONF_BUTTONMATRIX = "buttonmatrix" +CONF_BUTTON_TEXT_LIST_ID = "button_text_list_id" + +LvButtonMatrixButton = LvBoolean( + str(cg.uint16), + parents=(lv_pseudo_button_t,), +) +BUTTONMATRIX_BUTTON_SCHEMA = cv.Schema( + { + cv.Optional(CONF_TEXT): cv.string, + cv.Optional(CONF_KEY_CODE): key_code, + cv.GenerateID(): cv.declare_id(LvButtonMatrixButton), + cv.Optional(CONF_WIDTH, default=1): cv.positive_int, + cv.Optional(CONF_CONTROL): cv.ensure_list( + cv.Schema( + {cv.Optional(k.lower()): cv.boolean for k in BUTTONMATRIX_CTRLS.choices} + ) + ), + } +).extend(automation_schema(lv_button_t)) + +BUTTONMATRIX_SCHEMA = cv.Schema( + { + cv.Optional(CONF_ONE_CHECKED, default=False): lv_bool, + cv.GenerateID(CONF_BUTTON_TEXT_LIST_ID): cv.declare_id(char_ptr), + cv.Required(CONF_ROWS): cv.ensure_list( + cv.Schema( + { + cv.Required(CONF_BUTTONS): cv.ensure_list( + BUTTONMATRIX_BUTTON_SCHEMA + ), + } + ) + ), + } +) + + +class ButtonmatrixButtonType(WidgetType): + """ + A pseudo-widget for the matrix buttons + """ + + def __init__(self): + super().__init__("btnmatrix_btn", LvButtonMatrixButton, (), {}, {}) + + async def to_code(self, w, config: dict): + return [] + + +btn_btn_spec = ButtonmatrixButtonType() + + +class MatrixButton(Widget): + """ + Describes a button within a button matrix. + """ + + @staticmethod + def create_button(id, parent, config: dict, index): + w = MatrixButton(id, parent, config, index) + widget_map[id] = w + return w + + def __init__(self, id, parent: Widget, config, index): + super().__init__(id, btn_btn_spec, config) + self.parent = parent + self.index = index + self.obj = parent.obj + + def is_selected(self): + return self.parent.var.get_selected() == MockObj(self.var) + + @staticmethod + def map_ctrls(state): + state = str(state).upper().removeprefix("LV_STATE_") + assert state in BUTTONMATRIX_CTRLS.choices + return getattr(LV_BTNMATRIX_CTRL, state) + + def has_state(self, state): + state = self.map_ctrls(state) + return lv_expr.btnmatrix_has_btn_ctrl(self.obj, self.index, state) + + def add_state(self, state): + state = self.map_ctrls(state) + return lv.btnmatrix_set_btn_ctrl(self.obj, self.index, state) + + def clear_state(self, state): + state = self.map_ctrls(state) + return lv.btnmatrix_clear_btn_ctrl(self.obj, self.index, state) + + def is_pressed(self): + return self.is_selected() & self.parent.has_state(LV_STATE.PRESSED) + + def is_checked(self): + return self.has_state(LV_STATE.CHECKED) + + def get_value(self): + return self.is_checked() + + def check_null(self): + return None + + +async def get_button_data(config, buttonmatrix: Widget): + """ + Process a button matrix button list + :param config: The row list + :param buttonmatrix: The parent variable + :return: text array id, control list, width list + """ + text_list = [] + ctrl_list = [] + width_list = [] + key_list = [] + for row in config: + for button_conf in row.get(CONF_BUTTONS) or (): + bid = button_conf[CONF_ID] + index = len(width_list) + MatrixButton.create_button(bid, buttonmatrix, button_conf, index) + cg.new_variable(bid, index) + text_list.append(button_conf.get(CONF_TEXT) or "") + key_list.append(button_conf.get(CONF_KEY_CODE) or 0) + width_list.append(button_conf[CONF_WIDTH]) + ctrl = ["LV_BTNMATRIX_CTRL_CLICK_TRIG"] + for item in button_conf.get(CONF_CONTROL, ()): + ctrl.extend([k for k, v in item.items() if v]) + ctrl_list.append(await BUTTONMATRIX_CTRLS.process(ctrl)) + text_list.append("\n") + text_list = text_list[:-1] + text_list.append(cg.nullptr) + return text_list, ctrl_list, width_list, key_list + + +lv_buttonmatrix_t = LvType( + "LvButtonMatrixType", + parents=(KeyProvider, LvCompound), + largs=[(cg.uint16, "x")], + lvalue=lambda w: w.var.get_selected(), +) + + +class ButtonMatrixType(WidgetType): + def __init__(self): + super().__init__( + CONF_BUTTONMATRIX, + lv_buttonmatrix_t, + (CONF_MAIN, CONF_ITEMS), + BUTTONMATRIX_SCHEMA, + {}, + lv_name="btnmatrix", + ) + + async def to_code(self, w: Widget, config): + lvgl_components_required.add("BUTTONMATRIX") + if CONF_ROWS not in config: + return [] + text_list, ctrl_list, width_list, key_list = await get_button_data( + config[CONF_ROWS], w + ) + text_id = config[CONF_BUTTON_TEXT_LIST_ID] + text_id = cg.static_const_array(text_id, text_list) + lv.btnmatrix_set_map(w.obj, text_id) + set_btn_data(w.obj, ctrl_list, width_list) + lv.btnmatrix_set_one_checked(w.obj, config[CONF_ONE_CHECKED]) + for index, key in enumerate(key_list): + if key != 0: + lv_add(w.var.set_key(index, key)) + + def get_uses(self): + return ("btnmatrix",) + + +def set_btn_data(obj, ctrl_list, width_list): + for index, ctrl in enumerate(ctrl_list): + lv.btnmatrix_set_btn_ctrl(obj, index, ctrl) + for index, width in enumerate(width_list): + lv.btnmatrix_set_btn_width(obj, index, width) + + +buttonmatrix_spec = ButtonMatrixType() + + +@automation.register_action( + "lvgl.matrix.button.update", + ObjUpdateAction, + cv.Schema( + { + cv.Optional(CONF_WIDTH): cv.positive_int, + cv.Optional(CONF_CONTROL): cv.ensure_list( + cv.Schema( + { + cv.Optional(k.lower()): cv.boolean + for k in BUTTONMATRIX_CTRLS.choices + } + ), + ), + cv.Required(CONF_ID): cv.ensure_list( + cv.maybe_simple_value( + { + cv.Required(CONF_ID): cv.use_id(LvButtonMatrixButton), + }, + key=CONF_ID, + ) + ), + cv.Optional(CONF_SELECTED): lv_bool, + } + ), +) +async def button_update_to_code(config, action_id, template_arg, args): + widgets = await get_widgets(config[CONF_ID]) + assert all(isinstance(w, MatrixButton) for w in widgets) + + async def do_button_update(w: MatrixButton): + if (width := config.get(CONF_WIDTH)) is not None: + lv.btnmatrix_set_btn_width(w.obj, w.index, width) + if config.get(CONF_SELECTED): + lv.btnmatrix_set_selected_btn(w.obj, w.index) + if controls := config.get(CONF_CONTROL): + adds = [] + clrs = [] + for item in controls: + adds.extend( + [f"LV_BTNMATRIX_CTRL_{k.upper()}" for k, v in item.items() if v] + ) + clrs.extend( + [f"LV_BTNMATRIX_CTRL_{k.upper()}" for k, v in item.items() if not v] + ) + if adds: + lv.btnmatrix_set_btn_ctrl( + w.obj, w.index, await BUTTONMATRIX_CTRLS.process(adds) + ) + if clrs: + lv.btnmatrix_clear_btn_ctrl( + w.obj, w.index, await BUTTONMATRIX_CTRLS.process(clrs) + ) + + return await action_to_code( + widgets, do_button_update, action_id, template_arg, args + ) diff --git a/esphome/components/lvgl/checkbox.py b/esphome/components/lvgl/checkbox.py index 7418d633cf..be7b029269 100644 --- a/esphome/components/lvgl/checkbox.py +++ b/esphome/components/lvgl/checkbox.py @@ -18,7 +18,7 @@ class CheckboxType(WidgetType): ) async def to_code(self, w: Widget, config): - if value := config.get(CONF_TEXT): + if (value := config.get(CONF_TEXT)) is not None: lv.checkbox_set_text(w.obj, await lv_text.process(value)) diff --git a/esphome/components/lvgl/defines.py b/esphome/components/lvgl/defines.py index 16ec45ae8a..ac28f9ed5f 100644 --- a/esphome/components/lvgl/defines.py +++ b/esphome/components/lvgl/defines.py @@ -304,7 +304,7 @@ OBJ_FLAGS = ( ARC_MODES = LvConstant("LV_ARC_MODE_", "NORMAL", "REVERSE", "SYMMETRICAL") BAR_MODES = LvConstant("LV_BAR_MODE_", "NORMAL", "SYMMETRICAL", "RANGE") -BTNMATRIX_CTRLS = LvConstant( +BUTTONMATRIX_CTRLS = LvConstant( "LV_BTNMATRIX_CTRL_", "HIDDEN", "NO_REPEAT", diff --git a/esphome/components/lvgl/dropdown.py b/esphome/components/lvgl/dropdown.py new file mode 100644 index 0000000000..d7bdebaade --- /dev/null +++ b/esphome/components/lvgl/dropdown.py @@ -0,0 +1,76 @@ +import esphome.codegen as cg +import esphome.config_validation as cv +from esphome.const import CONF_OPTIONS + +from .defines import ( + CONF_DIR, + CONF_INDICATOR, + CONF_MAIN, + CONF_SELECTED_INDEX, + CONF_SYMBOL, + DIRECTIONS, + literal, +) +from .label import CONF_LABEL +from .lv_validation import lv_int, lv_text, option_string +from .lvcode import LocalVariable, lv, lv_expr +from .schemas import part_schema +from .types import LvSelect, LvType, lv_obj_t +from .widget import Widget, WidgetType, set_obj_properties + +CONF_DROPDOWN = "dropdown" +CONF_DROPDOWN_LIST = "dropdown_list" + +lv_dropdown_t = LvSelect("lv_dropdown_t") +lv_dropdown_list_t = LvType("lv_dropdown_list_t") +dropdown_list_spec = WidgetType(CONF_DROPDOWN_LIST, lv_dropdown_list_t, (CONF_MAIN,)) + +DROPDOWN_BASE_SCHEMA = cv.Schema( + { + cv.Optional(CONF_SYMBOL): lv_text, + cv.Optional(CONF_SELECTED_INDEX): cv.templatable(cv.int_), + cv.Optional(CONF_DIR, default="BOTTOM"): DIRECTIONS.one_of, + cv.Optional(CONF_DROPDOWN_LIST): part_schema(dropdown_list_spec), + } +) + +DROPDOWN_SCHEMA = DROPDOWN_BASE_SCHEMA.extend( + { + cv.Required(CONF_OPTIONS): cv.ensure_list(option_string), + } +) + + +class DropdownType(WidgetType): + def __init__(self): + super().__init__( + CONF_DROPDOWN, + lv_dropdown_t, + (CONF_MAIN, CONF_INDICATOR), + DROPDOWN_SCHEMA, + DROPDOWN_BASE_SCHEMA, + ) + + async def to_code(self, w: Widget, config): + if options := config.get(CONF_OPTIONS): + text = cg.safe_exp("\n".join(options)) + lv.dropdown_set_options(w.obj, text) + if symbol := config.get(CONF_SYMBOL): + lv.dropdown_set_symbol(w.obj, await lv_text.process(symbol)) + if (selected := config.get(CONF_SELECTED_INDEX)) is not None: + value = await lv_int.process(selected) + lv.dropdown_set_selected(w.obj, value) + if dirn := config.get(CONF_DIR): + lv.dropdown_set_dir(w.obj, literal(dirn)) + if dlist := config.get(CONF_DROPDOWN_LIST): + with LocalVariable( + "dropdown_list", lv_obj_t, lv_expr.dropdown_get_list(w.obj) + ) as dlist_obj: + dwid = Widget(dlist_obj, dropdown_list_spec, dlist) + await set_obj_properties(dwid, dlist) + + def get_uses(self): + return (CONF_LABEL,) + + +dropdown_spec = DropdownType() diff --git a/esphome/components/lvgl/img.py b/esphome/components/lvgl/img.py index e9682def8c..dd962fcf31 100644 --- a/esphome/components/lvgl/img.py +++ b/esphome/components/lvgl/img.py @@ -65,16 +65,16 @@ class ImgType(WidgetType): async def to_code(self, w: Widget, config): if src := config.get(CONF_SRC): lv.img_set_src(w.obj, await lv_image.process(src)) - if cf_angle := config.get(CONF_ANGLE): + if (cf_angle := config.get(CONF_ANGLE)) is not None: pivot_x = config[CONF_PIVOT_X] pivot_y = config[CONF_PIVOT_Y] lv.img_set_pivot(w.obj, pivot_x, pivot_y) lv.img_set_angle(w.obj, cf_angle) - if img_zoom := config.get(CONF_ZOOM): + if (img_zoom := config.get(CONF_ZOOM)) is not None: lv.img_set_zoom(w.obj, img_zoom) - if offset := config.get(CONF_OFFSET_X): + if (offset := config.get(CONF_OFFSET_X)) is not None: lv.img_set_offset_x(w.obj, offset) - if offset := config.get(CONF_OFFSET_Y): + if (offset := config.get(CONF_OFFSET_Y)) is not None: lv.img_set_offset_y(w.obj, offset) if CONF_ANTIALIAS in config: lv.img_set_antialias(w.obj, config[CONF_ANTIALIAS]) diff --git a/esphome/components/lvgl/keyboard.py b/esphome/components/lvgl/keyboard.py new file mode 100644 index 0000000000..7ce73d2170 --- /dev/null +++ b/esphome/components/lvgl/keyboard.py @@ -0,0 +1,49 @@ +from esphome.components.key_provider import KeyProvider +import esphome.config_validation as cv +from esphome.const import CONF_MODE +from esphome.cpp_types import std_string + +from .defines import CONF_ITEMS, CONF_MAIN, KEYBOARD_MODES, literal +from .helpers import add_lv_use, lvgl_components_required +from .textarea import CONF_TEXTAREA, lv_textarea_t +from .types import LvCompound, LvType +from .widget import Widget, WidgetType, get_widgets + +CONF_KEYBOARD = "keyboard" + +KEYBOARD_SCHEMA = { + cv.Optional(CONF_MODE, default="TEXT_UPPER"): KEYBOARD_MODES.one_of, + cv.Optional(CONF_TEXTAREA): cv.use_id(lv_textarea_t), +} + +lv_keyboard_t = LvType( + "LvKeyboardType", + parents=(KeyProvider, LvCompound), + largs=[(std_string, "text")], + has_on_value=True, + lvalue=lambda w: literal(f"lv_textarea_get_text({w.obj})"), +) + + +class KeyboardType(WidgetType): + def __init__(self): + super().__init__( + CONF_KEYBOARD, + lv_keyboard_t, + (CONF_MAIN, CONF_ITEMS), + KEYBOARD_SCHEMA, + ) + + def get_uses(self): + return CONF_KEYBOARD, CONF_TEXTAREA + + async def to_code(self, w: Widget, config: dict): + lvgl_components_required.add("KEY_LISTENER") + lvgl_components_required.add(CONF_KEYBOARD) + add_lv_use("btnmatrix") + await w.set_property(CONF_MODE, await KEYBOARD_MODES.process(config[CONF_MODE])) + if ta := await get_widgets(config, CONF_TEXTAREA): + await w.set_property(CONF_TEXTAREA, ta[0].obj) + + +keyboard_spec = KeyboardType() diff --git a/esphome/components/lvgl/led.py b/esphome/components/lvgl/led.py index f920758efb..9b6e819278 100644 --- a/esphome/components/lvgl/led.py +++ b/esphome/components/lvgl/led.py @@ -20,9 +20,9 @@ class LedType(WidgetType): super().__init__(CONF_LED, LvType("lv_led_t"), (CONF_MAIN,), LED_SCHEMA) async def to_code(self, w: Widget, config): - if color := config.get(CONF_COLOR): + if (color := config.get(CONF_COLOR)) is not None: lv.led_set_color(w.obj, await lv_color.process(color)) - if brightness := config.get(CONF_BRIGHTNESS): + if (brightness := config.get(CONF_BRIGHTNESS)) is not None: lv.led_set_brightness(w.obj, await lv_brightness.process(brightness)) diff --git a/esphome/components/lvgl/lvgl_esphome.cpp b/esphome/components/lvgl/lvgl_esphome.cpp index 1221682d28..544643d532 100644 --- a/esphome/components/lvgl/lvgl_esphome.cpp +++ b/esphome/components/lvgl/lvgl_esphome.cpp @@ -146,12 +146,12 @@ LVEncoderListener::LVEncoderListener(lv_indev_type_t type, uint16_t lpt, uint16_ #endif // USE_LVGL_ROTARY_ENCODER #ifdef USE_LVGL_BUTTONMATRIX -void LvBtnmatrixType::set_obj(lv_obj_t *lv_obj) { +void LvButtonMatrixType::set_obj(lv_obj_t *lv_obj) { LvCompound::set_obj(lv_obj); lv_obj_add_event_cb( lv_obj, [](lv_event_t *event) { - auto *self = static_cast(event->user_data); + auto *self = static_cast(event->user_data); if (self->key_callback_.size() == 0) return; auto key_idx = lv_btnmatrix_get_selected_btn(self->obj); diff --git a/esphome/components/lvgl/lvgl_esphome.h b/esphome/components/lvgl/lvgl_esphome.h index b92799addd..71e0fd069f 100644 --- a/esphome/components/lvgl/lvgl_esphome.h +++ b/esphome/components/lvgl/lvgl_esphome.h @@ -246,7 +246,7 @@ class LVEncoderListener : public Parented { }; #endif // USE_LVGL_ROTARY_ENCODER #ifdef USE_LVGL_BUTTONMATRIX -class LvBtnmatrixType : public key_provider::KeyProvider, public LvCompound { +class LvButtonMatrixType : public key_provider::KeyProvider, public LvCompound { public: void set_obj(lv_obj_t *lv_obj) override; uint16_t get_selected() { return lv_btnmatrix_get_selected_btn(this->obj); } diff --git a/esphome/components/lvgl/meter.py b/esphome/components/lvgl/meter.py new file mode 100644 index 0000000000..1a6bef7c57 --- /dev/null +++ b/esphome/components/lvgl/meter.py @@ -0,0 +1,302 @@ +from esphome import automation +import esphome.codegen as cg +import esphome.config_validation as cv +from esphome.const import ( + CONF_COLOR, + CONF_COUNT, + CONF_ID, + CONF_LENGTH, + CONF_LOCAL, + CONF_RANGE_FROM, + CONF_RANGE_TO, + CONF_ROTATION, + CONF_VALUE, + CONF_WIDTH, +) + +from .arc import CONF_ARC +from .automation import action_to_code +from .defines import ( + CONF_END_VALUE, + CONF_MAIN, + CONF_PIVOT_X, + CONF_PIVOT_Y, + CONF_SRC, + CONF_START_VALUE, + CONF_TICKS, +) +from .helpers import add_lv_use +from .img import CONF_IMAGE +from .line import CONF_LINE +from .lv_validation import ( + angle, + get_end_value, + get_start_value, + lv_bool, + lv_color, + lv_float, + lv_image, + requires_component, + size, +) +from .lvcode import LocalVariable, lv, lv_assign, lv_expr +from .obj import obj_spec +from .types import LvType, ObjUpdateAction +from .widget import Widget, WidgetType, get_widgets + +CONF_ANGLE_RANGE = "angle_range" +CONF_COLOR_END = "color_end" +CONF_COLOR_START = "color_start" +CONF_INDICATORS = "indicators" +CONF_LABEL_GAP = "label_gap" +CONF_MAJOR = "major" +CONF_METER = "meter" +CONF_R_MOD = "r_mod" +CONF_SCALES = "scales" +CONF_STRIDE = "stride" +CONF_TICK_STYLE = "tick_style" + +lv_meter_t = LvType("lv_meter_t") +lv_meter_indicator_t = cg.global_ns.struct("lv_meter_indicator_t") +lv_meter_indicator_t_ptr = lv_meter_indicator_t.operator("ptr") + + +def pixels(value): + """A size in one axis in pixels""" + if isinstance(value, str) and value.lower().endswith("px"): + return cv.int_(value[:-2]) + return cv.int_(value) + + +INDICATOR_LINE_SCHEMA = cv.Schema( + { + cv.Optional(CONF_WIDTH, default=4): size, + cv.Optional(CONF_COLOR, default=0): lv_color, + cv.Optional(CONF_R_MOD, default=0): size, + cv.Optional(CONF_VALUE): lv_float, + } +) +INDICATOR_IMG_SCHEMA = cv.Schema( + { + cv.Required(CONF_SRC): lv_image, + cv.Required(CONF_PIVOT_X): pixels, + cv.Required(CONF_PIVOT_Y): pixels, + cv.Optional(CONF_VALUE): lv_float, + } +) +INDICATOR_ARC_SCHEMA = cv.Schema( + { + cv.Optional(CONF_WIDTH, default=4): size, + cv.Optional(CONF_COLOR, default=0): lv_color, + cv.Optional(CONF_R_MOD, default=0): size, + cv.Exclusive(CONF_VALUE, CONF_VALUE): lv_float, + cv.Exclusive(CONF_START_VALUE, CONF_VALUE): lv_float, + cv.Optional(CONF_END_VALUE): lv_float, + } +) +INDICATOR_TICKS_SCHEMA = cv.Schema( + { + cv.Optional(CONF_WIDTH, default=4): size, + cv.Optional(CONF_COLOR_START, default=0): lv_color, + cv.Optional(CONF_COLOR_END): lv_color, + cv.Exclusive(CONF_VALUE, CONF_VALUE): lv_float, + cv.Exclusive(CONF_START_VALUE, CONF_VALUE): lv_float, + cv.Optional(CONF_END_VALUE): lv_float, + cv.Optional(CONF_LOCAL, default=False): lv_bool, + } +) +INDICATOR_SCHEMA = cv.Schema( + { + cv.Exclusive(CONF_LINE, CONF_INDICATORS): INDICATOR_LINE_SCHEMA.extend( + { + cv.GenerateID(): cv.declare_id(lv_meter_indicator_t), + } + ), + cv.Exclusive(CONF_IMAGE, CONF_INDICATORS): cv.All( + INDICATOR_IMG_SCHEMA.extend( + { + cv.GenerateID(): cv.declare_id(lv_meter_indicator_t), + } + ), + requires_component("image"), + ), + cv.Exclusive(CONF_ARC, CONF_INDICATORS): INDICATOR_ARC_SCHEMA.extend( + { + cv.GenerateID(): cv.declare_id(lv_meter_indicator_t), + } + ), + cv.Exclusive(CONF_TICK_STYLE, CONF_INDICATORS): INDICATOR_TICKS_SCHEMA.extend( + { + cv.GenerateID(): cv.declare_id(lv_meter_indicator_t), + } + ), + } +) + +SCALE_SCHEMA = cv.Schema( + { + cv.Optional(CONF_TICKS): cv.Schema( + { + cv.Optional(CONF_COUNT, default=12): cv.positive_int, + cv.Optional(CONF_WIDTH, default=2): size, + cv.Optional(CONF_LENGTH, default=10): size, + cv.Optional(CONF_COLOR, default=0x808080): lv_color, + cv.Optional(CONF_MAJOR): cv.Schema( + { + cv.Optional(CONF_STRIDE, default=3): cv.positive_int, + cv.Optional(CONF_WIDTH, default=5): size, + cv.Optional(CONF_LENGTH, default="15%"): size, + cv.Optional(CONF_COLOR, default=0): lv_color, + cv.Optional(CONF_LABEL_GAP, default=4): size, + } + ), + } + ), + cv.Optional(CONF_RANGE_FROM, default=0.0): cv.float_, + cv.Optional(CONF_RANGE_TO, default=100.0): cv.float_, + cv.Optional(CONF_ANGLE_RANGE, default=270): cv.int_range(0, 360), + cv.Optional(CONF_ROTATION): angle, + cv.Optional(CONF_INDICATORS): cv.ensure_list(INDICATOR_SCHEMA), + } +) + +METER_SCHEMA = {cv.Optional(CONF_SCALES): cv.ensure_list(SCALE_SCHEMA)} + + +class MeterType(WidgetType): + def __init__(self): + super().__init__(CONF_METER, lv_meter_t, (CONF_MAIN,), METER_SCHEMA) + + async def to_code(self, w: Widget, config): + """For a meter object, create and set parameters""" + + var = w.obj + for scale_conf in config.get(CONF_SCALES) or (): + rotation = 90 + (360 - scale_conf[CONF_ANGLE_RANGE]) / 2 + if CONF_ROTATION in scale_conf: + rotation = scale_conf[CONF_ROTATION] // 10 + with LocalVariable( + "meter_var", "lv_meter_scale_t", lv_expr.meter_add_scale(var) + ) as meter_var: + lv.meter_set_scale_range( + var, + meter_var, + scale_conf[CONF_RANGE_FROM], + scale_conf[CONF_RANGE_TO], + scale_conf[CONF_ANGLE_RANGE], + rotation, + ) + if ticks := scale_conf.get(CONF_TICKS): + color = await lv_color.process(ticks[CONF_COLOR]) + lv.meter_set_scale_ticks( + var, + meter_var, + ticks[CONF_COUNT], + ticks[CONF_WIDTH], + ticks[CONF_LENGTH], + color, + ) + if CONF_MAJOR in ticks: + major = ticks[CONF_MAJOR] + color = await lv_color.process(major[CONF_COLOR]) + lv.meter_set_scale_major_ticks( + var, + meter_var, + major[CONF_STRIDE], + major[CONF_WIDTH], + major[CONF_LENGTH], + color, + major[CONF_LABEL_GAP], + ) + for indicator in scale_conf.get(CONF_INDICATORS) or (): + (t, v) = next(iter(indicator.items())) + iid = v[CONF_ID] + ivar = cg.new_variable( + iid, cg.nullptr, type_=lv_meter_indicator_t_ptr + ) + # Enable getting the meter to which this belongs. + wid = Widget.create(iid, var, obj_spec, v) + wid.obj = ivar + if t == CONF_LINE: + color = await lv_color.process(v[CONF_COLOR]) + lv_assign( + ivar, + lv_expr.meter_add_needle_line( + var, meter_var, v[CONF_WIDTH], color, v[CONF_R_MOD] + ), + ) + if t == CONF_ARC: + color = await lv_color.process(v[CONF_COLOR]) + lv_assign( + ivar, + lv_expr.meter_add_arc( + var, meter_var, v[CONF_WIDTH], color, v[CONF_R_MOD] + ), + ) + if t == CONF_TICK_STYLE: + color_start = await lv_color.process(v[CONF_COLOR_START]) + color_end = await lv_color.process( + v.get(CONF_COLOR_END) or color_start + ) + lv_assign( + ivar, + lv_expr.meter_add_scale_lines( + var, + meter_var, + color_start, + color_end, + v[CONF_LOCAL], + v[CONF_WIDTH], + ), + ) + if t == CONF_IMAGE: + add_lv_use("img") + lv_assign( + ivar, + lv_expr.meter_add_needle_img( + var, + meter_var, + await lv_image.process(v[CONF_SRC]), + v[CONF_PIVOT_X], + v[CONF_PIVOT_Y], + ), + ) + start_value = await get_start_value(v) + end_value = await get_end_value(v) + set_indicator_values(var, ivar, start_value, end_value) + + +meter_spec = MeterType() + + +@automation.register_action( + "lvgl.indicator.update", + ObjUpdateAction, + cv.Schema( + { + cv.Required(CONF_ID): cv.use_id(lv_meter_indicator_t), + cv.Exclusive(CONF_VALUE, CONF_VALUE): lv_float, + cv.Exclusive(CONF_START_VALUE, CONF_VALUE): lv_float, + cv.Optional(CONF_END_VALUE): lv_float, + } + ), +) +async def indicator_update_to_code(config, action_id, template_arg, args): + widget = await get_widgets(config) + start_value = await get_start_value(config) + end_value = await get_end_value(config) + + async def set_value(w: Widget): + set_indicator_values(w.var, w.obj, start_value, end_value) + + return await action_to_code(widget, set_value, action_id, template_arg, args) + + +def set_indicator_values(meter, indicator, start_value, end_value): + if start_value is not None: + if end_value is None: + lv.meter_set_indicator_value(meter, indicator, start_value) + else: + lv.meter_set_indicator_start_value(meter, indicator, start_value) + if end_value is not None: + lv.meter_set_indicator_end_value(meter, indicator, end_value) diff --git a/esphome/components/lvgl/msgbox.py b/esphome/components/lvgl/msgbox.py new file mode 100644 index 0000000000..6dd529d77f --- /dev/null +++ b/esphome/components/lvgl/msgbox.py @@ -0,0 +1,127 @@ +from esphome import config_validation as cv +from esphome.const import CONF_BUTTON, CONF_ID +from esphome.core import ID +from esphome.cpp_generator import new_Pvariable, static_const_array +from esphome.cpp_types import nullptr + +from .button import button_spec +from .buttonmatrix import ( + BUTTONMATRIX_BUTTON_SCHEMA, + CONF_BUTTON_TEXT_LIST_ID, + buttonmatrix_spec, + get_button_data, + lv_buttonmatrix_t, + set_btn_data, +) +from .defines import ( + CONF_BODY, + CONF_BUTTONS, + CONF_CLOSE_BUTTON, + CONF_MSGBOXES, + CONF_TEXT, + CONF_TITLE, + TYPE_FLEX, + literal, +) +from .helpers import add_lv_use +from .label import CONF_LABEL +from .lv_validation import lv_bool, lv_pct, lv_text +from .lvcode import ( + EVENT_ARG, + LambdaContext, + LocalVariable, + lv_add, + lv_assign, + lv_expr, + lv_obj, + lv_Pvariable, +) +from .obj import obj_spec +from .schemas import STYLE_SCHEMA, STYLED_TEXT_SCHEMA, container_schema +from .styles import TOP_LAYER +from .types import LV_EVENT, char_ptr, lv_obj_t +from .widget import Widget, set_obj_properties + +CONF_MSGBOX = "msgbox" +MSGBOX_SCHEMA = container_schema( + obj_spec, + STYLE_SCHEMA.extend( + { + cv.GenerateID(CONF_ID): cv.declare_id(lv_obj_t), + cv.Required(CONF_TITLE): STYLED_TEXT_SCHEMA, + cv.Optional(CONF_BODY): STYLED_TEXT_SCHEMA, + cv.Optional(CONF_BUTTONS): cv.ensure_list(BUTTONMATRIX_BUTTON_SCHEMA), + cv.Optional(CONF_CLOSE_BUTTON): lv_bool, + cv.GenerateID(CONF_BUTTON_TEXT_LIST_ID): cv.declare_id(char_ptr), + } + ), +) + + +async def msgbox_to_code(conf): + """ + Construct a message box. This consists of a full-screen translucent background enclosing a centered container + with an optional title, body, close button and a button matrix. And any other widgets the user cares to add + :param conf: The config data + :return: code to add to the init lambda + """ + add_lv_use( + TYPE_FLEX, + CONF_BUTTON, + CONF_LABEL, + CONF_MSGBOX, + *buttonmatrix_spec.get_uses(), + *button_spec.get_uses(), + ) + mbid = conf[CONF_ID] + outer = lv_Pvariable(lv_obj_t, mbid.id) + btnm = new_Pvariable( + ID(f"{mbid.id}_btnm_", is_declaration=True, type=lv_buttonmatrix_t) + ) + msgbox = lv_Pvariable(lv_obj_t, f"{mbid.id}_msgbox") + outer_w = Widget.create(mbid, outer, obj_spec, conf) + btnm_widg = Widget.create(str(btnm), btnm, buttonmatrix_spec, conf) + text_list, ctrl_list, width_list, _ = await get_button_data((conf,), btnm_widg) + text_id = conf[CONF_BUTTON_TEXT_LIST_ID] + text_list = static_const_array(text_id, text_list) + if (text := conf.get(CONF_BODY)) is not None: + text = await lv_text.process(text.get(CONF_TEXT)) + if (title := conf.get(CONF_TITLE)) is not None: + title = await lv_text.process(title.get(CONF_TEXT)) + close_button = conf[CONF_CLOSE_BUTTON] + lv_assign(outer, lv_expr.obj_create(TOP_LAYER)) + lv_obj.set_width(outer, lv_pct(100)) + lv_obj.set_height(outer, lv_pct(100)) + lv_obj.set_style_bg_opa(outer, 128, 0) + lv_obj.set_style_bg_color(outer, literal("lv_color_black()"), 0) + lv_obj.set_style_border_width(outer, 0, 0) + lv_obj.set_style_pad_all(outer, 0, 0) + lv_obj.set_style_radius(outer, 0, 0) + outer_w.add_flag("LV_OBJ_FLAG_HIDDEN") + lv_assign( + msgbox, lv_expr.msgbox_create(outer, title, text, text_list, close_button) + ) + lv_obj.set_style_align(msgbox, literal("LV_ALIGN_CENTER"), 0) + lv_add(btnm.set_obj(lv_expr.msgbox_get_btns(msgbox))) + await set_obj_properties(outer_w, conf) + if close_button: + async with LambdaContext(EVENT_ARG, where=mbid) as context: + outer_w.add_flag("LV_OBJ_FLAG_HIDDEN") + with LocalVariable( + "close_btn_", lv_obj_t, lv_expr.msgbox_get_close_btn(msgbox) + ) as close_btn: + lv_obj.remove_event_cb(close_btn, nullptr) + lv_obj.add_event_cb( + close_btn, + await context.get_lambda(), + LV_EVENT.CLICKED, + nullptr, + ) + + if len(ctrl_list) != 0 or len(width_list) != 0: + set_btn_data(btnm.obj, ctrl_list, width_list) + + +async def msgboxes_to_code(config): + for conf in config.get(CONF_MSGBOXES, ()): + await msgbox_to_code(conf) diff --git a/esphome/components/lvgl/roller.py b/esphome/components/lvgl/roller.py new file mode 100644 index 0000000000..7af3ef3c3d --- /dev/null +++ b/esphome/components/lvgl/roller.py @@ -0,0 +1,77 @@ +import esphome.codegen as cg +import esphome.config_validation as cv +from esphome.const import CONF_MODE, CONF_OPTIONS + +from .defines import ( + CONF_ANIMATED, + CONF_MAIN, + CONF_SELECTED, + CONF_SELECTED_INDEX, + CONF_VISIBLE_ROW_COUNT, + ROLLER_MODES, + literal, +) +from .label import CONF_LABEL +from .lv_validation import animated, lv_int, option_string +from .lvcode import lv +from .types import LvSelect +from .widget import WidgetType + +CONF_ROLLER = "roller" +lv_roller_t = LvSelect("lv_roller_t") + +ROLLER_BASE_SCHEMA = cv.Schema( + { + cv.Optional(CONF_SELECTED_INDEX): cv.templatable(cv.int_), + cv.Optional(CONF_VISIBLE_ROW_COUNT): lv_int, + } +) + +ROLLER_SCHEMA = ROLLER_BASE_SCHEMA.extend( + { + cv.Required(CONF_OPTIONS): cv.ensure_list(option_string), + cv.Optional(CONF_MODE, default="NORMAL"): ROLLER_MODES.one_of, + } +) + +ROLLER_MODIFY_SCHEMA = ROLLER_BASE_SCHEMA.extend( + { + cv.Optional(CONF_ANIMATED, default=True): animated, + } +) + + +class RollerType(WidgetType): + def __init__(self): + super().__init__( + CONF_ROLLER, + lv_roller_t, + (CONF_MAIN, CONF_SELECTED), + ROLLER_SCHEMA, + ROLLER_MODIFY_SCHEMA, + ) + + async def to_code(self, w, config): + if options := config.get(CONF_OPTIONS): + mode = await ROLLER_MODES.process(config[CONF_MODE]) + text = cg.safe_exp("\n".join(options)) + lv.roller_set_options(w.obj, text, mode) + animopt = literal(config.get(CONF_ANIMATED) or "LV_ANIM_OFF") + if CONF_SELECTED_INDEX in config: + if selected := config[CONF_SELECTED_INDEX]: + value = await lv_int.process(selected) + lv.roller_set_selected(w.obj, value, animopt) + await w.set_property( + CONF_VISIBLE_ROW_COUNT, + await lv_int.process(config.get(CONF_VISIBLE_ROW_COUNT)), + ) + + @property + def animated(self): + return True + + def get_uses(self): + return (CONF_LABEL,) + + +roller_spec = RollerType() diff --git a/esphome/components/lvgl/spinbox.py b/esphome/components/lvgl/spinbox.py new file mode 100644 index 0000000000..62c58c54a3 --- /dev/null +++ b/esphome/components/lvgl/spinbox.py @@ -0,0 +1,178 @@ +from esphome import automation +import esphome.config_validation as cv +from esphome.const import CONF_ID, CONF_RANGE_FROM, CONF_RANGE_TO, CONF_STEP, CONF_VALUE + +from .automation import action_to_code, update_to_code +from .defines import ( + CONF_CURSOR, + CONF_DECIMAL_PLACES, + CONF_DIGITS, + CONF_MAIN, + CONF_ROLLOVER, + CONF_SCROLLBAR, + CONF_SELECTED, + CONF_TEXTAREA_PLACEHOLDER, +) +from .label import CONF_LABEL +from .lv_validation import lv_bool, lv_float +from .lvcode import lv +from .textarea import CONF_TEXTAREA +from .types import LvNumber, ObjUpdateAction +from .widget import Widget, WidgetType, get_widgets + +CONF_SPINBOX = "spinbox" + +lv_spinbox_t = LvNumber("lv_spinbox_t") + +SPIN_ACTIONS = ( + "INCREMENT", + "DECREMENT", + "STEP_NEXT", + "STEP_PREV", + "CLEAR", +) + + +def validate_spinbox(config): + max_val = 2**31 - 1 + min_val = -1 - max_val + range_from = int(config[CONF_RANGE_FROM]) + range_to = int(config[CONF_RANGE_TO]) + step = int(config[CONF_STEP]) + if ( + range_from > max_val + or range_from < min_val + or range_to > max_val + or range_to < min_val + ): + raise cv.Invalid("Range outside allowed limits") + if step <= 0 or step >= (range_to - range_from) / 2: + raise cv.Invalid("Invalid step value") + if config[CONF_DIGITS] <= config[CONF_DECIMAL_PLACES]: + raise cv.Invalid("Number of digits must exceed number of decimal places") + return config + + +SPINBOX_SCHEMA = cv.Schema( + { + cv.Optional(CONF_VALUE): lv_float, + cv.Optional(CONF_RANGE_FROM, default=0): cv.float_, + cv.Optional(CONF_RANGE_TO, default=100): cv.float_, + cv.Optional(CONF_DIGITS, default=4): cv.int_range(1, 10), + cv.Optional(CONF_STEP, default=1.0): cv.positive_float, + cv.Optional(CONF_DECIMAL_PLACES, default=0): cv.int_range(0, 6), + cv.Optional(CONF_ROLLOVER, default=False): lv_bool, + } +).add_extra(validate_spinbox) + + +SPINBOX_MODIFY_SCHEMA = { + cv.Required(CONF_VALUE): lv_float, +} + + +class SpinboxType(WidgetType): + def __init__(self): + super().__init__( + CONF_SPINBOX, + lv_spinbox_t, + ( + CONF_MAIN, + CONF_SCROLLBAR, + CONF_SELECTED, + CONF_CURSOR, + CONF_TEXTAREA_PLACEHOLDER, + ), + SPINBOX_SCHEMA, + SPINBOX_MODIFY_SCHEMA, + ) + + async def to_code(self, w: Widget, config): + if CONF_DIGITS in config: + digits = config[CONF_DIGITS] + scale = 10 ** config[CONF_DECIMAL_PLACES] + range_from = int(config[CONF_RANGE_FROM]) * scale + range_to = int(config[CONF_RANGE_TO]) * scale + step = int(config[CONF_STEP]) * scale + w.scale = scale + w.step = step + w.range_to = range_to + w.range_from = range_from + lv.spinbox_set_range(w.obj, range_from, range_to) + await w.set_property(CONF_STEP, step) + await w.set_property(CONF_ROLLOVER, config) + lv.spinbox_set_digit_format( + w.obj, digits, digits - config[CONF_DECIMAL_PLACES] + ) + if (value := config.get(CONF_VALUE)) is not None: + lv.spinbox_set_value(w.obj, await lv_float.process(value)) + + def get_scale(self, config): + return 10 ** config[CONF_DECIMAL_PLACES] + + def get_uses(self): + return CONF_TEXTAREA, CONF_LABEL + + def get_max(self, config: dict): + return config[CONF_RANGE_TO] + + def get_min(self, config: dict): + return config[CONF_RANGE_FROM] + + def get_step(self, config: dict): + return config[CONF_STEP] + + +spinbox_spec = SpinboxType() + + +@automation.register_action( + "lvgl.spinbox.increment", + ObjUpdateAction, + cv.maybe_simple_value( + { + cv.Required(CONF_ID): cv.use_id(lv_spinbox_t), + }, + key=CONF_ID, + ), +) +async def spinbox_increment(config, action_id, template_arg, args): + widgets = await get_widgets(config) + + async def do_increment(w: Widget): + lv.spinbox_increment(w.obj) + + return await action_to_code(widgets, do_increment, action_id, template_arg, args) + + +@automation.register_action( + "lvgl.spinbox.decrement", + ObjUpdateAction, + cv.maybe_simple_value( + { + cv.Required(CONF_ID): cv.use_id(lv_spinbox_t), + }, + key=CONF_ID, + ), +) +async def spinbox_decrement(config, action_id, template_arg, args): + widgets = await get_widgets(config) + + async def do_increment(w: Widget): + lv.spinbox_decrement(w.obj) + + return await action_to_code(widgets, do_increment, action_id, template_arg, args) + + +@automation.register_action( + "lvgl.spinbox.update", + ObjUpdateAction, + cv.Schema( + { + cv.Required(CONF_ID): cv.use_id(lv_spinbox_t), + cv.Required(CONF_VALUE): lv_float, + } + ), +) +async def spinbox_update_to_code(config, action_id, template_arg, args): + return await update_to_code(config, action_id, template_arg, args) diff --git a/esphome/components/lvgl/styles.py b/esphome/components/lvgl/styles.py index 7a795bc99d..09f1c376d0 100644 --- a/esphome/components/lvgl/styles.py +++ b/esphome/components/lvgl/styles.py @@ -26,7 +26,7 @@ async def styles_to_code(config): svar = cg.new_Pvariable(style[CONF_ID]) lv.style_init(svar) for prop, validator in ALL_STYLES.items(): - if value := style.get(prop): + if (value := style.get(prop)) is not None: if isinstance(validator, LValidator): value = await validator.process(value) if isinstance(value, list): diff --git a/esphome/components/lvgl/tabview.py b/esphome/components/lvgl/tabview.py new file mode 100644 index 0000000000..7b6a864e21 --- /dev/null +++ b/esphome/components/lvgl/tabview.py @@ -0,0 +1,114 @@ +from esphome import automation +import esphome.codegen as cg +import esphome.config_validation as cv +from esphome.const import CONF_ID, CONF_INDEX, CONF_NAME, CONF_POSITION, CONF_SIZE +from esphome.cpp_generator import MockObjClass + +from . import buttonmatrix_spec +from .automation import action_to_code +from .defines import ( + CONF_ANIMATED, + CONF_MAIN, + CONF_TAB_ID, + CONF_TABS, + DIRECTIONS, + TYPE_FLEX, + literal, +) +from .lv_validation import animated, lv_int, size +from .lvcode import LocalVariable, lv, lv_assign, lv_expr +from .obj import obj_spec +from .schemas import container_schema, part_schema +from .types import LV_EVENT, LvType, ObjUpdateAction, lv_obj_t, lv_obj_t_ptr +from .widget import Widget, WidgetType, add_widgets, get_widgets, set_obj_properties + +CONF_TABVIEW = "tabview" +CONF_TAB_STYLE = "tab_style" + +lv_tab_t = LvType("lv_obj_t") + +TABVIEW_SCHEMA = cv.Schema( + { + cv.Required(CONF_TABS): cv.ensure_list( + container_schema( + obj_spec, + { + cv.Required(CONF_NAME): cv.string, + cv.GenerateID(): cv.declare_id(lv_tab_t), + }, + ) + ), + cv.Optional(CONF_TAB_STYLE): part_schema(buttonmatrix_spec), + cv.Optional(CONF_POSITION, default="top"): DIRECTIONS.one_of, + cv.Optional(CONF_SIZE, default="10%"): size, + } +) + + +class TabviewType(WidgetType): + def __init__(self): + super().__init__( + CONF_TABVIEW, + LvType( + "lv_tabview_t", + largs=[(lv_obj_t_ptr, "tab")], + lvalue=lambda w: lv_expr.obj_get_child( + lv_expr.tabview_get_content(w.obj), + lv_expr.tabview_get_tab_act(w.obj), + ), + has_on_value=True, + ), + parts=(CONF_MAIN,), + schema=TABVIEW_SCHEMA, + modify_schema={}, + ) + + def get_uses(self): + return "btnmatrix", TYPE_FLEX + + async def to_code(self, w: Widget, config: dict): + for tab_conf in config[CONF_TABS]: + w_id = tab_conf[CONF_ID] + tab_obj = cg.Pvariable(w_id, cg.nullptr, type_=lv_tab_t) + tab_widget = Widget.create(w_id, tab_obj, obj_spec) + lv_assign(tab_obj, lv_expr.tabview_add_tab(w.obj, tab_conf[CONF_NAME])) + await set_obj_properties(tab_widget, tab_conf) + await add_widgets(tab_widget, tab_conf) + if button_style := config.get(CONF_TAB_STYLE): + with LocalVariable( + "tabview_btnmatrix", lv_obj_t, rhs=lv_expr.tabview_get_tab_btns(w.obj) + ) as btnmatrix_obj: + await set_obj_properties(Widget(btnmatrix_obj, obj_spec), button_style) + + def obj_creator(self, parent: MockObjClass, config: dict): + return lv_expr.call( + "tabview_create", + parent, + literal(config[CONF_POSITION]), + literal(config[CONF_SIZE]), + ) + + +tabview_spec = TabviewType() + + +@automation.register_action( + "lvgl.tabview.select", + ObjUpdateAction, + cv.Schema( + { + cv.Required(CONF_ID): cv.use_id(tabview_spec.w_type), + cv.Optional(CONF_ANIMATED, default=False): animated, + cv.Required(CONF_INDEX): lv_int, + }, + ).add_extra(cv.has_at_least_one_key(CONF_INDEX, CONF_TAB_ID)), +) +async def tabview_select(config, action_id, template_arg, args): + widget = await get_widgets(config) + index = config[CONF_INDEX] + + async def do_select(w: Widget): + lv.tabview_set_act(w.obj, index, literal(config[CONF_ANIMATED])) + lv.event_send(w.obj, LV_EVENT.VALUE_CHANGED, cg.nullptr) + + return await action_to_code(widget, do_select, action_id, template_arg, args) diff --git a/esphome/components/lvgl/textarea.py b/esphome/components/lvgl/textarea.py new file mode 100644 index 0000000000..d383e1f098 --- /dev/null +++ b/esphome/components/lvgl/textarea.py @@ -0,0 +1,67 @@ +import esphome.config_validation as cv +from esphome.const import CONF_MAX_LENGTH + +from .defines import ( + CONF_ACCEPTED_CHARS, + CONF_CURSOR, + CONF_MAIN, + CONF_ONE_LINE, + CONF_PASSWORD_MODE, + CONF_PLACEHOLDER_TEXT, + CONF_SCROLLBAR, + CONF_SELECTED, + CONF_TEXT, + CONF_TEXTAREA_PLACEHOLDER, +) +from .lv_validation import lv_bool, lv_int, lv_text +from .schemas import TEXT_SCHEMA +from .types import LvText +from .widget import Widget, WidgetType + +CONF_TEXTAREA = "textarea" + +lv_textarea_t = LvText("lv_textarea_t") + +TEXTAREA_SCHEMA = TEXT_SCHEMA.extend( + { + cv.Optional(CONF_PLACEHOLDER_TEXT): lv_text, + cv.Optional(CONF_ACCEPTED_CHARS): lv_text, + cv.Optional(CONF_ONE_LINE): lv_bool, + cv.Optional(CONF_PASSWORD_MODE): lv_bool, + cv.Optional(CONF_MAX_LENGTH): lv_int, + } +) + + +class TextareaType(WidgetType): + def __init__(self): + super().__init__( + CONF_TEXTAREA, + lv_textarea_t, + ( + CONF_MAIN, + CONF_SCROLLBAR, + CONF_SELECTED, + CONF_CURSOR, + CONF_TEXTAREA_PLACEHOLDER, + ), + TEXTAREA_SCHEMA, + ) + + async def to_code(self, w: Widget, config: dict): + for prop in (CONF_TEXT, CONF_PLACEHOLDER_TEXT, CONF_ACCEPTED_CHARS): + if (value := config.get(prop)) is not None: + await w.set_property(prop, await lv_text.process(value)) + await w.set_property( + CONF_MAX_LENGTH, await lv_int.process(config.get(CONF_MAX_LENGTH)) + ) + await w.set_property( + CONF_PASSWORD_MODE, + await lv_bool.process(config.get(CONF_PASSWORD_MODE)), + ) + await w.set_property( + CONF_ONE_LINE, await lv_bool.process(config.get(CONF_ONE_LINE)) + ) + + +textarea_spec = TextareaType() diff --git a/esphome/components/lvgl/tileview.py b/esphome/components/lvgl/tileview.py new file mode 100644 index 0000000000..aa841fa23e --- /dev/null +++ b/esphome/components/lvgl/tileview.py @@ -0,0 +1,128 @@ +from esphome import automation +import esphome.codegen as cg +import esphome.config_validation as cv +from esphome.const import CONF_ID, CONF_ON_VALUE, CONF_ROW, CONF_TRIGGER_ID + +from .automation import action_to_code +from .defines import ( + CONF_ANIMATED, + CONF_COLUMN, + CONF_DIR, + CONF_MAIN, + CONF_TILE_ID, + CONF_TILES, + TILE_DIRECTIONS, + literal, +) +from .lv_validation import animated, lv_int +from .lvcode import lv, lv_assign, lv_expr, lv_obj, lv_Pvariable +from .obj import obj_spec +from .schemas import container_schema +from .types import LV_EVENT, LvType, ObjUpdateAction, lv_obj_t, lv_obj_t_ptr +from .widget import Widget, WidgetType, add_widgets, get_widgets, set_obj_properties + +CONF_TILEVIEW = "tileview" + +lv_tile_t = LvType("lv_tileview_tile_t") + +lv_tileview_t = LvType( + "lv_tileview_t", + largs=[(lv_obj_t_ptr, "tile")], + lvalue=lambda w: w.get_property("tile_act"), +) + +tile_spec = WidgetType("lv_tileview_tile_t", lv_tile_t, (CONF_MAIN,), {}) + +TILEVIEW_SCHEMA = cv.Schema( + { + cv.Required(CONF_TILES): cv.ensure_list( + container_schema( + obj_spec, + { + cv.Required(CONF_ROW): lv_int, + cv.Required(CONF_COLUMN): lv_int, + cv.GenerateID(): cv.declare_id(lv_tile_t), + cv.Optional(CONF_DIR, default="ALL"): TILE_DIRECTIONS.several_of, + }, + ) + ), + cv.Optional(CONF_ON_VALUE): automation.validate_automation( + { + cv.GenerateID(CONF_TRIGGER_ID): cv.declare_id( + automation.Trigger.template(lv_obj_t_ptr) + ) + } + ), + } +) + + +class TileviewType(WidgetType): + def __init__(self): + super().__init__( + CONF_TILEVIEW, + lv_tileview_t, + (CONF_MAIN,), + schema=TILEVIEW_SCHEMA, + modify_schema={}, + ) + + async def to_code(self, w: Widget, config: dict): + for tile_conf in config.get(CONF_TILES) or (): + w_id = tile_conf[CONF_ID] + tile_obj = lv_Pvariable(lv_obj_t, w_id) + tile = Widget.create(w_id, tile_obj, tile_spec, tile_conf) + dirs = tile_conf[CONF_DIR] + if isinstance(dirs, list): + dirs = "|".join(dirs) + lv_assign( + tile_obj, + lv_expr.tileview_add_tile( + w.obj, tile_conf[CONF_COLUMN], tile_conf[CONF_ROW], literal(dirs) + ), + ) + await set_obj_properties(tile, tile_conf) + await add_widgets(tile, tile_conf) + + +tileview_spec = TileviewType() + + +def tile_select_validate(config): + row = CONF_ROW in config + column = CONF_COLUMN in config + tile = CONF_TILE_ID in config + if tile and (row or column) or not tile and not (row and column): + raise cv.Invalid("Specify either a tile id, or both a row and a column") + return config + + +@automation.register_action( + "lvgl.tileview.select", + ObjUpdateAction, + cv.Schema( + { + cv.Required(CONF_ID): cv.use_id(lv_tileview_t), + cv.Optional(CONF_ANIMATED, default=False): animated, + cv.Optional(CONF_ROW): lv_int, + cv.Optional(CONF_COLUMN): lv_int, + cv.Optional(CONF_TILE_ID): cv.use_id(lv_tile_t), + }, + ).add_extra(tile_select_validate), +) +async def tileview_select(config, action_id, template_arg, args): + widgets = await get_widgets(config) + + async def do_select(w: Widget): + if tile := config.get(CONF_TILE_ID): + tile = await cg.get_variable(tile) + lv_obj.set_tile(w.obj, tile, literal(config[CONF_ANIMATED])) + else: + row = await lv_int.process(config[CONF_ROW]) + column = await lv_int.process(config[CONF_COLUMN]) + lv_obj.set_tile_id( + widgets[0].obj, column, row, literal(config[CONF_ANIMATED]) + ) + lv.event_send(w.obj, LV_EVENT.VALUE_CHANGED, cg.nullptr) + + return await action_to_code(widgets, do_select, action_id, template_arg, args) diff --git a/esphome/components/lvgl/widget.py b/esphome/components/lvgl/widget.py index 5734aec7dc..fcaee29085 100644 --- a/esphome/components/lvgl/widget.py +++ b/esphome/components/lvgl/widget.py @@ -282,13 +282,13 @@ async def set_obj_properties(w: Widget, config): lv_obj.set_layout(w.obj, literal(f"LV_LAYOUT_{layout_type.upper()}")) if layout_type == TYPE_GRID: wid = config[CONF_ID] - rows = "{" + ",".join(layout[CONF_GRID_ROWS]) + ", LV_GRID_TEMPLATE_LAST}" + rows = [str(x) for x in layout[CONF_GRID_ROWS]] + rows = "{" + ",".join(rows) + ", LV_GRID_TEMPLATE_LAST}" row_id = ID(f"{wid}_row_dsc", is_declaration=True, type=lv_coord_t) row_array = cg.static_const_array(row_id, cg.RawExpression(rows)) w.set_style("grid_row_dsc_array", row_array, 0) - columns = ( - "{" + ",".join(layout[CONF_GRID_COLUMNS]) + ", LV_GRID_TEMPLATE_LAST}" - ) + columns = [str(x) for x in layout[CONF_GRID_COLUMNS]] + columns = "{" + ",".join(columns) + ", LV_GRID_TEMPLATE_LAST}" column_id = ID(f"{wid}_column_dsc", is_declaration=True, type=lv_coord_t) column_array = cg.static_const_array(column_id, cg.RawExpression(columns)) w.set_style("grid_column_dsc_array", column_array, 0) diff --git a/esphome/core/defines.h b/esphome/core/defines.h index 726db24592..b7bdbb1f9d 100644 --- a/esphome/core/defines.h +++ b/esphome/core/defines.h @@ -39,9 +39,12 @@ #define USE_LOCK #define USE_LOGGER #define USE_LVGL +#define USE_LVGL_ANIMIMG #define USE_LVGL_BINARY_SENSOR +#define USE_LVGL_BUTTONMATRIX #define USE_LVGL_FONT #define USE_LVGL_IMAGE +#define USE_LVGL_KEYBOARD #define USE_LVGL_KEY_LISTENER #define USE_LVGL_TOUCHSCREEN #define USE_LVGL_ROTARY_ENCODER diff --git a/tests/components/lvgl/.gitattributes b/tests/components/lvgl/.gitattributes new file mode 100644 index 0000000000..75e7a44254 --- /dev/null +++ b/tests/components/lvgl/.gitattributes @@ -0,0 +1,2 @@ +*.ttf -text + diff --git a/tests/components/lvgl/common.yaml b/tests/components/lvgl/common.yaml index 8b92f8caa7..6d0c1967b4 100644 --- a/tests/components/lvgl/common.yaml +++ b/tests/components/lvgl/common.yaml @@ -8,3 +8,49 @@ touchscreen: x_max: 240 y_max: 320 +font: + - file: "$component_dir/roboto.ttf" + id: roboto20 + size: 20 + extras: + - file: '$component_dir/materialdesignicons-webfont.ttf' + glyphs: [ + "\U000F004B", + "\U0000f0ed", + "\U000F006E", + "\U000F012C", + "\U000F179B", + "\U000F0748", + "\U000F1A1B", + "\U000F02DC", + "\U000F0A02", + "\U000F035F", + "\U000F0156", + "\U000F0C5F", + "\U000f0084", + "\U000f0091", + ] + - file: "$component_dir/helvetica.ttf" + id: helvetica20 + - file: "$component_dir/roboto.ttf" + id: roboto10 + size: 10 + bpp: 4 + extras: + - file: '$component_dir/materialdesignicons-webfont.ttf' + glyphs: [ + "\U000F004B", + "\U0000f0ed", + "\U000F006E", + "\U000F012C", + "\U000F179B", + "\U000F0748", + "\U000F1A1B", + "\U000F02DC", + "\U000F0A02", + "\U000F035F", + "\U000F0156", + "\U000F0C5F", + "\U000f0084", + "\U000f0091", + ] diff --git a/tests/components/lvgl/helvetica.ttf b/tests/components/lvgl/helvetica.ttf new file mode 100644 index 0000000000000000000000000000000000000000..7aec6f3f3cc74a7138ce350def27a2209b44ad89 GIT binary patch literal 83644 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⪚zp1_lsq#=y^D2D*irfuF$~j2XbR1p_|= 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

69WS) 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