Refactor to keep CI checks happy

esphome/components/lvgl/__init__.py

@@ -2196,9 +2196,8 @@ async def widget_to_code(w_cnfig, w_type, parent: Widget):
         init.append(f"{var} = {creator}")
         obj = var
 
-    widget = Widget(var, ty.get_widget_type(w_type), w_cnfig, obj)
+    widget = Widget(var, ty.get_widget_type(w_type), w_cnfig, obj, parent)
     widget_map[id] = widget
-    widget.set_parent(parent)
     if theme := theme_widget_map.get(w_type):
         init.append(f"{theme}({obj})")
     init.extend(await set_obj_properties(widget, w_cnfig))

esphome/components/lvgl/number.py

@@ -53,8 +53,8 @@ async def to_code(config):
                lv_event_send({widget.obj}, {paren}->get_custom_change_event(), nullptr);
                {publish};
             }})""",
-            f"{var}->traits.set_max_value({widget.get_max_value()})",
-            f"{var}->traits.set_min_value({widget.get_min_value()})",
+            f"""{var}->traits.set_max_value({widget.get_mxx_value("max")})""",
+            f"""{var}->traits.set_min_value({widget.get_mxx_value("min")})""",
             publish,
         ]
     )

esphome/components/lvgl/select.py

@@ -10,9 +10,9 @@
     add_init_lambda,
     get_widget,
 )
-from .defines import CONF_WIDGET, CONF_LVGL_ID, CONF_DROPDOWN
+from .defines import CONF_WIDGET, CONF_LVGL_ID, CONF_ANIMATED
 from .lv_validation import requires_component
-from .types import lvgl_ns, lv_select_t
+from .types import lvgl_ns, LvSelect
 
 LVGLSelect = lvgl_ns.class_("LVGLSelect", select.Select)
 
@@ -21,7 +21,8 @@
     .extend(LVGL_SCHEMA)
     .extend(
         {
-            cv.Required(CONF_WIDGET): cv.use_id(lv_select_t),
+            cv.Required(CONF_WIDGET): cv.use_id(LvSelect),
+            cv.Optional(CONF_ANIMATED, default=False): cv.boolean,
         }
     ),
     requires_component("select"),
@@ -34,27 +35,18 @@ async def to_code(config):
     paren = await cg.get_variable(config[CONF_LVGL_ID])
     init = []
     widget = await get_widget(config[CONF_WIDGET])
-    if widget.type_base() == CONF_DROPDOWN:
-        animated = ""
-    else:
-        animated = ", LV_ANIM_OFF"
-    publish = (
-        f"{var}->publish_index(lv_{widget.type_base()}_get_selected({widget.obj}))"
-    )
+    publish = f"""{var}->publish_index({widget.get_property("selected")[0]})"""
     init.extend(
         widget.set_event_cb(
             publish,
             "LV_EVENT_VALUE_CHANGED",
         )
     )
-    init.extend(
-        [
-            f"""{var}->set_options(lv_{widget.type_base()}_get_options({widget.obj}));
+    init.append(
+        f"""{var}->set_options({widget.get_property("options")[0]});
             {var}->set_control_lambda([] (size_t v) {{
-                lv_{widget.type_base()}_set_selected({widget.obj}, v {animated});
-               {publish};
-            }})""",
-            publish,
-        ]
+            """
     )
+    init.extend(widget.set_property("selected", "v", animated=config[CONF_ANIMATED]))
+    init.extend([publish, "})", publish])
     await add_init_lambda(paren, init)

esphome/components/lvgl/types.py

@@ -43,6 +43,7 @@ def __init__(self, *args, **kwargs):
         self.args = kwargs.pop("largs", [(lv_obj_t_ptr, "obj")])
         self.value = kwargs.pop("lvalue", lambda w: w.obj)
         self.has_on_value = kwargs.pop("has_on_value", False)
+        self.animated = kwargs.pop("animated", False)
 
     def get_arg_type(self):
         return self.args[0][0] if len(self.args) else None
@@ -65,7 +66,18 @@ def __init__(self, *args, **kwargs):
             largs=[(cg.bool_, "x")],
             lvalue=lambda w: w.is_checked(),
             has_on_value=True,
-            *kwargs,
+            **kwargs,
+        )
+
+
+class LvSelect(LvType):
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            largs=[(cg.int_, "x")],
+            lvalue=lambda w: w.get_property("selected")[0],
+            has_on_value=True,
+            **kwargs,
         )
 
 
@@ -86,9 +98,8 @@ def __init__(self, *args, **kwargs):
 lv_slider_t = LvNumber("LvSliderType")
 lv_disp_t_ptr = cg.global_ns.struct("lv_disp_t").operator("ptr")
 lv_canvas_t = LvType("LvCanvasType")
-lv_select_t = lvgl_ns.class_("LvPseudoSelect")
-lv_dropdown_t = LvType("LvDropdownType", parents=(lv_select_t,))
-lv_roller_t = LvType("LvRollerType", parents=(lv_select_t,))
+lv_dropdown_t = LvSelect("LvDropdownType")
+lv_roller_t = LvSelect("LvRollerType", animated=True)
 lv_led_t = LvType("LvLedType")
 lv_switch_t = LvBoolean("LvSwitchType")
 lv_table_t = LvType("LvTableType")
@@ -117,5 +128,5 @@ def __init__(self, *args, **kwargs):
 lv_tick_style_t = lv_obj_t
 
 
-def get_widget_type(typestr: str) -> cg.MockObjClass:
+def get_widget_type(typestr: str) -> LvType:
     return globals()[f"lv_{typestr}_t"]

esphome/components/lvgl/widget.py

@@ -9,7 +9,9 @@
 
 
 class Widget:
-    def __init__(self, var, wtype: cg.MockObjClass, config: dict = None, obj=None):
+    def __init__(
+        self, var, wtype: cg.MockObjClass, config: dict = None, obj=None, parent=None
+    ):
         self.var = var
         self.type = wtype
         self.config = config
@@ -19,11 +21,6 @@ def __init__(self, var, wtype: cg.MockObjClass, config: dict = None, obj=None):
         self.step = 1.0
         self.range_from = -sys.maxsize
         self.range_to = sys.maxsize
-
-    def get_obj(self):
-        return self.obj
-
-    def set_parent(self, parent):
         self.parent = parent
 
     def check_null(self):
@@ -60,15 +57,23 @@ def add_flag(self, flag):
     def clear_flag(self, flag):
         return [f"lv_obj_clear_flag({self.obj}, {flag})"]
 
-    def set_property(self, prop, value, ltype=None):
+    def set_property(self, prop, value, ltype=None, animated: bool = None):
+        if animated is None or self.type.animated is not True:
+            animated = ""
+        else:
+            animated = f""", {"LV_ANIM_ON" if animated else "LV_ANIM_OFF"}"""
         if isinstance(value, dict):
             value = value.get(prop)
         if value is None:
             return []
         if isinstance(value, TimePeriod):
             value = value.total_milliseconds
-        ltype = ltype or self.type_base()
-        return [f"lv_{ltype}_set_{prop}({self.obj}, {value})"]
+        ltype = ltype or self.__type_base()
+        return [f"lv_{ltype}_set_{prop}({self.obj}, {value} {animated})"]
+
+    def get_property(self, prop, ltype=None):
+        ltype = ltype or self.__type_base()
+        return [f"lv_{ltype}_get_{prop}({self.obj})"]
 
     def set_style(self, prop, value, state):
         return [f"lv_obj_set_style_{prop}({self.obj}, {value}, {state})"]
@@ -86,8 +91,8 @@ def set_event_cb(self, code, *varargs):
 
     def get_number_value(self):
         if self.scale == 1.0:
-            return f"lv_{self.type_base()}_get_value({self.obj})"
-        return f"lv_{self.type_base()}_get_value({self.obj})/{self.scale:#f}f"
+            return f"lv_{self.__type_base()}_get_value({self.obj})"
+        return f"lv_{self.__type_base()}_get_value({self.obj})/{self.scale:#f}f"
 
     def get_value(self):
         if isinstance(self.type, ty.LvType):
@@ -99,33 +104,27 @@ def get_args(self):
             return self.type.args
         return [(ty.lv_obj_t_ptr, "obj")]
 
-    def set_value(self, value, animated: bool = False):
-        if self.type_base() in (CONF_ARC, CONF_SPINBOX):
+    def set_value(self, value, animated: bool = None):
+        if animated is None or self.__type_base() in (CONF_ARC, CONF_SPINBOX):
             animated = ""
         else:
-            animated = f", {animated}"
+            animated = f""", {"LV_ANIM_ON" if animated else "LV_ANIM_OFF"}"""
         if self.scale != 1.0:
             value = f"{value} * {self.scale:#f}"
-        return [f"lv_{self.type_base()}_set_value({self.obj}, {value} {animated})"]
+        return [f"lv_{self.__type_base()}_set_value({self.obj}, {value} {animated})"]
 
     def get_mxx_value(self, which: str):
         if self.scale == 1.0:
             mult = ""
         else:
             mult = f"/ {self.scale:#f}"
-        if self.type_base() == CONF_SPINBOX and which in ("max", "min"):
+        if self.__type_base() == CONF_SPINBOX and which in ("max", "min"):
             gval = f"((lv_spinbox_t *){self.obj})->range_{which}"
         else:
-            gval = f"lv_{self.type_base()}_get_{which}_value({self.obj})"
+            gval = f"lv_{self.__type_base()}_get_{which}_value({self.obj})"
         return f"({gval} {mult})"
 
-    def get_max_value(self):
-        return self.get_mxx_value("max")
-
-    def get_min_value(self):
-        return self.get_mxx_value("min")
-
-    def type_base(self):
+    def __type_base(self):
         base = str(self.type)
         if base.startswith("Lv"):
             return f"{self.type}".removeprefix("Lv").removesuffix("Type").lower()

tests/components/lvgl/test.esp32.yaml

@@ -79,6 +79,7 @@ select:
   - platform: lvgl
     widget: roller_id
     name: LVGL Roller
+    animated: true
 
 image:
   - id: cat_image