esphome 2024.10.3__py3-none-any.whl → 2024.11.0b1__py3-none-any.whl

esphome/components/lvgl/number/__init__.py

@@ -3,7 +3,7 @@ from esphome.components import number
 import esphome.config_validation as cv
 from esphome.cpp_generator import MockObj
 
-from ..defines import CONF_ANIMATED, CONF_LVGL_ID, CONF_UPDATE_ON_RELEASE, CONF_WIDGET
+from ..defines import CONF_ANIMATED, CONF_UPDATE_ON_RELEASE, CONF_WIDGET
 from ..lv_validation import animated
 from ..lvcode import (
     API_EVENT,
@@ -13,28 +13,23 @@ from ..lvcode import (
     LvContext,
     lv,
     lv_add,
+    lvgl_static,
 )
-from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LvNumber, lvgl_ns
 from ..widgets import get_widgets, wait_for_widgets
 
 LVGLNumber = lvgl_ns.class_("LVGLNumber", number.Number)
 
-CONFIG_SCHEMA = (
-    number.number_schema(LVGLNumber)
-    .extend(LVGL_SCHEMA)
-    .extend(
-        {
-            cv.Required(CONF_WIDGET): cv.use_id(LvNumber),
-            cv.Optional(CONF_ANIMATED, default=True): animated,
-            cv.Optional(CONF_UPDATE_ON_RELEASE, default=False): cv.boolean,
-        }
-    )
+CONFIG_SCHEMA = number.number_schema(LVGLNumber).extend(
+    {
+        cv.Required(CONF_WIDGET): cv.use_id(LvNumber),
+        cv.Optional(CONF_ANIMATED, default=True): animated,
+        cv.Optional(CONF_UPDATE_ON_RELEASE, default=False): cv.boolean,
+    }
 )
 
 
 async def to_code(config):
-    paren = await cg.get_variable(config[CONF_LVGL_ID])
     widget = await get_widgets(config, CONF_WIDGET)
     widget = widget[0]
     var = await number.new_number(
@@ -58,10 +53,10 @@ async def to_code(config):
         if not config[CONF_UPDATE_ON_RELEASE]
         else LV_EVENT.RELEASED
     )
-    async with LvContext(paren):
+    async with LvContext():
         lv_add(var.set_control_lambda(await control.get_lambda()))
         lv_add(
-            paren.add_event_cb(
+            lvgl_static.add_event_cb(
                 widget.obj, await event.get_lambda(), UPDATE_EVENT, event_code
             )
         )

esphome/components/lvgl/schemas.py

@@ -216,7 +216,7 @@ def automation_schema(typ: LvType):
         events = df.LV_EVENT_TRIGGERS + (CONF_ON_VALUE,)
     else:
         events = df.LV_EVENT_TRIGGERS
-    args = [typ.get_arg_type()] if isinstance(typ, LvType) else []
+    args = typ.get_arg_type() if isinstance(typ, LvType) else []
     args.append(lv_event_t_ptr)
     return {
         cv.Optional(event): validate_automation(
@@ -391,7 +391,9 @@ def container_validator(schema, widget_type: WidgetType):
             add_lv_use(ltype)
         if value == SCHEMA_EXTRACT:
             return result
-        result = result.extend(LAYOUT_SCHEMAS[ltype.lower()])
+        result = result.extend(
+            LAYOUT_SCHEMAS.get(ltype.lower(), LAYOUT_SCHEMAS[df.TYPE_NONE])
+        )
         return result(value)
 
     return validator

esphome/components/lvgl/select/__init__.py

@@ -1,33 +1,19 @@
-import esphome.codegen as cg
 from esphome.components import select
 import esphome.config_validation as cv
 from esphome.const import CONF_OPTIONS
 
-from ..defines import CONF_ANIMATED, CONF_LVGL_ID, CONF_WIDGET
-from ..lvcode import (
-    API_EVENT,
-    EVENT_ARG,
-    UPDATE_EVENT,
-    LambdaContext,
-    LvContext,
-    lv,
-    lv_add,
-)
-from ..schemas import LVGL_SCHEMA
-from ..types import LV_EVENT, LvSelect, lvgl_ns
+from ..defines import CONF_ANIMATED, CONF_WIDGET, literal
+from ..lvcode import LvContext
+from ..types import LvSelect, lvgl_ns
 from ..widgets import get_widgets, wait_for_widgets
 
 LVGLSelect = lvgl_ns.class_("LVGLSelect", select.Select)
 
-CONFIG_SCHEMA = (
-    select.select_schema(LVGLSelect)
-    .extend(LVGL_SCHEMA)
-    .extend(
-        {
-            cv.Required(CONF_WIDGET): cv.use_id(LvSelect),
-            cv.Optional(CONF_ANIMATED, default=False): cv.boolean,
-        }
-    )
+CONFIG_SCHEMA = select.select_schema(LVGLSelect).extend(
+    {
+        cv.Required(CONF_WIDGET): cv.use_id(LvSelect),
+        cv.Optional(CONF_ANIMATED, default=False): cv.boolean,
+    }
 )
 
 
@@ -36,22 +22,11 @@ async def to_code(config):
     widget = widget[0]
     options = widget.config.get(CONF_OPTIONS, [])
     selector = await select.new_select(config, options=options)
-    paren = await cg.get_variable(config[CONF_LVGL_ID])
     await wait_for_widgets()
-    async with LambdaContext(EVENT_ARG) as pub_ctx:
-        pub_ctx.add(selector.publish_index(widget.get_value()))
-    async with LambdaContext([(cg.uint16, "v")]) as control:
-        await widget.set_property("selected", "v", animated=config[CONF_ANIMATED])
-        lv.event_send(widget.obj, API_EVENT, cg.nullptr)
-        control.add(selector.publish_index(widget.get_value()))
-    async with LvContext(paren) as ctx:
-        lv_add(selector.set_control_lambda(await control.get_lambda()))
+    async with LvContext() as ctx:
         ctx.add(
-            paren.add_event_cb(
-                widget.obj,
-                await pub_ctx.get_lambda(),
-                LV_EVENT.VALUE_CHANGED,
-                UPDATE_EVENT,
+            selector.set_widget(
+                widget.var,
+                literal("LV_ANIM_ON" if config[CONF_ANIMATED] else "LV_ANIM_OFF"),
             )
         )
-        lv_add(selector.publish_index(widget.get_value()))

esphome/components/lvgl/select/lvgl_select.h

@@ -6,58 +6,52 @@
 #include "esphome/core/automation.h"
 #include "esphome/core/component.h"
 #include "esphome/core/preferences.h"
+#include "../lvgl.h"
 
 namespace esphome {
 namespace lvgl {
 
-static std::vector<std::string> split_string(const std::string &str) {
-  std::vector<std::string> strings;
-  auto delimiter = std::string("\n");
-
-  std::string::size_type pos;
-  std::string::size_type prev = 0;
-  while ((pos = str.find(delimiter, prev)) != std::string::npos) {
-    strings.push_back(str.substr(prev, pos - prev));
-    prev = pos + delimiter.size();
-  }
-
-  // To get the last substring (or only, if delimiter is not found)
-  strings.push_back(str.substr(prev));
-
-  return strings;
-}
-
 class LVGLSelect : public select::Select {
  public:
-  void set_control_lambda(std::function<void(size_t)> lambda) {
-    this->control_lambda_ = std::move(lambda);
+  void set_widget(LvSelectable *widget, lv_anim_enable_t anim = LV_ANIM_OFF) {
+    this->widget_ = widget;
+    this->anim_ = anim;
+    this->set_options_();
+    lv_obj_add_event_cb(
+        this->widget_->obj,
+        [](lv_event_t *e) {
+          auto *it = static_cast<LVGLSelect *>(e->user_data);
+          it->set_options_();
+        },
+        LV_EVENT_REFRESH, this);
     if (this->initial_state_.has_value()) {
       this->control(this->initial_state_.value());
       this->initial_state_.reset();
     }
+    this->publish();
+    auto lamb = [](lv_event_t *e) {
+      auto *self = static_cast<LVGLSelect *>(e->user_data);
+      self->publish();
+    };
+    lv_obj_add_event_cb(this->widget_->obj, lamb, LV_EVENT_VALUE_CHANGED, this);
+    lv_obj_add_event_cb(this->widget_->obj, lamb, lv_update_event, this);
   }
 
-  void publish_index(size_t index) {
-    auto value = this->at(index);
-    if (value)
-      this->publish_state(value.value());
-  }
-
-  void set_options(const char *str) { this->traits.set_options(split_string(str)); }
+  void publish() { this->publish_state(this->widget_->get_selected_text()); }
 
  protected:
   void control(const std::string &value) override {
-    if (this->control_lambda_ != nullptr) {
-      auto index = index_of(value);
-      if (index)
-        this->control_lambda_(index.value());
+    if (this->widget_ != nullptr) {
+      this->widget_->set_selected_text(value, this->anim_);
     } else {
-      this->initial_state_ = value.c_str();
+      this->initial_state_ = value;
     }
   }
+  void set_options_() { this->traits.set_options(this->widget_->get_options()); }
 
-  std::function<void(size_t)> control_lambda_{};
-  optional<const char *> initial_state_{};
+  LvSelectable *widget_{};
+  optional<std::string> initial_state_{};
+  lv_anim_enable_t anim_{LV_ANIM_OFF};
 };
 
 }  // namespace lvgl

esphome/components/lvgl/sensor/__init__.py

@@ -1,8 +1,7 @@
-import esphome.codegen as cg
 from esphome.components.sensor import Sensor, new_sensor, sensor_schema
 import esphome.config_validation as cv
 
-from ..defines import CONF_LVGL_ID, CONF_WIDGET
+from ..defines import CONF_WIDGET
 from ..lvcode import (
     API_EVENT,
     EVENT_ARG,
@@ -11,34 +10,29 @@ from ..lvcode import (
     LambdaContext,
     LvContext,
     lv_add,
+    lvgl_static,
 )
-from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LvNumber
 from ..widgets import Widget, get_widgets, wait_for_widgets
 
-CONFIG_SCHEMA = (
-    sensor_schema(Sensor)
-    .extend(LVGL_SCHEMA)
-    .extend(
-        {
-            cv.Required(CONF_WIDGET): cv.use_id(LvNumber),
-        }
-    )
+CONFIG_SCHEMA = sensor_schema(Sensor).extend(
+    {
+        cv.Required(CONF_WIDGET): cv.use_id(LvNumber),
+    }
 )
 
 
 async def to_code(config):
     sensor = await new_sensor(config)
-    paren = await cg.get_variable(config[CONF_LVGL_ID])
     widget = await get_widgets(config, CONF_WIDGET)
     widget = widget[0]
     assert isinstance(widget, Widget)
     await wait_for_widgets()
     async with LambdaContext(EVENT_ARG) as lamb:
         lv_add(sensor.publish_state(widget.get_value()))
-    async with LvContext(paren, LVGL_COMP_ARG):
+    async with LvContext(LVGL_COMP_ARG):
         lv_add(
-            paren.add_event_cb(
+            lvgl_static.add_event_cb(
                 widget.obj,
                 await lamb.get_lambda(),
                 LV_EVENT.VALUE_CHANGED,

esphome/components/lvgl/styles.py

@@ -17,8 +17,6 @@ from .types import lv_lambda_t, lv_obj_t, lv_obj_t_ptr
 from .widgets import Widget, add_widgets, set_obj_properties, theme_widget_map
 from .widgets.obj import obj_spec
 
-TOP_LAYER = literal("lv_disp_get_layer_top(lv_component->get_disp())")
-
 
 async def styles_to_code(config):
     """Convert styles to C__ code."""
@@ -51,9 +49,10 @@ async def theme_to_code(config):
             lv_assign(apply, await context.get_lambda())
 
 
-async def add_top_layer(config):
+async def add_top_layer(lv_component, config):
+    top_layer = lv.disp_get_layer_top(lv_component.get_disp())
     if top_conf := config.get(CONF_TOP_LAYER):
-        with LocalVariable("top_layer", lv_obj_t, TOP_LAYER) as top_layer_obj:
+        with LocalVariable("top_layer", lv_obj_t, top_layer) as top_layer_obj:
             top_w = Widget(top_layer_obj, obj_spec, top_conf)
             await set_obj_properties(top_w, top_conf)
             await add_widgets(top_w, top_conf)

esphome/components/lvgl/switch/__init__.py

@@ -3,7 +3,7 @@ from esphome.components.switch import Switch, new_switch, switch_schema
 import esphome.config_validation as cv
 from esphome.cpp_generator import MockObj
 
-from ..defines import CONF_LVGL_ID, CONF_WIDGET, literal
+from ..defines import CONF_WIDGET, literal
 from ..lvcode import (
     API_EVENT,
     EVENT_ARG,
@@ -13,26 +13,21 @@ from ..lvcode import (
     LvContext,
     lv,
     lv_add,
+    lvgl_static,
 )
-from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LV_STATE, lv_pseudo_button_t, lvgl_ns
 from ..widgets import get_widgets, wait_for_widgets
 
 LVGLSwitch = lvgl_ns.class_("LVGLSwitch", Switch)
-CONFIG_SCHEMA = (
-    switch_schema(LVGLSwitch)
-    .extend(LVGL_SCHEMA)
-    .extend(
-        {
-            cv.Required(CONF_WIDGET): cv.use_id(lv_pseudo_button_t),
-        }
-    )
+CONFIG_SCHEMA = switch_schema(LVGLSwitch).extend(
+    {
+        cv.Required(CONF_WIDGET): cv.use_id(lv_pseudo_button_t),
+    }
 )
 
 
 async def to_code(config):
     switch = await new_switch(config)
-    paren = await cg.get_variable(config[CONF_LVGL_ID])
     widget = await get_widgets(config, CONF_WIDGET)
     widget = widget[0]
     await wait_for_widgets()
@@ -45,10 +40,10 @@ async def to_code(config):
             widget.clear_state(LV_STATE.CHECKED)
         lv.event_send(widget.obj, API_EVENT, cg.nullptr)
         control.add(switch.publish_state(literal("v")))
-    async with LvContext(paren) as ctx:
+    async with LvContext() as ctx:
         lv_add(switch.set_control_lambda(await control.get_lambda()))
         ctx.add(
-            paren.add_event_cb(
+            lvgl_static.add_event_cb(
                 widget.obj,
                 await checked_ctx.get_lambda(),
                 LV_EVENT.VALUE_CHANGED,

esphome/components/lvgl/text/__init__.py

@@ -3,7 +3,7 @@ from esphome.components import text
 from esphome.components.text import new_text
 import esphome.config_validation as cv
 
-from ..defines import CONF_LVGL_ID, CONF_WIDGET
+from ..defines import CONF_WIDGET
 from ..lvcode import (
     API_EVENT,
     EVENT_ARG,
@@ -12,14 +12,14 @@ from ..lvcode import (
     LvContext,
     lv,
     lv_add,
+    lvgl_static,
 )
-from ..schemas import LVGL_SCHEMA
 from ..types import LV_EVENT, LvText, lvgl_ns
 from ..widgets import get_widgets, wait_for_widgets
 
 LVGLText = lvgl_ns.class_("LVGLText", text.Text)
 
-CONFIG_SCHEMA = text.TEXT_SCHEMA.extend(LVGL_SCHEMA).extend(
+CONFIG_SCHEMA = text.TEXT_SCHEMA.extend(
     {
         cv.GenerateID(): cv.declare_id(LVGLText),
         cv.Required(CONF_WIDGET): cv.use_id(LvText),
@@ -29,7 +29,6 @@ CONFIG_SCHEMA = text.TEXT_SCHEMA.extend(LVGL_SCHEMA).extend(
 
 async def to_code(config):
     textvar = await new_text(config)
-    paren = await cg.get_variable(config[CONF_LVGL_ID])
     widget = await get_widgets(config, CONF_WIDGET)
     widget = widget[0]
     await wait_for_widgets()
@@ -39,10 +38,10 @@ async def to_code(config):
         control.add(textvar.publish_state(widget.get_value()))
     async with LambdaContext(EVENT_ARG) as lamb:
         lv_add(textvar.publish_state(widget.get_value()))
-    async with LvContext(paren):
+    async with LvContext():
         lv_add(textvar.set_control_lambda(await control.get_lambda()))
         lv_add(
-            paren.add_event_cb(
+            lvgl_static.add_event_cb(
                 widget.obj,
                 await lamb.get_lambda(),
                 LV_EVENT.VALUE_CHANGED,

esphome/components/lvgl/text_sensor/__init__.py

@@ -1,4 +1,3 @@
-import esphome.codegen as cg
 from esphome.components.text_sensor import (
     TextSensor,
     new_text_sensor,
@@ -6,34 +5,35 @@ from esphome.components.text_sensor import (
 )
 import esphome.config_validation as cv
 
-from ..defines import CONF_LVGL_ID, CONF_WIDGET
-from ..lvcode import API_EVENT, EVENT_ARG, UPDATE_EVENT, LambdaContext, LvContext
-from ..schemas import LVGL_SCHEMA
+from ..defines import CONF_WIDGET
+from ..lvcode import (
+    API_EVENT,
+    EVENT_ARG,
+    UPDATE_EVENT,
+    LambdaContext,
+    LvContext,
+    lvgl_static,
+)
 from ..types import LV_EVENT, LvText
 from ..widgets import get_widgets, wait_for_widgets
 
-CONFIG_SCHEMA = (
-    text_sensor_schema(TextSensor)
-    .extend(LVGL_SCHEMA)
-    .extend(
-        {
-            cv.Required(CONF_WIDGET): cv.use_id(LvText),
-        }
-    )
+CONFIG_SCHEMA = text_sensor_schema(TextSensor).extend(
+    {
+        cv.Required(CONF_WIDGET): cv.use_id(LvText),
+    }
 )
 
 
 async def to_code(config):
     sensor = await new_text_sensor(config)
-    paren = await cg.get_variable(config[CONF_LVGL_ID])
     widget = await get_widgets(config, CONF_WIDGET)
     widget = widget[0]
     await wait_for_widgets()
     async with LambdaContext(EVENT_ARG) as pressed_ctx:
         pressed_ctx.add(sensor.publish_state(widget.get_value()))
-    async with LvContext(paren) as ctx:
+    async with LvContext() as ctx:
         ctx.add(
-            paren.add_event_cb(
+            lvgl_static.add_event_cb(
                 widget.obj,
                 await pressed_ctx.get_lambda(),
                 LV_EVENT.VALUE_CHANGED,

esphome/components/lvgl/touchscreens.py

@@ -33,13 +33,12 @@ def touchscreen_schema(config):
     return [TOUCHSCREENS_CONFIG(config)]
 
 
-async def touchscreens_to_code(var, config):
+async def touchscreens_to_code(lv_component, config):
     for tconf in config[CONF_TOUCHSCREENS]:
         lvgl_components_required.add(CONF_TOUCHSCREEN)
         touchscreen = await cg.get_variable(tconf[CONF_TOUCHSCREEN_ID])
         lpt = tconf[CONF_LONG_PRESS_TIME].total_milliseconds
         lprt = tconf[CONF_LONG_PRESS_REPEAT_TIME].total_milliseconds
-        listener = cg.new_Pvariable(tconf[CONF_ID], lpt, lprt)
-        await cg.register_parented(listener, var)
+        listener = cg.new_Pvariable(tconf[CONF_ID], lpt, lprt, lv_component)
         lv.indev_drv_register(listener.get_drv())
         cg.add(touchscreen.register_listener(listener))

esphome/components/lvgl/trigger.py

@@ -20,17 +20,16 @@ from .lvcode import (
     lv,
     lv_add,
     lv_event_t_ptr,
+    lvgl_static,
 )
 from .types import LV_EVENT
 from .widgets import widget_map
 
 
-async def generate_triggers(lv_component):
+async def generate_triggers():
     """
     Generate LVGL triggers for all defined widgets
     Must be done after all widgets completed
-    :param lv_component:  The parent component
-    :return:
     """
 
     for w in widget_map.values():
@@ -43,11 +42,10 @@ async def generate_triggers(lv_component):
                 conf = conf[0]
                 w.add_flag("LV_OBJ_FLAG_CLICKABLE")
                 event = literal("LV_EVENT_" + LV_EVENT_MAP[event[3:].upper()])
-                await add_trigger(conf, lv_component, w, event)
+                await add_trigger(conf, w, event)
             for conf in w.config.get(CONF_ON_VALUE, ()):
                 await add_trigger(
                     conf,
-                    lv_component,
                     w,
                     LV_EVENT.VALUE_CHANGED,
                     API_EVENT,
@@ -63,13 +61,13 @@ async def generate_triggers(lv_component):
                 lv.obj_align_to(w.obj, target, align, x, y)
 
 
-async def add_trigger(conf, lv_component, w, *events):
+async def add_trigger(conf, w, *events):
     tid = conf[CONF_TRIGGER_ID]
     trigger = cg.new_Pvariable(tid)
     args = w.get_args() + [(lv_event_t_ptr, "event")]
-    value = w.get_value()
+    value = w.get_values()
     await automation.build_automation(trigger, args, conf)
     async with LambdaContext(EVENT_ARG, where=tid) as context:
         with LvConditional(w.is_selected()):
-            lv_add(trigger.trigger(value, literal("event")))
-    lv_add(lv_component.add_event_cb(w.obj, await context.get_lambda(), *events))
+            lv_add(trigger.trigger(*value, literal("event")))
+    lv_add(lvgl_static.add_event_cb(w.obj, await context.get_lambda(), *events))

esphome/components/lvgl/types.py

@@ -18,7 +18,9 @@ class LvType(cg.MockObjClass):
         self.value_property = None
 
     def get_arg_type(self):
-        return self.args[0][0] if len(self.args) else None
+        if len(self.args) == 0:
+            return None
+        return [arg[0] for arg in self.args]
 
 
 class LvNumber(LvType):
@@ -38,8 +40,10 @@ void_ptr = cg.void.operator("ptr")
 lv_coord_t = cg.global_ns.namespace("lv_coord_t")
 lv_event_code_t = cg.global_ns.enum("lv_event_code_t")
 lv_indev_type_t = cg.global_ns.enum("lv_indev_type_t")
+lv_key_t = cg.global_ns.enum("lv_key_t")
 FontEngine = lvgl_ns.class_("FontEngine")
 IdleTrigger = lvgl_ns.class_("IdleTrigger", automation.Trigger.template())
+PauseTrigger = lvgl_ns.class_("PauseTrigger", automation.Trigger.template())
 ObjUpdateAction = lvgl_ns.class_("ObjUpdateAction", automation.Action)
 LvglCondition = lvgl_ns.class_("LvglCondition", automation.Condition)
 LvglAction = lvgl_ns.class_("LvglAction", automation.Action)
@@ -91,11 +95,13 @@ class LvBoolean(LvType):
 
 class LvSelect(LvType):
     def __init__(self, *args, **kwargs):
+        parens = kwargs.pop("parents", ()) + (LvCompound,)
         super().__init__(
             *args,
-            largs=[(cg.int_, "x")],
-            lvalue=lambda w: w.get_property("selected"),
+            largs=[(cg.int_, "x"), (cg.std_string, "text")],
+            lvalue=lambda w: [w.var.get_selected_index(), w.var.get_selected_text()],
             has_on_value=True,
+            parents=parens,
             **kwargs,
         )
 

esphome/components/lvgl/widgets/__init__.py

@@ -55,29 +55,14 @@ theme_widget_map = {}
 styles_used = set()
 
 
-class LvScrActType(WidgetType):
-    """
-    A "widget" representing the active screen.
-    """
-
-    def __init__(self):
-        super().__init__("lv_scr_act()", lv_obj_t, ())
-
-    async def to_code(self, w, config: dict):
-        return []
-
-
 class Widget:
     """
     Represents a Widget.
+    This class has a lot of methods. Adding any more runs foul of lint checks ("too many public methods").
     """
 
     widgets_completed = False
 
-    @staticmethod
-    def set_completed():
-        Widget.widgets_completed = True
-
     def __init__(self, var, wtype: WidgetType, config: dict = None):
         self.var = var
         self.type = wtype
@@ -179,9 +164,20 @@ class Widget:
 
     def get_value(self):
         if isinstance(self.type.w_type, LvType):
-            return self.type.w_type.value(self)
+            result = self.type.w_type.value(self)
+            if isinstance(result, list):
+                return result[0]
+            return result
         return self.obj
 
+    def get_values(self):
+        if isinstance(self.type.w_type, LvType):
+            result = self.type.w_type.value(self)
+            if isinstance(result, list):
+                return result
+            return [result]
+        return [self.obj]
+
     def get_number_value(self):
         value = self.type.mock_obj.get_value(self.obj)
         if self.scale == 1.0:
@@ -213,6 +209,25 @@ class Widget:
 widget_map: dict[Any, Widget] = {}
 
 
+class LvScrActType(WidgetType):
+    """
+    A "widget" representing the active screen.
+    """
+
+    def __init__(self):
+        super().__init__("lv_scr_act()", lv_obj_t, ())
+
+    async def to_code(self, w, config: dict):
+        return []
+
+
+lv_scr_act_spec = LvScrActType()
+
+
+def get_scr_act(lv_comp: MockObj) -> Widget:
+    return Widget.create(None, lv_comp.get_scr_act(), lv_scr_act_spec, {})
+
+
 def get_widget_generator(wid):
     """
     Used to wait for a widget during code generation.
@@ -443,7 +458,3 @@ async def widget_to_code(w_cnfig, w_type: WidgetType, parent):
     await set_obj_properties(w, w_cnfig)
     await add_widgets(w, w_cnfig)
     await spec.to_code(w, w_cnfig)
-
-
-lv_scr_act_spec = LvScrActType()
-lv_scr_act = Widget.create(None, literal("lv_scr_act()"), lv_scr_act_spec, {})