add use-vendored-config feature

Without that, I got the following error from cargo:
```
error: target `demo` in package `lvgl` requires the features: `alloc`
Consider enabling them by passing, e.g., `--features="alloc"`
```

.github/workflows/rust.yml

@@ -30,5 +30,4 @@ jobs:
         run: cargo build --verbose
 
       - name: Run tests
-        # LVGL is not thread safe, we need to run tests sequentially
+        run: cargo test --verbose
-        run: cargo test --verbose -- --nocapture --test-threads 1

README.md

@@ -1,3 +1,5 @@
+[![SWUbanner](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://github.com/vshymanskyy/StandWithUkraine/blob/main/docs/README.md)
+
 <h1 align="center"> LVGL - Open-source Embedded GUI Library in Rust</h1>
 
 ![Original LVGL demo image](lv_demo.png)
@@ -86,7 +88,7 @@ $ git submodule update
 Then run the `demo` example:
 
 ```shell
-$ DEP_LV_CONFIG_PATH=`pwd`/examples/include cargo run --example demo
+$ DEP_LV_CONFIG_PATH=`pwd`/examples/include cargo run --example demo --features="alloc"
 ```
 
 ## Feature Support

examples/app.rs

@@ -1,40 +0,0 @@
-use embedded_graphics::pixelcolor::Rgb565;
-use embedded_graphics::prelude::*;
-use embedded_graphics_simulator::{OutputSettingsBuilder, SimulatorDisplay, Window};
-use lvgl;
-use lvgl::widgets::Label;
-use lvgl::{Display, DrawBuffer};
-use parking_lot::Mutex;
-use std::cell::RefCell;
-use std::sync::Arc;
-
-type ColorSpace = Rgb565;
-
-fn main() {
-    let embedded_graphics_display: SimulatorDisplay<ColorSpace> = SimulatorDisplay::new(Size::new(
-        lvgl::DISP_HOR_RES as u32,
-        lvgl::DISP_VER_RES as u32,
-    ));
-
-    let output_settings = OutputSettingsBuilder::new().scale(2).build();
-    let mut window = Window::new("App Example", &output_settings);
-
-    let mut shared_native_display = Arc::new(Mutex::new(embedded_graphics_display));
-
-    // LVGL usage
-    lvgl::init();
-
-    const REFRESH_BUFFER_SIZE: usize = lvgl::DISP_HOR_RES * lvgl::DISP_VER_RES / 10;
-    static DRAW_BUFFER: DrawBuffer<REFRESH_BUFFER_SIZE> = DrawBuffer::new();
-
-    let display = Display::register(&DRAW_BUFFER, {
-        let shared_display = Arc::clone(&shared_native_display);
-        move |update| {
-            let mut embedded_graphics_display = shared_display.lock();
-            embedded_graphics_display.draw_iter(update.as_pixels());
-        }
-    })
-    .unwrap();
-
-    let label: Label = "Nice!".into();
-}

examples/arc.rs

@@ -4,16 +4,12 @@ use embedded_graphics::prelude::*;
 use embedded_graphics_simulator::{
     OutputSettingsBuilder, SimulatorDisplay, SimulatorEvent, Window,
 };
-use lvgl::display::Display;
 use lvgl::style::Style;
 use lvgl::widgets::{Arc, Label, LabelAlign};
-use lvgl::{self, Align, Color, Part, State};
+use lvgl::{self, Align, Color, Part, State, UI};
 use lvgl::{LvError, Widget};
 use lvgl_sys;
-use parking_lot::Mutex;
+use std::time::Instant;
-use std::sync::Arc as SyncArc;
-use std::thread;
-use std::time::{Duration, Instant};
 
 fn mem_info() -> lvgl_sys::lv_mem_monitor_t {
     let mut info = lvgl_sys::lv_mem_monitor_t {
@@ -40,9 +36,7 @@ fn main() -> Result<(), LvError> {
 }
 
 fn run_arc_demo() -> Result<(), LvError> {
-    lvgl::init();
+    let display: SimulatorDisplay<Rgb565> = SimulatorDisplay::new(Size::new(
-
-    let embedded_graphics_display: SimulatorDisplay<Rgb565> = SimulatorDisplay::new(Size::new(
         lvgl_sys::LV_HOR_RES_MAX,
         lvgl_sys::LV_VER_RES_MAX,
     ));
@@ -50,60 +44,52 @@ fn run_arc_demo() -> Result<(), LvError> {
     let output_settings = OutputSettingsBuilder::new().scale(2).build();
     let mut window = Window::new("Arc Example", &output_settings);
 
-    let shared_native_display = SyncArc::new(Mutex::new(embedded_graphics_display));
+    let mut ui = UI::init()?;
-    let display = Display::register_shared(&shared_native_display)?;
 
-    let mut screen = display.get_str_act()?;
+    // Implement and register your display:
+    ui.disp_drv_register(display)?;
+
+    // Create screen and widgets
+    let mut screen = ui.scr_act()?;
 
     let mut screen_style = Style::default();
     screen_style.set_bg_color(State::DEFAULT, Color::from_rgb((255, 255, 255)));
     screen_style.set_radius(State::DEFAULT, 0);
-    screen.add_style(Part::Main, &mut screen_style)?;
+    screen.add_style(Part::Main, screen_style)?;
 
     // Create the arc object
-    let mut arc = Arc::new()?;
+    let mut arc = Arc::new(&mut screen)?;
     arc.set_size(150, 150)?;
     arc.set_align(&mut screen, Align::Center, 0, 10)?;
     arc.set_start_angle(135)?;
     arc.set_end_angle(135)?;
 
-    let mut loading_lbl = Label::new()?;
+    let mut loading_lbl = Label::new(&mut screen)?;
     loading_lbl.set_text(CString::new("Loading...").unwrap().as_c_str())?;
     loading_lbl.set_align(&mut arc, Align::OutTopMid, 0, -10)?;
     loading_lbl.set_label_align(LabelAlign::Center)?;
 
     let mut loading_style = Style::default();
     loading_style.set_text_color(State::DEFAULT, Color::from_rgb((0, 0, 0)));
-    loading_lbl.add_style(Part::Main, &mut loading_style)?;
+    loading_lbl.add_style(Part::Main, loading_style)?;
 
     let mut angle = 0;
     let mut forward = true;
     let mut i = 0;
 
-    // LVGL timer thread
+    let mut loop_started = Instant::now();
-    thread::spawn(|| {
-        let interval = Duration::from_millis(5);
-        loop {
-            thread::sleep(interval);
-            lvgl::tick_inc(interval);
-        }
-    });
-
     'running: loop {
         if i > 270 {
             forward = if forward { false } else { true };
             i = 1;
-            println!("mem info running: {:?}", mem_info());
+            println!("meminfo running: {:?}", mem_info());
         }
         angle = if forward { angle + 1 } else { angle - 1 };
         arc.set_end_angle(angle + 135)?;
         i += 1;
 
-        lvgl::task_handler();
+        ui.task_handler();
-        {
+        window.update(ui.get_display_ref().unwrap());
-            let eg_display = shared_native_display.lock();
-            window.update(&eg_display);
-        }
 
         for event in window.events() {
             match event {
@@ -111,7 +97,9 @@ fn run_arc_demo() -> Result<(), LvError> {
                 _ => {}
             }
         }
-        thread::sleep(Duration::from_millis(15));
+
+        ui.tick_inc(loop_started.elapsed());
+        loop_started = Instant::now();
     }
 
     Ok(())

examples/demo.rs

@@ -1,5 +1,4 @@
 use cstr_core::CString;
-use embedded_graphics::drawable;
 use embedded_graphics::pixelcolor::Rgb565;
 use embedded_graphics::prelude::*;
 use embedded_graphics_simulator::{
@@ -8,91 +7,61 @@ use embedded_graphics_simulator::{
 use lvgl;
 use lvgl::style::Style;
 use lvgl::widgets::{Label, LabelAlign};
-use lvgl::{Align, Color, DefaultDisplay, Display, DrawBuffer, LvError, Part, State, Widget};
+use lvgl::{Align, Color, LvError, Part, State, Widget, UI};
 use lvgl_sys;
-use parking_lot::Mutex;
-use std::sync::Arc as SyncArc;
-use std::thread;
 use std::thread::sleep;
 use std::time::{Duration, Instant};
 
 fn main() -> Result<(), LvError> {
-    let embedded_graphics_display: SimulatorDisplay<Rgb565> = SimulatorDisplay::new(Size::new(
+    let display: SimulatorDisplay<Rgb565> = SimulatorDisplay::new(Size::new(
-        lvgl::DISP_HOR_RES as u32,
+        lvgl_sys::LV_HOR_RES_MAX,
-        lvgl::DISP_VER_RES as u32,
+        lvgl_sys::LV_VER_RES_MAX,
     ));
 
-    let output_settings = OutputSettingsBuilder::new().scale(1).build();
+    let output_settings = OutputSettingsBuilder::new().scale(2).build();
     let mut window = Window::new("PineTime", &output_settings);
 
-    let shared_native_display = SyncArc::new(Mutex::new(embedded_graphics_display));
+    let mut ui = UI::init()?;
 
-    // LVGL-rs usage starts here
+    // Implement and register your display:
-    lvgl::init();
+    ui.disp_drv_register(display).unwrap();
-
-    // LVGL will render the graphics here first, and seed the rendered image to the
-    // display. The buffer size can be set freely but 1/10 screen size is a good starting point.
-    const REFRESH_BUFFER_SIZE: usize = lvgl::DISP_HOR_RES * lvgl::DISP_VER_RES / 10;
-    static DRAW_BUFFER: DrawBuffer<REFRESH_BUFFER_SIZE> = DrawBuffer::new();
-    //
-    // const NUMBER_OF_DISPLAYS: usize = 1;
-    // static DISPLAY_REGISTRY: DisplayRegistry<NUMBER_OF_DISPLAYS> = DisplayRegistry::empty();
-    // // static DISPLAY_REGISTRY: SingleDisplayRegistry = DisplayRegistry::empty();
-    // let display = DISPLAY_REGISTRY.register_shared(&DRAW_BUFFER, shared_native_display.clone())?;
-
-    // Register your display update callback with LVGL. The closure you pass here will be called
-    // whenever LVGL has updates to be painted to the display.
-    let display = Display::register(&DRAW_BUFFER, {
-        let shared_disp_inner = SyncArc::clone(&shared_native_display);
-        move |update| {
-            let mut em_disp = shared_disp_inner.lock();
-            em_disp.draw_iter(update.as_pixels());
-        }
-    })?;
 
     // Create screen and widgets
-    let mut screen = display.get_scr_act()?;
+    let mut screen = ui.scr_act()?;
-
-    println!("Before all widgets: {:?}", mem_info());
 
     let mut screen_style = Style::default();
     screen_style.set_bg_color(State::DEFAULT, Color::from_rgb((0, 0, 0)));
     screen_style.set_radius(State::DEFAULT, 0);
-    screen.add_style(Part::Main, &mut screen_style)?;
+    screen.add_style(Part::Main, screen_style)?;
 
-    let mut time = Label::from("20:46");
+    let mut time = Label::new(&mut screen)?;
     let mut style_time = Style::default();
-    // style_time.set_text_font(font_noto_sans_numeric_28);
+    //style_time.set_text_font(font_noto_sans_numeric_28);
     style_time.set_text_color(State::DEFAULT, Color::from_rgb((255, 255, 255)));
-    time.add_style(Part::Main, &mut style_time)?;
+    time.add_style(Part::Main, style_time)?;
     time.set_align(&mut screen, Align::Center, 0, 0)?;
+    time.set_text(CString::new("20:46").unwrap().as_c_str())?;
     time.set_width(240)?;
     time.set_height(240)?;
 
-    let mut bt = Label::from("#5794f2 \u{F293}#");
+    let mut bt = Label::new(&mut screen)?;
     bt.set_width(50)?;
     bt.set_height(80)?;
     bt.set_recolor(true)?;
+    bt.set_text(CString::new("#5794f2 \u{F293}#").unwrap().as_c_str())?;
     bt.set_label_align(LabelAlign::Left)?;
     bt.set_align(&mut screen, Align::InTopLeft, 0, 0)?;
 
-    let mut power: Label = "#fade2a 20%#".into();
+    let mut power = Label::new(&mut screen)?;
     power.set_recolor(true)?;
     power.set_width(80)?;
     power.set_height(20)?;
+    power.set_text(CString::new("#fade2a 20%#").unwrap().as_c_str())?;
     power.set_label_align(LabelAlign::Right)?;
     power.set_align(&mut screen, Align::InTopRight, 0, 0)?;
 
-    // LVGL timer thread
-    thread::spawn(|| {
-        let interval = Duration::from_millis(5);
-        loop {
-            thread::sleep(interval);
-            lvgl::tick_inc(interval);
-        }
-    });
-
     let mut i = 0;
+    let mut loop_started = Instant::now();
     'running: loop {
         if i > 59 {
             i = 0;
@@ -101,11 +70,8 @@ fn main() -> Result<(), LvError> {
         time.set_text(&val)?;
         i = 1 + i;
 
-        lvgl::task_handler();
+        ui.task_handler();
-        {
+        window.update(ui.get_display_ref().unwrap());
-            let native_display = shared_native_display.lock();
-            window.update(&native_display);
-        }
 
         for event in window.events() {
             match event {
@@ -113,11 +79,11 @@ fn main() -> Result<(), LvError> {
                 _ => {}
             }
         }
-        println!("During run: {:?}", mem_info());
         sleep(Duration::from_secs(1));
-    }
 
-    println!("Final part of demo app: {:?}", mem_info());
+        ui.tick_inc(loop_started.elapsed());
+        loop_started = Instant::now();
+    }
 
     Ok(())
 }
@@ -133,20 +99,3 @@ fn main() -> Result<(), LvError> {
 extern "C" {
     pub static mut noto_sans_numeric_80: lvgl_sys::lv_font_t;
 }
-
-fn mem_info() -> lvgl_sys::lv_mem_monitor_t {
-    let mut info = lvgl_sys::lv_mem_monitor_t {
-        total_size: 0,
-        free_cnt: 0,
-        free_size: 0,
-        free_biggest_size: 0,
-        used_cnt: 0,
-        max_used: 0,
-        used_pct: 0,
-        frag_pct: 0,
-    };
-    unsafe {
-        lvgl_sys::lv_mem_monitor(&mut info as *mut _);
-    }
-    info
-}

examples/include/lv_conf.h

@@ -1,6 +1,6 @@
 /**
  * @file lv_conf.h
- * Configuration file for v7.10.1
+ *
  */
 
 /*
@@ -80,9 +80,9 @@ typedef int16_t lv_coord_t;
 #define LV_MEM_CUSTOM      0
 #if LV_MEM_CUSTOM == 0
 /* Size of the memory used by `lv_mem_alloc` in bytes (>= 2kB)*/
-#  define LV_MEM_SIZE    (14U * 1024U)
+#  define LV_MEM_SIZE    (1048576U) // 1Mb
 
-/* Compiler prefix for a big array declaration */
+/* Complier prefix for a big array declaration */
 #  define LV_MEM_ATTR
 
 /* Set an address for the memory pool instead of allocating it as an array.
@@ -97,10 +97,6 @@ typedef int16_t lv_coord_t;
 #  define LV_MEM_CUSTOM_FREE    free         /*Wrapper to free*/
 #endif     /*LV_MEM_CUSTOM*/
 
-/* Use the standard memcpy and memset instead of LVGL's own functions.
- * The standard functions might or might not be faster depending on their implementation. */
-#define LV_MEMCPY_MEMSET_STD    0
-
 /* Garbage Collector settings
  * Used if lvgl is binded to higher level language and the memory is managed by that language */
 #define LV_ENABLE_GC 0
@@ -127,13 +123,14 @@ typedef int16_t lv_coord_t;
 #define LV_INDEV_DEF_DRAG_THROW           10
 
 /* Long press time in milliseconds.
- * Time to send `LV_EVENT_LONG_PRESSED`) */
+ * Time to send `LV_EVENT_LONG_PRESSSED`) */
 #define LV_INDEV_DEF_LONG_PRESS_TIME      400
 
 /* Repeated trigger period in long press [ms]
  * Time between `LV_EVENT_LONG_PRESSED_REPEAT */
 #define LV_INDEV_DEF_LONG_PRESS_REP_TIME  100
 
+
 /* Gesture threshold in pixels */
 #define LV_INDEV_DEF_GESTURE_LIMIT        50
 
@@ -153,7 +150,7 @@ typedef void * lv_anim_user_data_t;
 
 #endif
 
-/* 1: Enable shadow drawing on rectangles*/
+/* 1: Enable shadow drawing*/
 #define LV_USE_SHADOW           1
 #if LV_USE_SHADOW
 /* Allow buffering some shadow calculation
@@ -163,15 +160,6 @@ typedef void * lv_anim_user_data_t;
 #define LV_SHADOW_CACHE_SIZE    0
 #endif
 
-/*1: enable outline drawing on rectangles*/
-#define LV_USE_OUTLINE  1
-
-/*1: enable pattern drawing on rectangles*/
-#define LV_USE_PATTERN  1
-
-/*1: enable value string drawing on rectangles*/
-#define LV_USE_VALUE_STR    1
-
 /* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
 #define LV_USE_BLEND_MODES      1
 
@@ -190,22 +178,6 @@ typedef void * lv_group_user_data_t;
 /* 1: Enable GPU interface*/
 #define LV_USE_GPU              1   /*Only enables `gpu_fill_cb` and `gpu_blend_cb` in the disp. drv- */
 #define LV_USE_GPU_STM32_DMA2D  0
-/*If enabling LV_USE_GPU_STM32_DMA2D, LV_GPU_DMA2D_CMSIS_INCLUDE must be defined to include path of CMSIS header of target processor
-e.g. "stm32f769xx.h" or "stm32f429xx.h" */
-#define LV_GPU_DMA2D_CMSIS_INCLUDE
-
-/*1: Use PXP for CPU off-load on NXP RTxxx platforms */
-#define LV_USE_GPU_NXP_PXP      0
-
-/*1: Add default bare metal and FreeRTOS interrupt handling routines for PXP (lv_gpu_nxp_pxp_osa.c)
- *   and call lv_gpu_nxp_pxp_init() automatically during lv_init(). Note that symbol FSL_RTOS_FREE_RTOS
- *   has to be defined in order to use FreeRTOS OSA, otherwise bare-metal implementation is selected.
- *0: lv_gpu_nxp_pxp_init() has to be called manually before lv_init()
- * */
-#define LV_USE_GPU_NXP_PXP_AUTO_INIT 0
-
-/*1: Use VG-Lite for CPU offload on NXP RTxxx platforms */
-#define LV_USE_GPU_NXP_VG_LITE   0
 
 /* 1: Enable file system (might be required for images */
 #define LV_USE_FILESYSTEM       1
@@ -222,7 +194,6 @@ typedef void * lv_fs_drv_user_data_t;
 
 /*1: Use the functions and types from the older API if possible */
 #define LV_USE_API_EXTENSION_V6  1
-#define LV_USE_API_EXTENSION_V7  1
 
 /*========================
  * Image decoder and cache
@@ -239,7 +210,7 @@ typedef void * lv_fs_drv_user_data_t;
  * (I.e. no new image decoder is added)
  * With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images.
  * However the opened images might consume additional RAM.
- * Set it to 0 to disable caching */
+ * LV_IMG_CACHE_DEF_SIZE must be >= 1 */
 #define LV_IMG_CACHE_DEF_SIZE       1
 
 /*Declare the type of the user data of image decoder (can be e.g. `void *`, `int`, `struct`)*/
@@ -248,10 +219,6 @@ typedef void * lv_img_decoder_user_data_t;
 /*=====================
  *  Compiler settings
  *====================*/
-
-/* For big endian systems set to 1 */
-#define LV_BIG_ENDIAN_SYSTEM    0
-
 /* Define a custom attribute to `lv_tick_inc` function */
 #define LV_ATTRIBUTE_TICK_INC
 
@@ -261,14 +228,9 @@ typedef void * lv_img_decoder_user_data_t;
 /* Define a custom attribute to `lv_disp_flush_ready` function */
 #define LV_ATTRIBUTE_FLUSH_READY
 
-/* Required alignment size for buffers */
-#define LV_ATTRIBUTE_MEM_ALIGN_SIZE
-
 /* With size optimization (-Os) the compiler might not align data to
- * 4 or 8 byte boundary. Some HW may need even 32 or 64 bytes.
+ * 4 or 8 byte boundary. This alignment will be explicitly applied where needed.
- * This alignment will be explicitly applied where needed.
+ * E.g. __attribute__((aligned(4))) */
- * LV_ATTRIBUTE_MEM_ALIGN_SIZE should be used to specify required align size.
- * E.g. __attribute__((aligned(LV_ATTRIBUTE_MEM_ALIGN_SIZE))) */
 #define LV_ATTRIBUTE_MEM_ALIGN
 
 /* Attribute to mark large constant arrays for example
@@ -287,10 +249,6 @@ typedef void * lv_img_decoder_user_data_t;
  */
 #define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning
 
-/* Prefix variables that are used in GPU accelerated operations, often these need to be
- * placed in RAM sections that are DMA accessible */
-#define LV_ATTRIBUTE_DMA
-
 /*===================
  *  HAL settings
  *==================*/
@@ -299,8 +257,8 @@ typedef void * lv_img_decoder_user_data_t;
  * It removes the need to manually update the tick with `lv_tick_inc`) */
 #define LV_TICK_CUSTOM     0
 #if LV_TICK_CUSTOM == 1
-#define LV_TICK_CUSTOM_INCLUDE  "Arduino.h"         /*Header for the system time function*/
+#define LV_TICK_CUSTOM_INCLUDE  "something.h"       /*Header for the sys time function*/
-#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current system time in ms*/
+#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current systime in ms*/
 #endif   /*LV_TICK_CUSTOM*/
 
 typedef void * lv_disp_drv_user_data_t;             /*Type of user data in the display driver*/
@@ -335,7 +293,7 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
  * If an invalid parameter is found an error log message is printed and
  * the MCU halts at the error. (`LV_USE_LOG` should be enabled)
  * If you are debugging the MCU you can pause
- * the debugger to see exactly where the issue is.
+ * the debugger to see exactly where  the issue is.
  *
  * The behavior of asserts can be overwritten by redefining them here.
  * E.g. #define LV_ASSERT_MEM(p)  <my_assert_code>
@@ -370,19 +328,17 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
  *    FONT USAGE
  *===================*/
 
-/* The built-in fonts contains the ASCII range and some Symbols with 4 bit-per-pixel.
+/* The built-in fonts contains the ASCII range and some Symbols with  4 bit-per-pixel.
  * The symbols are available via `LV_SYMBOL_...` defines
- * More info about fonts: https://docs.lvgl.io/v7/en/html/overview/font.html
+ * More info about fonts: https://docs.lvgl.com/#Fonts
  * To create a new font go to: https://lvgl.com/ttf-font-to-c-array
  */
 
 /* Montserrat fonts with bpp = 4
  * https://fonts.google.com/specimen/Montserrat  */
-#define LV_FONT_MONTSERRAT_8     0
-#define LV_FONT_MONTSERRAT_10    0
 #define LV_FONT_MONTSERRAT_12    0
-#define LV_FONT_MONTSERRAT_14    1
+#define LV_FONT_MONTSERRAT_14    0
-#define LV_FONT_MONTSERRAT_16    0
+#define LV_FONT_MONTSERRAT_16    1
 #define LV_FONT_MONTSERRAT_18    0
 #define LV_FONT_MONTSERRAT_20    0
 #define LV_FONT_MONTSERRAT_22    0
@@ -409,7 +365,6 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
 /*Pixel perfect monospace font
  * http://pelulamu.net/unscii/ */
 #define LV_FONT_UNSCII_8     0
-#define LV_FONT_UNSCII_16     0
 
 /* Optionally declare your custom fonts here.
  * You can use these fonts as default font too
@@ -424,20 +379,11 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
  * but with > 10,000 characters if you see issues probably you need to enable it.*/
 #define LV_FONT_FMT_TXT_LARGE   0
 
-/* Enables/disables support for compressed fonts. If it's disabled, compressed
- * glyphs cannot be processed by the library and won't be rendered.
- */
-#define LV_USE_FONT_COMPRESSED 1
-
-/* Enable subpixel rendering */
-#define LV_USE_FONT_SUBPX 1
-#if LV_USE_FONT_SUBPX
 /* Set the pixel order of the display.
  * Important only if "subpx fonts" are used.
  * With "normal" font it doesn't matter.
  */
 #define LV_FONT_SUBPX_BGR    0
-#endif
 
 /*Declare the type of the user data of fonts (can be e.g. `void *`, `int`, `struct`)*/
 typedef void * lv_font_user_data_t;
@@ -450,37 +396,34 @@ typedef void * lv_font_user_data_t;
 
 /* No theme, you can apply your styles as you need
  * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
-#define LV_USE_THEME_EMPTY       1
+ #define LV_USE_THEME_EMPTY       1
 
 /*Simple to the create your theme based on it
  * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
-#define LV_USE_THEME_TEMPLATE    1
+ #define LV_USE_THEME_TEMPLATE    1
 
 /* A fast and impressive theme.
  * Flags:
  * LV_THEME_MATERIAL_FLAG_LIGHT: light theme
- * LV_THEME_MATERIAL_FLAG_DARK: dark theme
+ * LV_THEME_MATERIAL_FLAG_DARK: dark theme*/
- * LV_THEME_MATERIAL_FLAG_NO_TRANSITION: disable transitions (state change animations)
+ #define LV_USE_THEME_MATERIAL    1
- * LV_THEME_MATERIAL_FLAG_NO_FOCUS: disable indication of focused state)
- * */
-#define LV_USE_THEME_MATERIAL    1
 
 /* Mono-color theme for monochrome displays.
  * If LV_THEME_DEFAULT_COLOR_PRIMARY is LV_COLOR_BLACK the
  * texts and borders will be black and the background will be
  * white. Else the colors are inverted.
  * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
-#define LV_USE_THEME_MONO        1
+ #define LV_USE_THEME_MONO        1
 
 #define LV_THEME_DEFAULT_INCLUDE            <stdint.h>      /*Include a header for the init. function*/
 #define LV_THEME_DEFAULT_INIT               lv_theme_material_init
-#define LV_THEME_DEFAULT_COLOR_PRIMARY      lv_color_hex(0x01a2b1)
+#define LV_THEME_DEFAULT_COLOR_PRIMARY      LV_COLOR_RED
-#define LV_THEME_DEFAULT_COLOR_SECONDARY    lv_color_hex(0x44d1b6)
+#define LV_THEME_DEFAULT_COLOR_SECONDARY    LV_COLOR_BLUE
 #define LV_THEME_DEFAULT_FLAG               LV_THEME_MATERIAL_FLAG_LIGHT
-#define LV_THEME_DEFAULT_FONT_SMALL         &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_SMALL         &lv_font_montserrat_16
-#define LV_THEME_DEFAULT_FONT_NORMAL        &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_NORMAL        &lv_font_montserrat_16
-#define LV_THEME_DEFAULT_FONT_SUBTITLE      &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_SUBTITLE      &lv_font_montserrat_16
-#define LV_THEME_DEFAULT_FONT_TITLE         &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_TITLE         &lv_font_montserrat_16
 
 /*=================
  *  Text settings
@@ -513,7 +456,7 @@ typedef void * lv_font_user_data_t;
 
 /* Support bidirectional texts.
  * Allows mixing Left-to-Right and Right-to-Left texts.
- * The direction will be processed according to the Unicode Bidirectional Algorithm:
+ * The direction will be processed according to the Unicode Bidirectioanl Algorithm:
  * https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/
 #define LV_USE_BIDI     0
 #if LV_USE_BIDI
@@ -555,7 +498,7 @@ typedef void * lv_obj_user_data_t;
 #endif
 #endif
 
-/*1: enable `lv_obj_realign()` based on `lv_obj_align()` parameters*/
+/*1: enable `lv_obj_realaign()` based on `lv_obj_align()` parameters*/
 #define LV_USE_OBJ_REALIGN          1
 
 /* Enable to make the object clickable on a larger area.
@@ -586,9 +529,6 @@ typedef void * lv_obj_user_data_t;
 
 /*Calendar (dependencies: -)*/
 #define LV_USE_CALENDAR 1
-#if LV_USE_CALENDAR
-#  define LV_CALENDAR_WEEK_STARTS_MONDAY    0
-#endif
 
 /*Canvas (dependencies: lv_img)*/
 #define LV_USE_CANVAS   1
@@ -673,7 +613,7 @@ typedef void * lv_obj_user_data_t;
  * 1: Some extra precision
  * 2: Best precision
  */
-#  define LV_LINEMETER_PRECISE    1
+#  define LV_LINEMETER_PRECISE    0
 #endif
 
 /*Mask (dependencies: -)*/
@@ -727,7 +667,6 @@ typedef void * lv_obj_user_data_t;
 #define LV_USE_TABLE    1
 #if LV_USE_TABLE
 #  define LV_TABLE_COL_MAX    12
-#  define LV_TABLE_CELL_STYLE_CNT 4
 #endif
 
 /*Tab (dependencies: lv_page, lv_btnm)*/

lvgl-codegen/src/analysis.rs

@@ -1,66 +0,0 @@
-/// A parameter of C functions.
-///
-/// This struct represents all relevant information we can extract from the C function declaration
-/// of a LVGL public interface. We can use this information to do inference for how the parameter
-/// should be represented in a safe Rust API.
-#[derive(Clone, Debug)]
-pub struct CParameter {
-    /// The name of the parameter in the C code.
-    pub name: String,
-
-    /// This is the raw representation of the Rust equivalent of the C type.
-    pub c_type: String,
-
-    /// Takes a pointer to a type that is referenced by the LVGL code permanently.
-    pub scope: ParameterScope,
-
-    /// The pointer is not marked as `*const` so the referenced object can be mutated.
-    pub mutable: bool,
-
-    /// We need to check if the value is optional in the C code. We need to check
-    /// the function comments for this information.
-    ///     - "if NULL then"
-    ///     - "if not NULL then"
-    ///     - "NULL to"
-    pub allow_none: bool,
-
-    /// Comment associated with the parameter, if exists.
-    pub comment: Option<String>,
-}
-
-#[derive(Clone, Debug)]
-pub enum ParameterScope {
-    Call,
-    Static,
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum FunctionKind {
-    Constructor,
-    Method,
-    Function,
-}
-
-/// Inference from a LVGL C API function.
-#[derive(Clone, Debug)]
-pub struct Function {
-    /// Name of the function in the LVGL C API.
-    pub name: String,
-
-    /// Comment associated with the function, if exists.
-    pub comment: Option<String>,
-
-    pub kind: FunctionKind,
-
-    pub parameters: Vec<CParameter>,
-
-    pub ret: Return,
-}
-
-#[derive(Clone, Debug)]
-pub enum Return {
-    Value(Option<CParameter>),
-
-    /// If the return is a LVGL result
-    ResultError(CParameter),
-}

lvgl-codegen/src/lib.rs

@@ -1,5 +1,3 @@
-mod analysis;
-
 use inflector::cases::pascalcase::to_pascal_case;
 use lazy_static::lazy_static;
 use proc_macro2::{Ident, TokenStream};
@@ -46,12 +44,6 @@ pub struct LvWidget {
     methods: Vec<LvFunc>,
 }
 
-impl LvWidget {
-    fn pascal_name(&self) -> String {
-        to_pascal_case(&self.name)
-    }
-}
-
 impl Rusty for LvWidget {
     type Parent = ();
 
@@ -61,7 +53,7 @@ impl Rusty for LvWidget {
             return Err(WrapperError::Skip);
         }
 
-        let widget_name = format_ident!("{}", self.pascal_name());
+        let widget_name = format_ident!("{}", to_pascal_case(self.name.as_str()));
         let methods: Vec<TokenStream> = self.methods.iter().flat_map(|m| m.code(self)).collect();
         Ok(quote! {
             define_object!(#widget_name);
@@ -98,7 +90,6 @@ impl Rusty for LvFunc {
     type Parent = LvWidget;
 
     fn code(&self, parent: &Self::Parent) -> WrapperResult<TokenStream> {
-        let widget_name = format_ident!("{}", parent.pascal_name());
         let templ = format!("{}{}_", LIB_PREFIX, parent.name.as_str());
         let new_name = self.name.replace(templ.as_str(), "");
         let func_name = format_ident!("{}", new_name);
@@ -108,12 +99,12 @@ impl Rusty for LvFunc {
         if new_name.as_str().eq("create") {
             return Ok(quote! {
 
-                pub fn create(parent: &mut impl crate::NativeObject, copy: Option<&#widget_name>) -> crate::LvResult<Self> {
+                pub fn new<C>(parent: &mut C) -> crate::LvResult<Self>
+                where
+                    C: crate::NativeObject,
+                {
                     unsafe {
-                        let ptr = lvgl_sys::#original_func_name(
+                        let ptr = lvgl_sys::#original_func_name(parent.raw()?.as_mut(), core::ptr::null_mut());
-                            parent.raw()?.as_mut(),
-                            copy.map(|c| c.raw().unwrap().as_mut() as *mut lvgl_sys::lv_obj_t).unwrap_or(core::ptr::null_mut() as *mut lvgl_sys::lv_obj_t),
-                        );
                         if let Some(raw) = core::ptr::NonNull::new(ptr) {
                             let core = <crate::Obj as crate::Widget>::from_raw(raw);
                             Ok(Self { core })
@@ -123,15 +114,6 @@ impl Rusty for LvFunc {
                     }
                 }
 
-                pub fn create_at(parent: &mut impl crate::NativeObject) -> crate::LvResult<Self> {
-                    Ok(Self::create(parent, None)?)
-                }
-
-                pub fn new() -> crate::LvResult<Self> {
-                    let mut parent = crate::display::DefaultDisplay::get_scr_act()?;
-                    Ok(Self::create_at(&mut parent)?)
-                }
-
             });
         }
 
@@ -321,21 +303,21 @@ impl Rusty for LvArg {
 #[derive(Clone)]
 pub struct LvType {
     literal_name: String,
-    r_type: Option<Box<syn::Type>>,
+    _r_type: Option<Box<syn::Type>>,
 }
 
 impl LvType {
     pub fn new(literal_name: String) -> Self {
         Self {
             literal_name,
-            r_type: None,
+            _r_type: None,
         }
     }
 
     pub fn from(r_type: Box<syn::Type>) -> Self {
         Self {
             literal_name: r_type.to_token_stream().to_string(),
-            r_type: Some(r_type),
+            _r_type: Some(r_type),
         }
     }
 
@@ -356,9 +338,6 @@ impl Rusty for LvType {
             Some(name) => {
                 let val = if self.is_str() {
                     quote!(&cstr_core::CStr)
-                } else if self.literal_name.contains("lv_") {
-                    let ident = format_ident!("{}", name);
-                    quote!(&#ident)
                 } else {
                     let ident = format_ident!("{}", name);
                     quote!(#ident)
@@ -652,12 +631,13 @@ mod test {
             define_object!(Arc);
 
             impl Arc {
-                pub fn create(parent: &mut impl crate::NativeObject, copy: Option<&Arc>) -> crate::LvResult<Self> {
+                pub fn new<C>(parent: &mut C) -> crate::LvResult<Self>
+                where
+                    C: crate::NativeObject,
+                {
+
                     unsafe {
-                        let ptr = lvgl_sys::lv_arc_create(
+                        let ptr = lvgl_sys::lv_arc_create(parent.raw()?.as_mut(), core::ptr::null_mut());
-                            parent.raw()?.as_mut(),
-                            copy.map(|c| c.raw().unwrap().as_mut() as *mut lvgl_sys::lv_obj_t).unwrap_or(core::ptr::null_mut() as *mut lvgl_sys::lv_obj_t),
-                        );
                         if let Some(raw) = core::ptr::NonNull::new(ptr) {
                             let core = <crate::Obj as crate::Widget>::from_raw(raw);
                             Ok(Self { core })
@@ -666,15 +646,6 @@ mod test {
                         }
                     }
                 }
-
-                pub fn create_at(parent: &mut impl crate::NativeObject) -> crate::LvResult<Self> {
-                    Ok(Self::create(parent, None)?)
-                }
-
-                pub fn new() -> crate::LvResult<Self> {
-                    let mut parent = crate::display::DefaultDisplay::get_scr_act()?;
-                    Ok(Self::create_at(&mut parent)?)
-                }
             }
         };
 

lvgl-sys/Cargo.toml

@@ -21,4 +21,7 @@ cty = "0.2.1"
 
 [build-dependencies]
 cc = "1.0.68"
-bindgen = "0.58.1"
+bindgen = "0.59.2"
+
+[features]
+use-vendored-config = []

lvgl-sys/build.rs

@@ -4,16 +4,14 @@ use std::{env, path::Path, path::PathBuf};
 static CONFIG_NAME: &str = "DEP_LV_CONFIG_PATH";
 
 fn main() {
-    let project_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap())
+    let project_dir = canonicalize(PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap()));
-        .canonicalize()
-        .unwrap();
     let shims_dir = project_dir.join("shims");
     let vendor = project_dir.join("vendor");
     let vendor_src = vendor.join("lvgl").join("src");
 
     let lv_config_dir = {
         let conf_path = env::var(CONFIG_NAME)
-            .map(|raw_path| PathBuf::from(raw_path))
+            .map(PathBuf::from)
             .unwrap_or_else(|_| {
                 match std::env::var("DOCS_RS") {
                     Ok(_) => {
@@ -21,10 +19,16 @@ fn main() {
                         // so let's use the vendored `lv_conf.h` file.
                         vendor.join("include")
                     }
-                    Err(_) => panic!(
+                    Err(_) => {
-                        "The environment variable {} is required to be defined",
+                        #[cfg(not(feature = "use-vendored-config"))]
-                        CONFIG_NAME
+                        panic!(
-                    ),
+                            "The environment variable {} is required to be defined",
+                            CONFIG_NAME
+                        );
+
+                        #[cfg(feature = "use-vendored-config")]
+                        vendor.join("include")
+                    }
                 }
             });
 
@@ -114,7 +118,6 @@ fn main() {
     let bindings = bindgen::Builder::default()
         .header(shims_dir.join("lvgl_sys.h").to_str().unwrap())
         .generate_comments(false)
-        .derive_default(true)
         .layout_tests(false)
         .use_core()
         .rustfmt_bindings(true)
@@ -140,3 +143,10 @@ fn add_c_files(build: &mut cc::Build, path: impl AsRef<Path>) {
         }
     }
 }
+
+fn canonicalize(path: impl AsRef<Path>) -> PathBuf {
+    let canonicalized = path.as_ref().canonicalize().unwrap();
+    let canonicalized = &*canonicalized.to_string_lossy();
+
+    PathBuf::from(canonicalized.strip_prefix(r"\\?\").unwrap_or(canonicalized))
+}

lvgl/Cargo.toml

@@ -14,16 +14,14 @@ build = "build.rs"
 [dependencies]
 lvgl-sys = { version = "0.5.2", path = "../lvgl-sys" }
 cty = "0.2.1"
+embedded-graphics = "0.7.1"
 cstr_core = "0.2.3"
 bitflags = "1.2.1"
-parking_lot = "0.11.1"
-embedded-graphics = { version = "0.6.2", optional = true }
 
 [features]
-default = []
-embedded_graphics = ["embedded-graphics"]
 alloc = ["cstr_core/alloc"]
 lvgl_alloc = ["alloc"]
+use-vendored-config = ["lvgl-sys/use-vendored-config"]
 
 [build-dependencies]
 quote = "1.0.9"
@@ -32,34 +30,29 @@ lvgl-codegen = { version = "0.5.2", path = "../lvgl-codegen" }
 lvgl-sys = { version = "0.5.2", path = "../lvgl-sys" }
 
 [dev-dependencies]
-embedded-graphics-simulator = "0.2.1"
+embedded-graphics-simulator = "0.3.0"
-
+heapless = "0.7.13"
-[[example]]
-name = "app"
-path = "../examples/app.rs"
-required-features = ["alloc", "embedded_graphics"]
 
 [[example]]
 name = "demo"
 path = "../examples/demo.rs"
-required-features = ["alloc", "embedded_graphics"]
+required-features = ["alloc"]
 
 [[example]]
 name = "bar"
 path = "../examples/bar.rs"
-required-features = ["alloc", "embedded_graphics"]
+required-features = ["alloc"]
 
 [[example]]
 name = "button_click"
 path = "../examples/button_click.rs"
-required-features = ["alloc", "embedded_graphics"]
+required-features = ["alloc"]
 
 [[example]]
 name = "gauge"
 path = "../examples/gauge.rs"
-required-features = ["alloc", "embedded_graphics"]
 
 [[example]]
 name = "arc"
 path = "../examples/arc.rs"
-required-features = ["alloc", "embedded_graphics"]
+required-features = ["lvgl_alloc"]

lvgl/src/allocator.rs

@@ -9,12 +9,12 @@ pub struct LvglAlloc;
 unsafe impl GlobalAlloc for LvglAlloc {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         // Make sure LVGL is initialized!
-        crate::init();
+        crate::lvgl_init();
         lvgl_sys::lv_mem_alloc(layout.size() as lvgl_sys::size_t) as *mut u8
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        crate::init();
+        crate::lvgl_init();
         lvgl_sys::lv_mem_free(ptr as *const cty::c_void)
     }
 }

lvgl/src/display.rs

@@ -1,268 +0,0 @@
-use crate::functions::CoreError;
-use crate::{disp_drv_register, disp_get_default, get_str_act};
-use crate::{Box, RunOnce};
-use crate::{Color, Obj};
-use core::cell::RefCell;
-use core::mem::MaybeUninit;
-use core::ptr::NonNull;
-use core::{ptr, result};
-use parking_lot::const_mutex;
-use parking_lot::Mutex;
-
-pub const DISP_HOR_RES: usize = lvgl_sys::LV_HOR_RES_MAX as usize;
-pub const DISP_VER_RES: usize = lvgl_sys::LV_VER_RES_MAX as usize;
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum DisplayError {
-    NotAvailable,
-    FailedToRegister,
-    NotRegistered,
-}
-
-type Result<T> = result::Result<T, DisplayError>;
-
-pub struct Display {
-    pub(crate) disp: NonNull<lvgl_sys::lv_disp_t>,
-}
-
-impl Display {
-    pub(crate) fn from_raw(disp: NonNull<lvgl_sys::lv_disp_t>) -> Self {
-        Self { disp }
-    }
-
-    pub fn register<F, const N: usize>(
-        draw_buffer: &'static DrawBuffer<N>,
-        display_update: F,
-    ) -> Result<Self>
-    where
-        F: FnMut(&DisplayRefresh<N>) + 'static,
-    {
-        let mut display_diver = DisplayDriver::new(draw_buffer, display_update)?;
-        Ok(disp_drv_register(&mut display_diver)?)
-    }
-
-    pub fn get_scr_act(&self) -> Result<Obj> {
-        Ok(get_str_act(Some(&self))?)
-    }
-}
-
-impl Default for Display {
-    fn default() -> Self {
-        disp_get_default().expect("LVGL must be INITIALIZED")
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct DefaultDisplay {}
-
-impl DefaultDisplay {
-    /// Gets the screen active of the default display.
-    pub fn get_scr_act() -> Result<Obj> {
-        Ok(get_str_act(None)?)
-    }
-}
-
-pub struct DrawBuffer<const N: usize> {
-    initialized: RunOnce,
-    refresh_buffer: Mutex<RefCell<[MaybeUninit<lvgl_sys::lv_color_t>; N]>>,
-}
-
-impl<const N: usize> DrawBuffer<N> {
-    pub const fn new() -> Self {
-        Self {
-            initialized: RunOnce::new(),
-            refresh_buffer: const_mutex(RefCell::new([MaybeUninit::uninit(); N])),
-        }
-    }
-
-    fn get_ptr(&self) -> Option<Box<lvgl_sys::lv_disp_buf_t>> {
-        if self.initialized.swap_and_check() {
-            // TODO: needs to be 'static somehow
-            // Cannot be in the DrawBuffer struct because the type `lv_disp_buf_t` contains a raw
-            // pointer and raw pointers are not Send and consequently cannot be in `static` variables.
-            let mut inner: MaybeUninit<lvgl_sys::lv_disp_buf_t> = MaybeUninit::uninit();
-            let primary_buffer_guard = self.refresh_buffer.lock();
-            let draw_buf = unsafe {
-                lvgl_sys::lv_disp_buf_init(
-                    inner.as_mut_ptr(),
-                    primary_buffer_guard.borrow_mut().as_mut_ptr() as *mut _ as *mut cty::c_void,
-                    ptr::null_mut(),
-                    N as u32,
-                );
-                inner.assume_init()
-            };
-            Some(Box::new(draw_buf))
-        } else {
-            None
-        }
-    }
-}
-
-pub struct DisplayDriver {
-    pub(crate) disp_drv: lvgl_sys::lv_disp_drv_t,
-}
-
-impl DisplayDriver {
-    pub fn new<F, const N: usize>(
-        draw_buffer: &'static DrawBuffer<N>,
-        display_update_callback: F,
-    ) -> Result<Self>
-    where
-        F: FnMut(&DisplayRefresh<N>) + 'static,
-    {
-        let mut disp_drv = unsafe {
-            let mut inner = MaybeUninit::uninit();
-            lvgl_sys::lv_disp_drv_init(inner.as_mut_ptr());
-            inner.assume_init()
-        };
-
-        // Safety: The variable `draw_buffer` is statically allocated, no need to worry about this being dropped.
-        disp_drv.buffer = draw_buffer
-            .get_ptr()
-            .map(|ptr| Box::into_raw(ptr) as *mut _)
-            .ok_or(DisplayError::FailedToRegister)?;
-
-        disp_drv.user_data = Box::into_raw(Box::new(display_update_callback)) as *mut _
-            as lvgl_sys::lv_disp_drv_user_data_t;
-
-        // Sets trampoline pointer to the function implementation that uses the `F` type for a
-        // refresh buffer of size N specifically.
-        disp_drv.flush_cb = Some(disp_flush_trampoline::<F, N>);
-
-        // We do not store any memory that can be accidentally deallocated by on the Rust side.
-        Ok(Self { disp_drv })
-    }
-}
-
-/// Represents a sub-area of the display that is being updated.
-pub struct Area {
-    pub x1: i16,
-    pub x2: i16,
-    pub y1: i16,
-    pub y2: i16,
-}
-
-/// It's a update to the display information, contains the area that is being updated and the color
-/// of the pixels that need to be updated. The colors are represented in a contiguous array.
-pub struct DisplayRefresh<const N: usize> {
-    pub area: Area,
-    pub colors: [Color; N],
-}
-
-#[cfg(feature = "embedded_graphics")]
-mod embedded_graphics_impl {
-    use crate::{Color, DisplayRefresh};
-    use embedded_graphics::drawable;
-    use embedded_graphics::prelude::*;
-
-    impl<const N: usize> DisplayRefresh<N> {
-        pub fn as_pixels<C>(&self) -> impl IntoIterator<Item = drawable::Pixel<C>> + '_
-        where
-            C: PixelColor + From<Color>,
-        {
-            let area = &self.area;
-            let x1 = area.x1;
-            let x2 = area.x2;
-            let y1 = area.y1;
-            let y2 = area.y2;
-
-            let ys = y1..=y2;
-            let xs = (x1..=x2).enumerate();
-            let x_len = (x2 - x1 + 1) as usize;
-
-            // We use iterators here to ensure that the Rust compiler can apply all possible
-            // optimizations at compile time.
-            ys.enumerate()
-                .map(move |(iy, y)| {
-                    xs.clone().map(move |(ix, x)| {
-                        let color_len = x_len * iy + ix;
-                        let raw_color = self.colors[color_len];
-                        drawable::Pixel(Point::new(x as i32, y as i32), raw_color.into())
-                    })
-                })
-                .flatten()
-        }
-    }
-}
-
-unsafe extern "C" fn disp_flush_trampoline<F, const N: usize>(
-    disp_drv: *mut lvgl_sys::lv_disp_drv_t,
-    area: *const lvgl_sys::lv_area_t,
-    color_p: *mut lvgl_sys::lv_color_t,
-) where
-    F: FnMut(&DisplayRefresh<N>) + 'static,
-{
-    let display_driver = *disp_drv;
-    if !display_driver.user_data.is_null() {
-        let callback = &mut *(display_driver.user_data as *mut F);
-
-        let mut colors = [Color::default(); N];
-        let mut color_len = 0;
-        for color in &mut colors {
-            let lv_color = *color_p.add(color_len);
-            *color = Color::from_raw(lv_color);
-            color_len += 1;
-        }
-
-        let update = DisplayRefresh {
-            area: Area {
-                x1: (*area).x1,
-                x2: (*area).x2,
-                y1: (*area).y1,
-                y2: (*area).y2,
-            },
-            colors,
-        };
-        callback(&update);
-    }
-
-    // Indicate to LVGL that we are ready with the flushing
-    lvgl_sys::lv_disp_flush_ready(disp_drv);
-}
-
-impl From<CoreError> for DisplayError {
-    fn from(err: CoreError) -> Self {
-        use DisplayError::*;
-        match err {
-            CoreError::ResourceNotAvailable => NotAvailable,
-            CoreError::OperationFailed => NotAvailable,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::tests;
-
-    #[test]
-    fn get_scr_act_return_display() {
-        tests::initialize_test();
-        let _screen = get_str_act(None).expect("We can get the active screen");
-    }
-
-    #[test]
-    fn get_default_display() {
-        tests::initialize_test();
-        let display = Display::default();
-
-        let _screen_direct = display
-            .get_scr_act()
-            .expect("Return screen directly from the display instance");
-
-        let _screen_default =
-            DefaultDisplay::get_scr_act().expect("Return screen from the default display");
-    }
-
-    #[test]
-    fn register_display_directly() -> Result<()> {
-        tests::initialize_test();
-        let display = Display::default();
-
-        let _screen = display
-            .get_scr_act()
-            .expect("Return screen directly from the display instance");
-
-        Ok(())
-    }
-}

lvgl/src/functions.rs

@@ -1,56 +0,0 @@
-use crate::display::{Display, DisplayDriver};
-use crate::{Obj, Widget};
-use core::ptr::NonNull;
-use core::time::Duration;
-use core::{ptr, result};
-
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum CoreError {
-    ResourceNotAvailable,
-    OperationFailed,
-}
-
-type Result<T> = result::Result<T, CoreError>;
-
-/// Register own buffer
-pub(crate) fn disp_drv_register(disp_drv: &mut DisplayDriver) -> Result<Display> {
-    let disp_ptr = unsafe { lvgl_sys::lv_disp_drv_register(&mut disp_drv.disp_drv as *mut _) };
-    Ok(Display::from_raw(
-        NonNull::new(disp_ptr).ok_or(CoreError::OperationFailed)?,
-    ))
-}
-
-pub(crate) fn disp_get_default() -> Result<Display> {
-    let disp_ptr = unsafe { lvgl_sys::lv_disp_get_default() };
-    Ok(Display::from_raw(
-        NonNull::new(disp_ptr).ok_or(CoreError::OperationFailed)?,
-    ))
-}
-
-pub(crate) fn get_str_act(disp: Option<&Display>) -> Result<Obj> {
-    let scr_ptr = unsafe {
-        lvgl_sys::lv_disp_get_scr_act(
-            disp.map(|d| d.disp.as_ptr())
-                .unwrap_or(ptr::null_mut() as *mut lvgl_sys::lv_disp_t),
-        )
-    };
-    Ok(Obj::from_raw(
-        NonNull::new(scr_ptr).ok_or(CoreError::ResourceNotAvailable)?,
-    ))
-}
-
-/// You have to call this function periodically.
-/// Expects a `tick_period` duration as argument which is the call period of this
-/// function in milliseconds.
-#[inline]
-pub fn tick_inc(tick_period: Duration) {
-    unsafe {
-        lvgl_sys::lv_tick_inc(tick_period.as_millis() as u32);
-    }
-}
-
-/// Call it periodically to handle tasks.
-#[inline]
-pub fn task_handler() {
-    unsafe { lvgl_sys::lv_task_handler() };
-}

lvgl/src/lib.rs

@@ -17,10 +17,7 @@
 #[macro_use]
 extern crate bitflags;
 
-#[macro_use]
+#[cfg(feature = "lvgl_alloc")]
-mod lv_core;
-
-#[cfg(feature = "alloc")]
 extern crate alloc;
 
 // We can ONLY use `alloc::boxed::Box` if `lvgl_alloc` is enabled.
@@ -34,6 +31,12 @@ use ::alloc::boxed::Box;
 #[cfg(feature = "lvgl_alloc")]
 mod allocator;
 
+mod support;
+mod ui;
+#[macro_use]
+mod lv_core;
+pub mod widgets;
+
 #[cfg(not(feature = "lvgl_alloc"))]
 pub(crate) mod mem;
 
@@ -44,54 +47,22 @@ pub(crate) mod mem;
 #[cfg(not(feature = "lvgl_alloc"))]
 use crate::mem::Box;
 
-mod display;
-pub use display::*;
-mod functions;
-mod support;
-pub mod widgets;
-use core::sync::atomic::{AtomicBool, Ordering};
-pub use functions::*;
 pub use lv_core::*;
 pub use support::*;
+pub use ui::*;
 
-struct RunOnce(AtomicBool);
+use core::sync::atomic::{AtomicBool, Ordering};
 
-impl RunOnce {
+// Initialize LVGL only once.
-    const fn new() -> Self {
+static LVGL_INITIALIZED: AtomicBool = AtomicBool::new(false);
-        Self(AtomicBool::new(false))
-    }
 
-    fn swap_and_check(&self) -> bool {
+pub(crate) fn lvgl_init() {
-        self.0
+    if LVGL_INITIALIZED
-            .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+        .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
-            .is_ok()
+        .is_ok()
-    }
+    {
-}
-
-static LVGL_INITIALIZED: RunOnce = RunOnce::new();
-
-pub fn init() {
-    if LVGL_INITIALIZED.swap_and_check() {
         unsafe {
             lvgl_sys::lv_init();
         }
     }
 }
-
-#[cfg(test)]
-pub(crate) mod tests {
-    use super::*;
-    use crate::display::{Display, DrawBuffer};
-
-    pub(crate) fn initialize_test() {
-        init();
-
-        const REFRESH_BUFFER_SIZE: usize = 64 * 64 / 10;
-        static DRAW_BUFFER: DrawBuffer<REFRESH_BUFFER_SIZE> = DrawBuffer::new();
-        static ONCE_INIT: RunOnce = RunOnce::new();
-
-        if ONCE_INIT.swap_and_check() {
-            let _ = Display::register(&DRAW_BUFFER, |_| {}).unwrap();
-        }
-    }
-}

lvgl/src/lv_core/obj.rs

@@ -1,4 +1,5 @@
 use crate::lv_core::style::Style;
+use crate::Box;
 use crate::{Align, LvError, LvResult};
 use core::ptr;
 
@@ -34,15 +35,14 @@ pub trait Widget: NativeObject {
 
     /// Construct an instance of the object from a raw pointer.
     ///
-    fn from_raw(raw_pointer: ptr::NonNull<lvgl_sys::lv_obj_t>) -> Self;
+    /// # Safety
+    /// Provided the LVGL library can allocate memory this should be safe.
+    ///
+    unsafe fn from_raw(raw_pointer: ptr::NonNull<lvgl_sys::lv_obj_t>) -> Self;
 
-    fn add_style(&self, part: Self::Part, style: &mut Style) -> LvResult<()> {
+    fn add_style(&self, part: Self::Part, style: Style) -> LvResult<()> {
         unsafe {
-            lvgl_sys::lv_obj_add_style(
+            lvgl_sys::lv_obj_add_style(self.raw()?.as_mut(), part.into(), Box::into_raw(style.raw));
-                self.raw()?.as_mut(),
-                part.into(),
-                style.raw.as_mut() as *mut _,
-            );
         };
         Ok(())
     }
@@ -104,7 +104,7 @@ impl Widget for Obj {
     type SpecialEvent = ();
     type Part = Part;
 
-    fn from_raw(raw: ptr::NonNull<lvgl_sys::lv_obj_t>) -> Self {
+    unsafe fn from_raw(raw: ptr::NonNull<lvgl_sys::lv_obj_t>) -> Self {
         Self { raw: raw.as_ptr() }
     }
 }
@@ -167,7 +167,7 @@ macro_rules! define_object {
             type SpecialEvent = $event_type;
             type Part = $part_type;
 
-            fn from_raw(raw_pointer: core::ptr::NonNull<lvgl_sys::lv_obj_t>) -> Self {
+            unsafe fn from_raw(raw_pointer: core::ptr::NonNull<lvgl_sys::lv_obj_t>) -> Self {
                 Self {
                     core: $crate::Obj::from_raw(raw_pointer),
                 }
@@ -176,54 +176,22 @@ macro_rules! define_object {
     };
 }
 
-// define_object!(Rafael);
-//
-// impl Rafael {
-//     pub fn create(
-//         parent: &mut impl crate::NativeObject,
-//         copy: Option<&Rafael>,
-//     ) -> crate::LvResult<Self> {
-//         unsafe {
-//             let ptr = lvgl_sys::lv_arc_create(
-//                 parent.raw()?.as_mut(),
-//                 copy.map(|c| c.raw().unwrap().as_mut() as *mut lvgl_sys::lv_obj_t)
-//                     .unwrap_or(core::ptr::null_mut() as *mut lvgl_sys::lv_obj_t),
-//             );
-//             if let Some(raw) = core::ptr::NonNull::new(ptr) {
-//                 let core = <crate::Obj as crate::Widget>::from_raw(raw);
-//                 Ok(Self { core })
-//             } else {
-//                 Err(crate::LvError::InvalidReference)
-//             }
-//         }
-//     }
-//
-//     pub fn create_at(parent: &mut impl crate::NativeObject) -> crate::LvResult<Self> {
-//         Ok(Self::create(parent, None)?)
-//     }
-//
-//     pub fn new() -> crate::LvResult<Self> {
-//         let mut parent = crate::display::DefaultDisplay::get_scr_act()?;
-//         Ok(Self::create_at(&mut parent)?)
-//     }
-// }
-
 bitflags! {
     pub struct State: u32 {
         /// Normal, released
-        const DEFAULT  = lvgl_sys::LV_STATE_DEFAULT;
+        const DEFAULT  = lvgl_sys::LV_STATE_DEFAULT as u32;
         /// Toggled or checked
-        const CHECKED  = lvgl_sys::LV_STATE_CHECKED;
+        const CHECKED  = lvgl_sys::LV_STATE_CHECKED as u32;
         /// Focused via keypad or encoder or clicked via touchpad/mouse
-        const FOCUSED  = lvgl_sys::LV_STATE_FOCUSED;
+        const FOCUSED  = lvgl_sys::LV_STATE_FOCUSED as u32;
         /// Edit by an encoder
-        const EDITED   = lvgl_sys::LV_STATE_EDITED;
+        const EDITED   = lvgl_sys::LV_STATE_EDITED as u32;
         /// Hovered by mouse (not supported now)
-        const HOVERED  = lvgl_sys::LV_STATE_HOVERED;
+        const HOVERED  = lvgl_sys::LV_STATE_HOVERED as u32;
         /// Pressed
-        const PRESSED  = lvgl_sys::LV_STATE_PRESSED;
+        const PRESSED  = lvgl_sys::LV_STATE_PRESSED as u32;
         /// Disabled or inactive
-        const DISABLED = lvgl_sys::LV_STATE_DISABLED;
+        const DISABLED = lvgl_sys::LV_STATE_DISABLED as u32;
     }
 }
 
@@ -238,9 +206,9 @@ pub enum Part {
     All,
 }
 
-impl Into<u8> for Part {
+impl From<Part> for u8 {
-    fn into(self) -> u8 {
+    fn from(self_: Part) -> u8 {
-        match self {
+        match self_ {
             Part::Main => lvgl_sys::LV_OBJ_PART_MAIN as u8,
             Part::All => lvgl_sys::LV_OBJ_PART_ALL as u8,
         }

lvgl/src/lv_core/style.rs

@@ -7,6 +7,7 @@ pub enum Themes {
     Pretty,
 }
 
+#[derive(Clone)]
 pub struct Style {
     pub(crate) raw: Box<lvgl_sys::lv_style_t>,
 }
@@ -17,7 +18,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_ptr(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_STR
+                (lvgl_sys::LV_STYLE_VALUE_STR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.as_ptr() as *mut cty::c_void,
             );
@@ -39,122 +40,122 @@ impl Default for Style {
 
 bitflags! {
     pub struct Opacity: u32 {
-        const OPA_TRANSP = lvgl_sys::LV_OPA_TRANSP;
+        const OPA_TRANSP = lvgl_sys::LV_OPA_TRANSP as u32;
-        const OPA_0 = lvgl_sys::LV_OPA_0;
+        const OPA_0 = lvgl_sys::LV_OPA_0 as u32;
-        const OPA_10 = lvgl_sys::LV_OPA_10;
+        const OPA_10 = lvgl_sys::LV_OPA_10 as u32;
-        const OPA_20 = lvgl_sys::LV_OPA_20;
+        const OPA_20 = lvgl_sys::LV_OPA_20 as u32;
-        const OPA_30 = lvgl_sys::LV_OPA_30;
+        const OPA_30 = lvgl_sys::LV_OPA_30 as u32;
-        const OPA_40 = lvgl_sys::LV_OPA_40;
+        const OPA_40 = lvgl_sys::LV_OPA_40 as u32;
-        const OPA_50 = lvgl_sys::LV_OPA_50;
+        const OPA_50 = lvgl_sys::LV_OPA_50 as u32;
-        const OPA_60 = lvgl_sys::LV_OPA_60;
+        const OPA_60 = lvgl_sys::LV_OPA_60 as u32;
-        const OPA_70 = lvgl_sys::LV_OPA_70;
+        const OPA_70 = lvgl_sys::LV_OPA_70 as u32;
-        const OPA_80 = lvgl_sys::LV_OPA_80;
+        const OPA_80 = lvgl_sys::LV_OPA_80 as u32;
-        const OPA_90 = lvgl_sys::LV_OPA_90;
+        const OPA_90 = lvgl_sys::LV_OPA_90 as u32;
-        const OPA_100 = lvgl_sys::LV_OPA_100;
+        const OPA_100 = lvgl_sys::LV_OPA_100 as u32;
-        const OPA_COVER = lvgl_sys::LV_OPA_COVER;
+        const OPA_COVER = lvgl_sys::LV_OPA_COVER as u32;
     }
 }
 
-impl Into<u8> for Opacity {
+impl From<Opacity> for u8 {
-    fn into(self) -> u8 {
+    fn from(self_: Opacity) -> u8 {
-        self.bits as u8
+        self_.bits as u8
     }
 }
 
 bitflags! {
     pub struct StyleProp: u32 {
-        const RADIUS = lvgl_sys::LV_STYLE_RADIUS;
+        const RADIUS = lvgl_sys::LV_STYLE_RADIUS as u32;
-        const CLIP_CORNER = lvgl_sys::LV_STYLE_CLIP_CORNER;
+        const CLIP_CORNER = lvgl_sys::LV_STYLE_CLIP_CORNER as u32;
-        const SIZE = lvgl_sys::LV_STYLE_SIZE;
+        const SIZE = lvgl_sys::LV_STYLE_SIZE as u32;
-        const TRANSFORM_WIDTH = lvgl_sys::LV_STYLE_TRANSFORM_WIDTH;
+        const TRANSFORM_WIDTH = lvgl_sys::LV_STYLE_TRANSFORM_WIDTH as u32;
-        const TRANSFORM_HEIGHT = lvgl_sys::LV_STYLE_TRANSFORM_HEIGHT;
+        const TRANSFORM_HEIGHT = lvgl_sys::LV_STYLE_TRANSFORM_HEIGHT as u32;
-        const TRANSFORM_ANGLE = lvgl_sys::LV_STYLE_TRANSFORM_ANGLE;
+        const TRANSFORM_ANGLE = lvgl_sys::LV_STYLE_TRANSFORM_ANGLE as u32;
-        const TRANSFORM_ZOOM = lvgl_sys::LV_STYLE_TRANSFORM_ZOOM;
+        const TRANSFORM_ZOOM = lvgl_sys::LV_STYLE_TRANSFORM_ZOOM as u32;
-        const OPA_SCALE = lvgl_sys::LV_STYLE_OPA_SCALE;
+        const OPA_SCALE = lvgl_sys::LV_STYLE_OPA_SCALE as u32;
-        const PAD_TOP = lvgl_sys::LV_STYLE_PAD_TOP;
+        const PAD_TOP = lvgl_sys::LV_STYLE_PAD_TOP as u32;
-        const PAD_BOTTOM = lvgl_sys::LV_STYLE_PAD_BOTTOM;
+        const PAD_BOTTOM = lvgl_sys::LV_STYLE_PAD_BOTTOM as u32;
-        const PAD_LEFT = lvgl_sys::LV_STYLE_PAD_LEFT;
+        const PAD_LEFT = lvgl_sys::LV_STYLE_PAD_LEFT as u32;
-        const PAD_RIGHT = lvgl_sys::LV_STYLE_PAD_RIGHT;
+        const PAD_RIGHT = lvgl_sys::LV_STYLE_PAD_RIGHT as u32;
-        const PAD_INNER = lvgl_sys::LV_STYLE_PAD_INNER;
+        const PAD_INNER = lvgl_sys::LV_STYLE_PAD_INNER as u32;
-        const MARGIN_TOP = lvgl_sys::LV_STYLE_MARGIN_TOP;
+        const MARGIN_TOP = lvgl_sys::LV_STYLE_MARGIN_TOP as u32;
-        const MARGIN_BOTTOM = lvgl_sys::LV_STYLE_MARGIN_BOTTOM;
+        const MARGIN_BOTTOM = lvgl_sys::LV_STYLE_MARGIN_BOTTOM as u32;
-        const MARGIN_LEFT = lvgl_sys::LV_STYLE_MARGIN_LEFT;
+        const MARGIN_LEFT = lvgl_sys::LV_STYLE_MARGIN_LEFT as u32;
-        const MARGIN_RIGHT = lvgl_sys::LV_STYLE_MARGIN_RIGHT;
+        const MARGIN_RIGHT = lvgl_sys::LV_STYLE_MARGIN_RIGHT as u32;
-        const BG_BLEND_MODE = lvgl_sys::LV_STYLE_BG_BLEND_MODE;
+        const BG_BLEND_MODE = lvgl_sys::LV_STYLE_BG_BLEND_MODE as u32;
-        const BG_MAIN_STOP = lvgl_sys::LV_STYLE_BG_MAIN_STOP;
+        const BG_MAIN_STOP = lvgl_sys::LV_STYLE_BG_MAIN_STOP as u32;
-        const BG_GRAD_STOP = lvgl_sys::LV_STYLE_BG_GRAD_STOP;
+        const BG_GRAD_STOP = lvgl_sys::LV_STYLE_BG_GRAD_STOP as u32;
-        const BG_GRAD_DIR = lvgl_sys::LV_STYLE_BG_GRAD_DIR;
+        const BG_GRAD_DIR = lvgl_sys::LV_STYLE_BG_GRAD_DIR as u32;
-        const BG_COLOR = lvgl_sys::LV_STYLE_BG_COLOR;
+        const BG_COLOR = lvgl_sys::LV_STYLE_BG_COLOR as u32;
-        const BG_GRAD_COLOR = lvgl_sys::LV_STYLE_BG_GRAD_COLOR;
+        const BG_GRAD_COLOR = lvgl_sys::LV_STYLE_BG_GRAD_COLOR as u32;
-        const BG_OPA = lvgl_sys::LV_STYLE_BG_OPA;
+        const BG_OPA = lvgl_sys::LV_STYLE_BG_OPA as u32;
-        const BORDER_WIDTH = lvgl_sys::LV_STYLE_BORDER_WIDTH;
+        const BORDER_WIDTH = lvgl_sys::LV_STYLE_BORDER_WIDTH as u32;
-        const BORDER_SIDE = lvgl_sys::LV_STYLE_BORDER_SIDE;
+        const BORDER_SIDE = lvgl_sys::LV_STYLE_BORDER_SIDE as u32;
-        const BORDER_BLEND_MODE = lvgl_sys::LV_STYLE_BORDER_BLEND_MODE;
+        const BORDER_BLEND_MODE = lvgl_sys::LV_STYLE_BORDER_BLEND_MODE as u32;
-        const BORDER_POST = lvgl_sys::LV_STYLE_BORDER_POST;
+        const BORDER_POST = lvgl_sys::LV_STYLE_BORDER_POST as u32;
-        const BORDER_COLOR = lvgl_sys::LV_STYLE_BORDER_COLOR;
+        const BORDER_COLOR = lvgl_sys::LV_STYLE_BORDER_COLOR as u32;
-        const BORDER_OPA = lvgl_sys::LV_STYLE_BORDER_OPA;
+        const BORDER_OPA = lvgl_sys::LV_STYLE_BORDER_OPA as u32;
-        const OUTLINE_WIDTH = lvgl_sys::LV_STYLE_OUTLINE_WIDTH;
+        const OUTLINE_WIDTH = lvgl_sys::LV_STYLE_OUTLINE_WIDTH as u32;
-        const OUTLINE_PAD = lvgl_sys::LV_STYLE_OUTLINE_PAD;
+        const OUTLINE_PAD = lvgl_sys::LV_STYLE_OUTLINE_PAD as u32;
-        const OUTLINE_BLEND_MODE = lvgl_sys::LV_STYLE_OUTLINE_BLEND_MODE;
+        const OUTLINE_BLEND_MODE = lvgl_sys::LV_STYLE_OUTLINE_BLEND_MODE as u32;
-        const OUTLINE_COLOR = lvgl_sys::LV_STYLE_OUTLINE_COLOR;
+        const OUTLINE_COLOR = lvgl_sys::LV_STYLE_OUTLINE_COLOR as u32;
-        const OUTLINE_OPA = lvgl_sys::LV_STYLE_OUTLINE_OPA;
+        const OUTLINE_OPA = lvgl_sys::LV_STYLE_OUTLINE_OPA as u32;
-        const SHADOW_WIDTH = lvgl_sys::LV_STYLE_SHADOW_WIDTH;
+        const SHADOW_WIDTH = lvgl_sys::LV_STYLE_SHADOW_WIDTH as u32;
-        const SHADOW_OFS_X = lvgl_sys::LV_STYLE_SHADOW_OFS_X;
+        const SHADOW_OFS_X = lvgl_sys::LV_STYLE_SHADOW_OFS_X as u32;
-        const SHADOW_OFS_Y = lvgl_sys::LV_STYLE_SHADOW_OFS_Y;
+        const SHADOW_OFS_Y = lvgl_sys::LV_STYLE_SHADOW_OFS_Y as u32;
-        const SHADOW_SPREAD = lvgl_sys::LV_STYLE_SHADOW_SPREAD;
+        const SHADOW_SPREAD = lvgl_sys::LV_STYLE_SHADOW_SPREAD as u32;
-        const SHADOW_BLEND_MODE = lvgl_sys::LV_STYLE_SHADOW_BLEND_MODE;
+        const SHADOW_BLEND_MODE = lvgl_sys::LV_STYLE_SHADOW_BLEND_MODE as u32;
-        const SHADOW_COLOR = lvgl_sys::LV_STYLE_SHADOW_COLOR;
+        const SHADOW_COLOR = lvgl_sys::LV_STYLE_SHADOW_COLOR as u32;
-        const SHADOW_OPA = lvgl_sys::LV_STYLE_SHADOW_OPA;
+        const SHADOW_OPA = lvgl_sys::LV_STYLE_SHADOW_OPA as u32;
-        const PATTERN_BLEND_MODE = lvgl_sys::LV_STYLE_PATTERN_BLEND_MODE;
+        const PATTERN_BLEND_MODE = lvgl_sys::LV_STYLE_PATTERN_BLEND_MODE as u32;
-        const PATTERN_REPEAT = lvgl_sys::LV_STYLE_PATTERN_REPEAT;
+        const PATTERN_REPEAT = lvgl_sys::LV_STYLE_PATTERN_REPEAT as u32;
-        const PATTERN_RECOLOR = lvgl_sys::LV_STYLE_PATTERN_RECOLOR;
+        const PATTERN_RECOLOR = lvgl_sys::LV_STYLE_PATTERN_RECOLOR as u32;
-        const PATTERN_OPA = lvgl_sys::LV_STYLE_PATTERN_OPA;
+        const PATTERN_OPA = lvgl_sys::LV_STYLE_PATTERN_OPA as u32;
-        const PATTERN_RECOLOR_OPA = lvgl_sys::LV_STYLE_PATTERN_RECOLOR_OPA;
+        const PATTERN_RECOLOR_OPA = lvgl_sys::LV_STYLE_PATTERN_RECOLOR_OPA as u32;
-        const PATTERN_IMAGE = lvgl_sys::LV_STYLE_PATTERN_IMAGE;
+        const PATTERN_IMAGE = lvgl_sys::LV_STYLE_PATTERN_IMAGE as u32;
-        const VALUE_LETTER_SPACE = lvgl_sys::LV_STYLE_VALUE_LETTER_SPACE;
+        const VALUE_LETTER_SPACE = lvgl_sys::LV_STYLE_VALUE_LETTER_SPACE as u32;
-        const VALUE_LINE_SPACE = lvgl_sys::LV_STYLE_VALUE_LINE_SPACE;
+        const VALUE_LINE_SPACE = lvgl_sys::LV_STYLE_VALUE_LINE_SPACE as u32;
-        const VALUE_BLEND_MODE = lvgl_sys::LV_STYLE_VALUE_BLEND_MODE;
+        const VALUE_BLEND_MODE = lvgl_sys::LV_STYLE_VALUE_BLEND_MODE as u32;
-        const VALUE_OFS_X = lvgl_sys::LV_STYLE_VALUE_OFS_X;
+        const VALUE_OFS_X = lvgl_sys::LV_STYLE_VALUE_OFS_X as u32;
-        const VALUE_OFS_Y = lvgl_sys::LV_STYLE_VALUE_OFS_Y;
+        const VALUE_OFS_Y = lvgl_sys::LV_STYLE_VALUE_OFS_Y as u32;
-        const VALUE_ALIGN = lvgl_sys::LV_STYLE_VALUE_ALIGN;
+        const VALUE_ALIGN = lvgl_sys::LV_STYLE_VALUE_ALIGN as u32;
-        const VALUE_COLOR = lvgl_sys::LV_STYLE_VALUE_COLOR;
+        const VALUE_COLOR = lvgl_sys::LV_STYLE_VALUE_COLOR as u32;
-        const VALUE_OPA = lvgl_sys::LV_STYLE_VALUE_OPA;
+        const VALUE_OPA = lvgl_sys::LV_STYLE_VALUE_OPA as u32;
-        const VALUE_FONT = lvgl_sys::LV_STYLE_VALUE_FONT;
+        const VALUE_FONT = lvgl_sys::LV_STYLE_VALUE_FONT as u32;
-        const VALUE_STR = lvgl_sys::LV_STYLE_VALUE_STR;
+        const VALUE_STR = lvgl_sys::LV_STYLE_VALUE_STR as u32;
-        const TEXT_LETTER_SPACE = lvgl_sys::LV_STYLE_TEXT_LETTER_SPACE;
+        const TEXT_LETTER_SPACE = lvgl_sys::LV_STYLE_TEXT_LETTER_SPACE as u32;
-        const TEXT_LINE_SPACE = lvgl_sys::LV_STYLE_TEXT_LINE_SPACE;
+        const TEXT_LINE_SPACE = lvgl_sys::LV_STYLE_TEXT_LINE_SPACE as u32;
-        const TEXT_DECOR = lvgl_sys::LV_STYLE_TEXT_DECOR;
+        const TEXT_DECOR = lvgl_sys::LV_STYLE_TEXT_DECOR as u32;
-        const TEXT_BLEND_MODE = lvgl_sys::LV_STYLE_TEXT_BLEND_MODE;
+        const TEXT_BLEND_MODE = lvgl_sys::LV_STYLE_TEXT_BLEND_MODE as u32;
-        const TEXT_COLOR = lvgl_sys::LV_STYLE_TEXT_COLOR;
+        const TEXT_COLOR = lvgl_sys::LV_STYLE_TEXT_COLOR as u32;
-        const TEXT_SEL_COLOR = lvgl_sys::LV_STYLE_TEXT_SEL_COLOR;
+        const TEXT_SEL_COLOR = lvgl_sys::LV_STYLE_TEXT_SEL_COLOR as u32;
-        const TEXT_OPA = lvgl_sys::LV_STYLE_TEXT_OPA;
+        const TEXT_OPA = lvgl_sys::LV_STYLE_TEXT_OPA as u32;
-        const TEXT_FONT = lvgl_sys::LV_STYLE_TEXT_FONT;
+        const TEXT_FONT = lvgl_sys::LV_STYLE_TEXT_FONT as u32;
-        const LINE_WIDTH = lvgl_sys::LV_STYLE_LINE_WIDTH;
+        const LINE_WIDTH = lvgl_sys::LV_STYLE_LINE_WIDTH as u32;
-        const LINE_BLEND_MODE = lvgl_sys::LV_STYLE_LINE_BLEND_MODE;
+        const LINE_BLEND_MODE = lvgl_sys::LV_STYLE_LINE_BLEND_MODE as u32;
-        const LINE_DASH_WIDTH = lvgl_sys::LV_STYLE_LINE_DASH_WIDTH;
+        const LINE_DASH_WIDTH = lvgl_sys::LV_STYLE_LINE_DASH_WIDTH as u32;
-        const LINE_DASH_GAP = lvgl_sys::LV_STYLE_LINE_DASH_GAP;
+        const LINE_DASH_GAP = lvgl_sys::LV_STYLE_LINE_DASH_GAP as u32;
-        const LINE_ROUNDED = lvgl_sys::LV_STYLE_LINE_ROUNDED;
+        const LINE_ROUNDED = lvgl_sys::LV_STYLE_LINE_ROUNDED as u32;
-        const LINE_COLOR = lvgl_sys::LV_STYLE_LINE_COLOR;
+        const LINE_COLOR = lvgl_sys::LV_STYLE_LINE_COLOR as u32;
-        const LINE_OPA = lvgl_sys::LV_STYLE_LINE_OPA;
+        const LINE_OPA = lvgl_sys::LV_STYLE_LINE_OPA as u32;
-        const IMAGE_BLEND_MODE = lvgl_sys::LV_STYLE_IMAGE_BLEND_MODE;
+        const IMAGE_BLEND_MODE = lvgl_sys::LV_STYLE_IMAGE_BLEND_MODE as u32;
-        const IMAGE_RECOLOR = lvgl_sys::LV_STYLE_IMAGE_RECOLOR;
+        const IMAGE_RECOLOR = lvgl_sys::LV_STYLE_IMAGE_RECOLOR as u32;
-        const IMAGE_OPA = lvgl_sys::LV_STYLE_IMAGE_OPA;
+        const IMAGE_OPA = lvgl_sys::LV_STYLE_IMAGE_OPA as u32;
-        const IMAGE_RECOLOR_OPA = lvgl_sys::LV_STYLE_IMAGE_RECOLOR_OPA;
+        const IMAGE_RECOLOR_OPA = lvgl_sys::LV_STYLE_IMAGE_RECOLOR_OPA as u32;
-        const TRANSITION_TIME = lvgl_sys::LV_STYLE_TRANSITION_TIME;
+        const TRANSITION_TIME = lvgl_sys::LV_STYLE_TRANSITION_TIME as u32;
-        const TRANSITION_DELAY = lvgl_sys::LV_STYLE_TRANSITION_DELAY;
+        const TRANSITION_DELAY = lvgl_sys::LV_STYLE_TRANSITION_DELAY as u32;
-        const TRANSITION_PROP_1 = lvgl_sys::LV_STYLE_TRANSITION_PROP_1;
+        const TRANSITION_PROP_1 = lvgl_sys::LV_STYLE_TRANSITION_PROP_1 as u32;
-        const TRANSITION_PROP_2 = lvgl_sys::LV_STYLE_TRANSITION_PROP_2;
+        const TRANSITION_PROP_2 = lvgl_sys::LV_STYLE_TRANSITION_PROP_2 as u32;
-        const TRANSITION_PROP_3 = lvgl_sys::LV_STYLE_TRANSITION_PROP_3;
+        const TRANSITION_PROP_3 = lvgl_sys::LV_STYLE_TRANSITION_PROP_3 as u32;
-        const TRANSITION_PROP_4 = lvgl_sys::LV_STYLE_TRANSITION_PROP_4;
+        const TRANSITION_PROP_4 = lvgl_sys::LV_STYLE_TRANSITION_PROP_4 as u32;
-        const TRANSITION_PROP_5 = lvgl_sys::LV_STYLE_TRANSITION_PROP_5;
+        const TRANSITION_PROP_5 = lvgl_sys::LV_STYLE_TRANSITION_PROP_5 as u32;
-        const TRANSITION_PROP_6 = lvgl_sys::LV_STYLE_TRANSITION_PROP_6;
+        const TRANSITION_PROP_6 = lvgl_sys::LV_STYLE_TRANSITION_PROP_6 as u32;
-        const TRANSITION_PATH = lvgl_sys::LV_STYLE_TRANSITION_PATH;
+        const TRANSITION_PATH = lvgl_sys::LV_STYLE_TRANSITION_PATH as u32;
-        const SCALE_WIDTH = lvgl_sys::LV_STYLE_SCALE_WIDTH;
+        const SCALE_WIDTH = lvgl_sys::LV_STYLE_SCALE_WIDTH as u32;
-        const SCALE_BORDER_WIDTH = lvgl_sys::LV_STYLE_SCALE_BORDER_WIDTH;
+        const SCALE_BORDER_WIDTH = lvgl_sys::LV_STYLE_SCALE_BORDER_WIDTH as u32;
-        const SCALE_END_BORDER_WIDTH = lvgl_sys::LV_STYLE_SCALE_END_BORDER_WIDTH;
+        const SCALE_END_BORDER_WIDTH = lvgl_sys::LV_STYLE_SCALE_END_BORDER_WIDTH as u32;
-        const SCALE_END_LINE_WIDTH = lvgl_sys::LV_STYLE_SCALE_END_LINE_WIDTH;
+        const SCALE_END_LINE_WIDTH = lvgl_sys::LV_STYLE_SCALE_END_LINE_WIDTH as u32;
-        const SCALE_GRAD_COLOR = lvgl_sys::LV_STYLE_SCALE_GRAD_COLOR;
+        const SCALE_GRAD_COLOR = lvgl_sys::LV_STYLE_SCALE_GRAD_COLOR as u32;
-        const SCALE_END_COLOR = lvgl_sys::LV_STYLE_SCALE_END_COLOR;
+        const SCALE_END_COLOR = lvgl_sys::LV_STYLE_SCALE_END_COLOR as u32;
     }
 }
 
@@ -165,8 +166,8 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_RADIUS | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32))
+                (lvgl_sys::LV_STYLE_RADIUS as u32
-                    as u16,
+                    | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
         }
@@ -177,7 +178,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_CLIP_CORNER
+                (lvgl_sys::LV_STYLE_CLIP_CORNER as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -189,8 +190,8 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SIZE | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32))
+                (lvgl_sys::LV_STYLE_SIZE as u32
-                    as u16,
+                    | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
         }
@@ -201,7 +202,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSFORM_WIDTH
+                (lvgl_sys::LV_STYLE_TRANSFORM_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -213,7 +214,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSFORM_HEIGHT
+                (lvgl_sys::LV_STYLE_TRANSFORM_HEIGHT as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -225,7 +226,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSFORM_ANGLE
+                (lvgl_sys::LV_STYLE_TRANSFORM_ANGLE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -237,7 +238,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSFORM_ZOOM
+                (lvgl_sys::LV_STYLE_TRANSFORM_ZOOM as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -249,7 +250,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_OPA_SCALE
+                (lvgl_sys::LV_STYLE_OPA_SCALE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -261,8 +262,8 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PAD_TOP | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32))
+                (lvgl_sys::LV_STYLE_PAD_TOP as u32
-                    as u16,
+                    | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
         }
@@ -273,7 +274,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PAD_BOTTOM
+                (lvgl_sys::LV_STYLE_PAD_BOTTOM as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -285,7 +286,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PAD_LEFT
+                (lvgl_sys::LV_STYLE_PAD_LEFT as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -297,7 +298,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PAD_RIGHT
+                (lvgl_sys::LV_STYLE_PAD_RIGHT as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -309,7 +310,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PAD_INNER
+                (lvgl_sys::LV_STYLE_PAD_INNER as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -321,7 +322,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_MARGIN_TOP
+                (lvgl_sys::LV_STYLE_MARGIN_TOP as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -333,7 +334,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_MARGIN_BOTTOM
+                (lvgl_sys::LV_STYLE_MARGIN_BOTTOM as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -345,7 +346,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_MARGIN_LEFT
+                (lvgl_sys::LV_STYLE_MARGIN_LEFT as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -357,7 +358,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_MARGIN_RIGHT
+                (lvgl_sys::LV_STYLE_MARGIN_RIGHT as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -369,7 +370,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BG_BLEND_MODE
+                (lvgl_sys::LV_STYLE_BG_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -381,7 +382,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BG_MAIN_STOP
+                (lvgl_sys::LV_STYLE_BG_MAIN_STOP as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -393,7 +394,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BG_GRAD_STOP
+                (lvgl_sys::LV_STYLE_BG_GRAD_STOP as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -405,7 +406,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BG_GRAD_DIR
+                (lvgl_sys::LV_STYLE_BG_GRAD_DIR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -417,7 +418,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BG_COLOR
+                (lvgl_sys::LV_STYLE_BG_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -429,7 +430,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BG_GRAD_COLOR
+                (lvgl_sys::LV_STYLE_BG_GRAD_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -441,8 +442,8 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BG_OPA | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32))
+                (lvgl_sys::LV_STYLE_BG_OPA as u32
-                    as u16,
+                    | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
         }
@@ -453,7 +454,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BORDER_WIDTH
+                (lvgl_sys::LV_STYLE_BORDER_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -465,7 +466,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BORDER_SIDE
+                (lvgl_sys::LV_STYLE_BORDER_SIDE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -477,7 +478,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BORDER_BLEND_MODE
+                (lvgl_sys::LV_STYLE_BORDER_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -489,7 +490,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BORDER_POST
+                (lvgl_sys::LV_STYLE_BORDER_POST as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -501,7 +502,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BORDER_COLOR
+                (lvgl_sys::LV_STYLE_BORDER_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -513,7 +514,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_BORDER_OPA
+                (lvgl_sys::LV_STYLE_BORDER_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -525,7 +526,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_OUTLINE_WIDTH
+                (lvgl_sys::LV_STYLE_OUTLINE_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -537,7 +538,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_OUTLINE_PAD
+                (lvgl_sys::LV_STYLE_OUTLINE_PAD as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -549,7 +550,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_OUTLINE_BLEND_MODE
+                (lvgl_sys::LV_STYLE_OUTLINE_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -561,7 +562,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_OUTLINE_COLOR
+                (lvgl_sys::LV_STYLE_OUTLINE_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -573,7 +574,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_OUTLINE_OPA
+                (lvgl_sys::LV_STYLE_OUTLINE_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -585,7 +586,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SHADOW_WIDTH
+                (lvgl_sys::LV_STYLE_SHADOW_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -597,7 +598,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SHADOW_OFS_X
+                (lvgl_sys::LV_STYLE_SHADOW_OFS_X as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -609,7 +610,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SHADOW_OFS_Y
+                (lvgl_sys::LV_STYLE_SHADOW_OFS_Y as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -621,7 +622,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SHADOW_SPREAD
+                (lvgl_sys::LV_STYLE_SHADOW_SPREAD as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -633,7 +634,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SHADOW_BLEND_MODE
+                (lvgl_sys::LV_STYLE_SHADOW_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -645,7 +646,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SHADOW_COLOR
+                (lvgl_sys::LV_STYLE_SHADOW_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -657,7 +658,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SHADOW_OPA
+                (lvgl_sys::LV_STYLE_SHADOW_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -669,7 +670,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PATTERN_REPEAT
+                (lvgl_sys::LV_STYLE_PATTERN_REPEAT as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -681,7 +682,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PATTERN_BLEND_MODE
+                (lvgl_sys::LV_STYLE_PATTERN_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -693,7 +694,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PATTERN_RECOLOR
+                (lvgl_sys::LV_STYLE_PATTERN_RECOLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -705,7 +706,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PATTERN_OPA
+                (lvgl_sys::LV_STYLE_PATTERN_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -717,7 +718,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_PATTERN_RECOLOR_OPA
+                (lvgl_sys::LV_STYLE_PATTERN_RECOLOR_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -729,7 +730,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_LETTER_SPACE
+                (lvgl_sys::LV_STYLE_VALUE_LETTER_SPACE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -741,7 +742,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_LINE_SPACE
+                (lvgl_sys::LV_STYLE_VALUE_LINE_SPACE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -753,7 +754,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_BLEND_MODE
+                (lvgl_sys::LV_STYLE_VALUE_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -765,7 +766,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_OFS_X
+                (lvgl_sys::LV_STYLE_VALUE_OFS_X as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -777,7 +778,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_OFS_Y
+                (lvgl_sys::LV_STYLE_VALUE_OFS_Y as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -789,7 +790,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_ALIGN
+                (lvgl_sys::LV_STYLE_VALUE_ALIGN as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -801,7 +802,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_COLOR
+                (lvgl_sys::LV_STYLE_VALUE_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -813,7 +814,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_VALUE_OPA
+                (lvgl_sys::LV_STYLE_VALUE_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -825,7 +826,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TEXT_LETTER_SPACE
+                (lvgl_sys::LV_STYLE_TEXT_LETTER_SPACE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -837,7 +838,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TEXT_LINE_SPACE
+                (lvgl_sys::LV_STYLE_TEXT_LINE_SPACE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -849,7 +850,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TEXT_DECOR
+                (lvgl_sys::LV_STYLE_TEXT_DECOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -861,7 +862,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TEXT_BLEND_MODE
+                (lvgl_sys::LV_STYLE_TEXT_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -873,7 +874,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TEXT_COLOR
+                (lvgl_sys::LV_STYLE_TEXT_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -885,7 +886,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TEXT_SEL_COLOR
+                (lvgl_sys::LV_STYLE_TEXT_SEL_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -897,7 +898,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TEXT_OPA
+                (lvgl_sys::LV_STYLE_TEXT_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -909,7 +910,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_LINE_WIDTH
+                (lvgl_sys::LV_STYLE_LINE_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -921,7 +922,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_LINE_BLEND_MODE
+                (lvgl_sys::LV_STYLE_LINE_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -933,7 +934,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_LINE_DASH_WIDTH
+                (lvgl_sys::LV_STYLE_LINE_DASH_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -945,7 +946,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_LINE_DASH_GAP
+                (lvgl_sys::LV_STYLE_LINE_DASH_GAP as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -957,7 +958,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_LINE_ROUNDED
+                (lvgl_sys::LV_STYLE_LINE_ROUNDED as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -969,7 +970,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_LINE_COLOR
+                (lvgl_sys::LV_STYLE_LINE_COLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -981,7 +982,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_LINE_OPA
+                (lvgl_sys::LV_STYLE_LINE_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -993,7 +994,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_IMAGE_BLEND_MODE
+                (lvgl_sys::LV_STYLE_IMAGE_BLEND_MODE as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1005,7 +1006,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_IMAGE_RECOLOR
+                (lvgl_sys::LV_STYLE_IMAGE_RECOLOR as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.raw,
             );
@@ -1017,7 +1018,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_IMAGE_OPA
+                (lvgl_sys::LV_STYLE_IMAGE_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -1029,7 +1030,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_opa(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_IMAGE_RECOLOR_OPA
+                (lvgl_sys::LV_STYLE_IMAGE_RECOLOR_OPA as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value.into(),
             );
@@ -1041,7 +1042,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSITION_TIME
+                (lvgl_sys::LV_STYLE_TRANSITION_TIME as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1053,7 +1054,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSITION_DELAY
+                (lvgl_sys::LV_STYLE_TRANSITION_DELAY as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1065,7 +1066,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSITION_PROP_1
+                (lvgl_sys::LV_STYLE_TRANSITION_PROP_1 as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1077,7 +1078,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSITION_PROP_2
+                (lvgl_sys::LV_STYLE_TRANSITION_PROP_2 as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1089,7 +1090,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSITION_PROP_3
+                (lvgl_sys::LV_STYLE_TRANSITION_PROP_3 as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1101,7 +1102,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSITION_PROP_4
+                (lvgl_sys::LV_STYLE_TRANSITION_PROP_4 as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1113,7 +1114,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSITION_PROP_5
+                (lvgl_sys::LV_STYLE_TRANSITION_PROP_5 as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1125,7 +1126,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_TRANSITION_PROP_6
+                (lvgl_sys::LV_STYLE_TRANSITION_PROP_6 as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1137,7 +1138,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SCALE_WIDTH
+                (lvgl_sys::LV_STYLE_SCALE_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1149,7 +1150,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SCALE_BORDER_WIDTH
+                (lvgl_sys::LV_STYLE_SCALE_BORDER_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1161,7 +1162,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SCALE_END_BORDER_WIDTH
+                (lvgl_sys::LV_STYLE_SCALE_END_BORDER_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1173,7 +1174,7 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_int(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SCALE_END_LINE_WIDTH
+                (lvgl_sys::LV_STYLE_SCALE_END_LINE_WIDTH as u32
                     | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
                 value,
             );
@@ -1185,8 +1186,8 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SCALE_GRAD_COLOR
+                (lvgl_sys::LV_STYLE_SCALE_GRAD_COLOR as u32
-                    | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
+                    | (native_state << lvgl_sys::LV_STYLE_STATE_POS)) as u16,
                 value.raw,
             );
         }
@@ -1197,8 +1198,8 @@ impl Style {
         unsafe {
             lvgl_sys::_lv_style_set_color(
                 self.raw.as_mut(),
-                (lvgl_sys::LV_STYLE_SCALE_END_COLOR
+                (lvgl_sys::LV_STYLE_SCALE_END_COLOR as u32
-                    | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16,
+                    | (native_state << lvgl_sys::LV_STYLE_STATE_POS)) as u16,
                 value.raw,
             );
         }

lvgl/src/mem.rs

@@ -11,7 +11,7 @@ pub(crate) struct Box<T>(NonNull<T>);
 
 impl<T> Box<T> {
     /// Allocate memory using LVGL memory API and place `T` in the LVGL tracked memory.
-    pub fn new(value: T) -> Self {
+    pub fn new(value: T) -> Box<T> {
         let size = mem::size_of::<T>();
         let inner = unsafe {
             let ptr = lvgl_sys::lv_mem_alloc(size as lvgl_sys::size_t) as *mut T;
@@ -29,10 +29,10 @@ impl<T> Box<T> {
                     p
                 })
                 .unwrap_or_else(|| {
-                    panic!("Could not allocate memory {} bytes: {:?}", size, mem_info());
+                    panic!("Could not allocate memory {} bytes", size);
                 })
         };
-        Self(inner)
+        Box(inner)
     }
 
     pub fn into_raw(self) -> *mut T {
@@ -69,33 +69,20 @@ impl<T> AsMut<T> for Box<T> {
     }
 }
 
-fn mem_info() -> lvgl_sys::lv_mem_monitor_t {
+impl<T: Clone> Clone for Box<T> {
-    let mut info = lvgl_sys::lv_mem_monitor_t {
+    fn clone(&self) -> Self {
-        total_size: 0,
+        unsafe { Self::new(self.0.as_ref().clone()) }
-        free_cnt: 0,
-        free_size: 0,
-        free_biggest_size: 0,
-        used_cnt: 0,
-        max_used: 0,
-        used_pct: 0,
-        frag_pct: 0,
-    };
-    unsafe {
-        lvgl_sys::lv_mem_monitor(&mut info as *mut _);
     }
-    info
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::mem::mem_info;
-    use crate::*;
     use std::vec::Vec;
 
     #[test]
     fn place_value_in_lv_mem() {
-        tests::initialize_test();
+        crate::lvgl_init();
 
         let v = Box::new(5);
         drop(v);
@@ -105,7 +92,7 @@ mod test {
 
     #[test]
     fn place_complex_value_in_lv_mem() {
-        tests::initialize_test();
+        crate::lvgl_init();
 
         #[repr(C)]
         #[derive(Debug)]
@@ -154,4 +141,34 @@ mod test {
         // If this fails, we are leaking memory! BOOM! \o/
         assert_eq!(initial_mem_info.free_size, final_info.free_size)
     }
+
+    #[test]
+    fn clone_object_in_lv_mem() {
+        crate::lvgl_init();
+
+        let v1 = Box::new(5);
+        let v2 = v1.clone();
+
+        // Ensure that the two objects have identical values.
+        assert_eq!(*v1, *v2);
+        // They should have different memory addresses, however.
+        assert_ne!(v1.into_raw() as usize, v2.into_raw() as usize);
+    }
+
+    fn mem_info() -> lvgl_sys::lv_mem_monitor_t {
+        let mut info = lvgl_sys::lv_mem_monitor_t {
+            total_size: 0,
+            free_cnt: 0,
+            free_size: 0,
+            free_biggest_size: 0,
+            used_cnt: 0,
+            max_used: 0,
+            used_pct: 0,
+            frag_pct: 0,
+        };
+        unsafe {
+            lvgl_sys::lv_mem_monitor(&mut info as *mut _);
+        }
+        info
+    }
 }

lvgl/src/support.rs

@@ -1,9 +1,6 @@
-use crate::display::DisplayError;
 use crate::Widget;
 use core::convert::{TryFrom, TryInto};
 use core::ptr::NonNull;
-
-#[cfg(feature = "embedded_graphics")]
 use embedded_graphics::pixelcolor::{Rgb565, Rgb888};
 
 pub type LvResult<T> = Result<T, LvError>;
@@ -16,18 +13,7 @@ pub enum LvError {
     AlreadyInUse,
 }
 
-impl From<DisplayError> for LvError {
+#[derive(Clone)]
-    fn from(err: DisplayError) -> Self {
-        use LvError::*;
-        match err {
-            DisplayError::NotAvailable => Uninitialized,
-            DisplayError::FailedToRegister => InvalidReference,
-            DisplayError::NotRegistered => Uninitialized,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Default)]
 pub struct Color {
     pub(crate) raw: lvgl_sys::lv_color_t,
 }
@@ -55,7 +41,6 @@ impl Color {
     }
 }
 
-#[cfg(feature = "embedded_graphics")]
 impl From<Color> for Rgb888 {
     fn from(color: Color) -> Self {
         unsafe {
@@ -68,7 +53,6 @@ impl From<Color> for Rgb888 {
     }
 }
 
-#[cfg(feature = "embedded_graphics")]
 impl From<Color> for Rgb565 {
     fn from(color: Color) -> Self {
         unsafe {
@@ -128,23 +112,25 @@ impl<S> TryFrom<lvgl_sys::lv_event_t> for Event<S> {
     type Error = ();
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
+        const LV_EVENT_PRESSED: u32 = lvgl_sys::LV_EVENT_PRESSED as u32;
+        const LV_EVENT_PRESSING: u32 = lvgl_sys::LV_EVENT_PRESSING as u32;
+        const LV_EVENT_PRESS_LOST: u32 = lvgl_sys::LV_EVENT_PRESS_LOST as u32;
+        const LV_EVENT_SHORT_CLICKED: u32 = lvgl_sys::LV_EVENT_SHORT_CLICKED as u32;
+        const LV_EVENT_CLICKED: u32 = lvgl_sys::LV_EVENT_CLICKED as u32;
+        const LV_EVENT_LONG_PRESSED: u32 = lvgl_sys::LV_EVENT_LONG_PRESSED as u32;
+        const LV_EVENT_LONG_PRESSED_REPEAT: u32 = lvgl_sys::LV_EVENT_LONG_PRESSED_REPEAT as u32;
+        const LV_EVENT_RELEASED: u32 = lvgl_sys::LV_EVENT_RELEASED as u32;
+
         match value as u32 {
-            lvgl_sys::LV_EVENT_PRESSED => Ok(Event::Pressed),
+            LV_EVENT_PRESSED => Ok(Event::Pressed),
-            lvgl_sys::LV_EVENT_PRESSING => Ok(Event::Pressing),
+            LV_EVENT_PRESSING => Ok(Event::Pressing),
-            lvgl_sys::LV_EVENT_PRESS_LOST => Ok(Event::PressLost),
+            LV_EVENT_PRESS_LOST => Ok(Event::PressLost),
-            lvgl_sys::LV_EVENT_SHORT_CLICKED => Ok(Event::ShortClicked),
+            LV_EVENT_SHORT_CLICKED => Ok(Event::ShortClicked),
-            lvgl_sys::LV_EVENT_CLICKED => Ok(Event::Clicked),
+            LV_EVENT_CLICKED => Ok(Event::Clicked),
-            lvgl_sys::LV_EVENT_LONG_PRESSED => Ok(Event::LongPressed),
+            LV_EVENT_LONG_PRESSED => Ok(Event::LongPressed),
-            lvgl_sys::LV_EVENT_LONG_PRESSED_REPEAT => Ok(Event::LongPressedRepeat),
+            LV_EVENT_LONG_PRESSED_REPEAT => Ok(Event::LongPressedRepeat),
-            lvgl_sys::LV_EVENT_RELEASED => Ok(Event::Released),
+            LV_EVENT_RELEASED => Ok(Event::Released),
             _ => Err(()),
-            // _ => {
-            //     if let Ok(special_event_type) = S::try_from(value) {
-            //         Ok(Event::Special(special_event_type))
-            //     } else {
-            //         Err(())
-            //     }
-            // }
         }
     }
 }
@@ -217,9 +203,9 @@ pub enum Align {
     OutRightBottom,
 }
 
-impl Into<u8> for Align {
+impl From<Align> for u8 {
-    fn into(self) -> u8 {
+    fn from(self_: Align) -> u8 {
-        let native = match self {
+        let native = match self_ {
             Align::Center => lvgl_sys::LV_ALIGN_CENTER,
             Align::InTopLeft => lvgl_sys::LV_ALIGN_IN_TOP_LEFT,
             Align::InTopMid => lvgl_sys::LV_ALIGN_IN_TOP_MID,
@@ -263,7 +249,6 @@ impl From<Animation> for lvgl_sys::lv_anim_enable_t {
 #[cfg(test)]
 mod test {
     use super::*;
-    use lvgl_sys;
 
     #[test]
     fn color_properties_accessible() {

lvgl/src/ui.rs

@@ -0,0 +1,200 @@
+use crate::Box;
+use crate::{Color, Event, LvError, LvResult, Obj, Widget};
+use core::marker::PhantomData;
+use core::mem::MaybeUninit;
+use core::ptr;
+use core::ptr::NonNull;
+use core::sync::atomic::{AtomicBool, Ordering};
+use core::time::Duration;
+use embedded_graphics::draw_target::DrawTarget;
+use embedded_graphics::prelude::*;
+use embedded_graphics::{pixelcolor::PixelColor, Pixel};
+
+// There can only be a single reference to LVGL library.
+static LVGL_IN_USE: AtomicBool = AtomicBool::new(false);
+
+// TODO: Make this an external configuration
+const REFRESH_BUFFER_LEN: usize = 2;
+// Declare a buffer for the refresh rate
+pub(crate) const BUF_SIZE: usize = lvgl_sys::LV_HOR_RES_MAX as usize * REFRESH_BUFFER_LEN;
+
+pub struct UI<T, C>
+where
+    T: DrawTarget<Color = C>,
+    C: PixelColor + From<Color>,
+{
+    // LVGL is not thread-safe by default.
+    _not_sync: PhantomData<*mut ()>,
+    // Later we can add possibility to have multiple displays by using `heapless::Vec`
+    display_data: Option<DisplayUserData<T, C>>,
+}
+
+// LVGL does not use thread locals.
+unsafe impl<T, C> Send for UI<T, C>
+where
+    T: DrawTarget<Color = C>,
+    C: PixelColor + From<Color>,
+{
+}
+
+impl<T, C> UI<T, C>
+where
+    T: DrawTarget<Color = C>,
+    C: PixelColor + From<Color>,
+{
+    pub fn init() -> LvResult<Self> {
+        if LVGL_IN_USE
+            .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
+            .is_ok()
+        {
+            crate::lvgl_init();
+            Ok(Self {
+                _not_sync: PhantomData,
+                display_data: None,
+            })
+        } else {
+            Err(LvError::AlreadyInUse)
+        }
+    }
+
+    pub fn disp_drv_register(&mut self, display: T) -> LvResult<()> {
+        self.display_data = Some(DisplayUserData {
+            display,
+            phantom: PhantomData,
+        });
+
+        let refresh_buffer1 = [Color::from_rgb((0, 0, 0)).raw; BUF_SIZE];
+        let refresh_buffer2 = [Color::from_rgb((0, 0, 0)).raw; BUF_SIZE];
+
+        let mut disp_buf = MaybeUninit::<lvgl_sys::lv_disp_buf_t>::uninit();
+        let mut disp_drv = MaybeUninit::<lvgl_sys::lv_disp_drv_t>::uninit();
+
+        unsafe {
+            // Initialize the display buffer
+            lvgl_sys::lv_disp_buf_init(
+                disp_buf.as_mut_ptr(),
+                Box::into_raw(Box::new(refresh_buffer1)) as *mut cty::c_void,
+                Box::into_raw(Box::new(refresh_buffer2)) as *mut cty::c_void,
+                lvgl_sys::LV_HOR_RES_MAX * REFRESH_BUFFER_LEN as u32,
+            );
+            // Basic initialization of the display driver
+            lvgl_sys::lv_disp_drv_init(disp_drv.as_mut_ptr());
+            let mut disp_drv = Box::new(disp_drv.assume_init());
+            // Assign the buffer to the display
+            disp_drv.buffer = Box::into_raw(Box::new(disp_buf.assume_init()));
+            // Set your driver function
+            disp_drv.flush_cb = Some(display_callback_wrapper::<T, C>);
+            disp_drv.user_data = &mut self.display_data as *mut _ as *mut cty::c_void;
+            // We need to remember to deallocate the `disp_drv` memory when dropping UI
+            lvgl_sys::lv_disp_drv_register(Box::into_raw(disp_drv));
+        };
+
+        Ok(())
+    }
+
+    pub fn get_display_ref(&self) -> Option<&T> {
+        match self.display_data.as_ref() {
+            None => None,
+            Some(v) => Some(&v.display),
+        }
+    }
+
+    pub fn scr_act(&self) -> LvResult<Obj> {
+        unsafe {
+            let screen = lvgl_sys::lv_disp_get_scr_act(ptr::null_mut());
+            if let Some(v) = NonNull::new(screen) {
+                Ok(Obj::from_raw(v))
+            } else {
+                Err(LvError::InvalidReference)
+            }
+        }
+    }
+
+    pub fn event_send<W>(&mut self, obj: &mut W, event: Event<W::SpecialEvent>) -> LvResult<()>
+    where
+        W: Widget,
+    {
+        unsafe {
+            lvgl_sys::lv_event_send(obj.raw()?.as_mut(), event.into(), ptr::null_mut());
+        }
+        Ok(())
+    }
+
+    pub fn tick_inc(&mut self, tick_period: Duration) {
+        unsafe {
+            lvgl_sys::lv_tick_inc(tick_period.as_millis() as u32);
+        }
+    }
+
+    pub fn task_handler(&mut self) {
+        unsafe {
+            lvgl_sys::lv_task_handler();
+        }
+    }
+}
+
+pub(crate) struct DisplayUserData<T, C>
+where
+    T: DrawTarget<Color = C>,
+    C: PixelColor + From<Color>,
+{
+    display: T,
+    phantom: PhantomData<C>,
+}
+
+unsafe extern "C" fn display_callback_wrapper<T, C>(
+    disp_drv: *mut lvgl_sys::lv_disp_drv_t,
+    area: *const lvgl_sys::lv_area_t,
+    color_p: *mut lvgl_sys::lv_color_t,
+) where
+    T: DrawTarget<Color = C>,
+    C: PixelColor + From<Color>,
+{
+    // In the `std` world we would make sure to capture panics here and make them not escape across
+    // the FFI boundary. Since this library is focused on embedded platforms, we don't
+    // have an standard unwinding mechanism to rely upon.
+    let display_driver = *disp_drv;
+    // Rust code closure reference
+    if !display_driver.user_data.is_null() {
+        let user_data = &mut *(display_driver.user_data as *mut DisplayUserData<T, C>);
+        let x1 = (*area).x1;
+        let x2 = (*area).x2;
+        let y1 = (*area).y1;
+        let y2 = (*area).y2;
+        // TODO: Can we do anything when there is a error while flushing?
+        let _ = display_flush(&mut user_data.display, (x1, x2), (y1, y2), color_p);
+    }
+    // Indicate to LVGL that we are ready with the flushing
+    lvgl_sys::lv_disp_flush_ready(disp_drv);
+}
+
+// We separate this display flush function to reduce the amount of unsafe code we need to write.
+// This also provides a good separation of concerns, what is necessary from LVGL to work and
+// what is the lvgl-rs wrapper responsibility.
+fn display_flush<T, C>(
+    display: &mut T,
+    (x1, x2): (i16, i16),
+    (y1, y2): (i16, i16),
+    color_p: *mut lvgl_sys::lv_color_t,
+) -> Result<(), T::Error>
+where
+    T: DrawTarget<Color = C>,
+    C: PixelColor + From<Color>,
+{
+    let ys = y1..=y2;
+    let xs = (x1..=x2).enumerate();
+    let x_len = (x2 - x1 + 1) as usize;
+
+    // We use iterators here to ensure that the Rust compiler can apply all possible
+    // optimizations at compile time.
+    let pixels = ys.enumerate().flat_map(|(iy, y)| {
+        xs.clone().map(move |(ix, x)| {
+            let color_len = x_len * iy + ix;
+            let lv_color = unsafe { *color_p.add(color_len) };
+            let raw_color = Color::from_raw(lv_color);
+            Pixel(Point::new(x as i32, y as i32), raw_color.into())
+        })
+    });
+
+    display.draw_iter(pixels)
+}

lvgl/src/widgets/label.rs

@@ -10,37 +10,6 @@ impl Label {
     }
 }
 
-#[cfg(feature = "alloc")]
-mod alloc_imp {
-    use crate::widgets::Label;
-    use crate::LvError;
-    use cstr_core::CString;
-    use core::convert::TryFrom;
-
-    impl<S: AsRef<str>> From<S> for Label {
-        fn from(text: S) -> Self {
-            // text.try_into().unwrap()
-            let text_cstr = CString::new(text.as_ref()).unwrap();
-            let mut label = Label::new().unwrap();
-            label.set_text(text_cstr.as_c_str()).unwrap();
-            label
-        }
-    }
-
-    // Issue link: https://github.com/rust-lang/rust/issues/50133
-    //
-    // impl<S: AsRef<str>> TryFrom<S> for Label {
-    //     type Error = LvError;
-    //     fn try_from(text: S) -> Result<Self, Self::Error> {
-    //         let text_cstr = CString::new(text.as_ref())?;
-    //         let mut label = Label::new()?;
-    //         label.set_text(text_cstr.as_c_str())?;
-    //         Ok(label)
-    //     }
-    // }
-}
-
-
 #[derive(Debug, Copy, Clone, PartialEq)]
 #[repr(u8)]
 pub enum LabelAlign {