diff --git a/.gitmodules b/.gitmodules index 4bf4baf..13afe4f 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ [submodule "lvgl-sys/vendor/lvgl"] path = lvgl-sys/vendor/lvgl - url = https://github.com/littlevgl/lvgl.git + url = https://github.com/lvgl/lvgl.git diff --git a/Cargo.toml b/Cargo.toml index 491624a..4f3767e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,5 +2,6 @@ members = [ "lvgl", "lvgl-sys", + "lvgl-codegen", "examples" ] diff --git a/README.md b/README.md index 1c71325..2a77455 100644 --- a/README.md +++ b/README.md @@ -94,35 +94,36 @@ List of LVGL features that impacts the library usage in general. - [ ] Arc (lv_arc) - [x] Bar (lv_bar) - [x] Button (lv_btn) -- [ ] Button matrix (lv_btnm) +- [ ] Button matrix (lv_btnmatrix) - [ ] Calendar (lv_calendar) - [ ] Canvas (lv_canvas) - [ ] Checkbox (lv_cb) - [ ] Chart (lv_chart) - [ ] Container (lv_cont) - [ ] Color picker (lv_cpicker) -- [ ] Drop-down list (lv_ddlist) +- [ ] Drop-down list (lv_dropdown) - [ ] Gauge (lv_gauge) - [ ] Image (lv_img) - [ ] Image button (lv_imgbtn) -- [ ] Keyboard (lv_kb) +- [ ] Keyboard (lv_keyboard) - [x] Label (lv_label) - [ ] LED (lv_led) - [ ] Line (lv_line) - [ ] List (lv_list) - [ ] Line meter (lv_lmeter) -- [ ] Message box (lv_mbox) +- [ ] Message box (lv_msdbox) +- [ ] Object mask (lv_objmask) - [ ] Page (lv_page) -- [ ] Preloader (lv_preload) - [ ] Roller (lv_roller) - [ ] Slider (lv_slider) - [ ] Spinbox (lv_spinbox) -- [ ] Switch (lv_sw) +- [ ] Spinner (lv_spinner) +- [ ] Switch (lv_switch) - [ ] Table (lv_table) - [ ] Tabview (lv_tabview) -- [ ] Text area (lv_ta) +- [ ] Text area (lv_textarea) - [ ] Tile view (lv_tileview) -- [ ] Window (lv_win) +- [ ] Window (lv_wn- [ ] Widgets currently implemented might have some missing features. If the widget you want to use is not exposed or is missing a feature you want to make use, please send a Pull Request or open an issue. diff --git a/examples/bar.rs b/examples/bar.rs index 52b2ac7..99aaac6 100644 --- a/examples/bar.rs +++ b/examples/bar.rs @@ -3,8 +3,9 @@ use embedded_graphics::prelude::*; use embedded_graphics_simulator::{ OutputSettingsBuilder, SimulatorDisplay, SimulatorEvent, Window, }; -use lvgl::widgets::{Bar, BarComponent, Label, LabelAlign}; -use lvgl::{self, Align, Animation, Border, Color, DisplayDriver, Event, Object, Style, UI}; +use lvgl::style::Style; +use lvgl::widgets::{Bar, BarPart, Label, LabelAlign}; +use lvgl::{self, Align, Animation, Color, DisplayDriver, Event, ObjPart, Object, State, UI}; use lvgl_sys; use std::sync::{mpsc, Arc, Mutex}; use std::thread::sleep; @@ -29,32 +30,20 @@ fn main() -> Result<(), String> { let mut screen = ui.scr_act(); let mut screen_style = Style::default(); - screen_style.set_body_main_color(Color::from_rgb((255, 255, 255))); - screen_style.set_body_grad_color(Color::from_rgb((255, 255, 255))); - screen_style.set_body_radius(0); - screen.set_style(screen_style); + screen_style.set_bg_color(State::DEFAULT, Color::from_rgb((255, 255, 255))); + screen_style.set_radius(State::DEFAULT, 0); + screen.add_style(ObjPart::Main, screen_style); // Create the bar object let mut bar = Bar::new(&mut screen); - bar.set_size(175, 50); - bar.set_align(&mut screen, Align::Center, 0, 20); + bar.set_size(175, 20); + bar.set_align(&mut screen, Align::Center, 0, 10); bar.set_range(0, 100); - bar.set_value(0, Animation::OFF); - // Set the indicator style for the bar object + // // Set the indicator style for the bar object let mut ind_style = Style::default(); - ind_style.set_body_main_color(Color::from_rgb((100, 245, 0))); - ind_style.set_body_grad_color(Color::from_rgb((100, 245, 0))); - bar.set_bar_style(BarComponent::Indicator, ind_style); - - // Set the background style for the bar object - let mut bg_style = Style::default(); - bg_style.set_body_grad_color(Color::from_rgb((255, 255, 255))); - bg_style.set_body_main_color(Color::from_rgb((255, 255, 255))); - bg_style.set_body_radius(0); - bg_style.set_body_border_part(Border::TOP); - bg_style.set_body_border_width(1); - bar.set_bar_style(BarComponent::Background, bg_style); + ind_style.set_bg_color(State::DEFAULT, Color::from_rgb((100, 245, 100))); + bar.add_style(BarPart::Indicator, ind_style); let mut loading_lbl = Label::new(&mut screen); loading_lbl.set_text("Loading..."); @@ -62,8 +51,8 @@ fn main() -> Result<(), String> { loading_lbl.set_label_align(LabelAlign::Center); let mut loading_style = Style::default(); - loading_style.set_text_color(Color::from_rgb((0, 0, 0))); - loading_lbl.set_style(loading_style); + loading_style.set_text_color(State::DEFAULT, Color::from_rgb((0, 0, 0))); + loading_lbl.add_style(ObjPart::Main, loading_style); let threaded_ui = Arc::new(Mutex::new(ui)); diff --git a/examples/button_click.rs b/examples/button_click.rs index 66fe3b8..535eaf7 100644 --- a/examples/button_click.rs +++ b/examples/button_click.rs @@ -3,8 +3,9 @@ use embedded_graphics::prelude::*; use embedded_graphics_simulator::{ OutputSettingsBuilder, SimulatorDisplay, SimulatorEvent, Window, }; +use lvgl::style::Style; use lvgl::widgets::{Button, Label}; -use lvgl::{self, Align, Color, DisplayDriver, Event, Object, Style, UI}; +use lvgl::{self, Align, Color, DisplayDriver, Event, ObjPart, Object, State, UI}; use lvgl_sys; use std::sync::{mpsc, Arc, Mutex}; use std::thread::sleep; @@ -29,10 +30,8 @@ fn main() -> Result<(), String> { let mut screen = ui.scr_act(); let mut screen_style = Style::default(); - screen_style.set_body_main_color(Color::from_rgb((0, 0, 0))); - screen_style.set_body_grad_color(Color::from_rgb((0, 0, 0))); - screen_style.set_body_radius(0); - screen.set_style(screen_style); + screen_style.set_bg_color(State::DEFAULT, Color::from_rgb((0, 0, 0))); + screen.add_style(ObjPart::Main, screen_style); // Create the button let mut button = Button::new(&mut screen); diff --git a/examples/demo.rs b/examples/demo.rs index d123402..61468c3 100644 --- a/examples/demo.rs +++ b/examples/demo.rs @@ -4,8 +4,9 @@ use embedded_graphics_simulator::{ OutputSettingsBuilder, SimulatorDisplay, SimulatorEvent, Window, }; use lvgl; +use lvgl::style::Style; use lvgl::widgets::{Label, LabelAlign}; -use lvgl::{Align, Color, Object, Style, UI}; +use lvgl::{Align, Color, ObjPart, Object, State, UI}; use lvgl_sys; use std::sync::{mpsc, Arc, Mutex}; use std::thread::sleep; @@ -29,30 +30,29 @@ fn main() -> Result<(), String> { // Create screen and widgets let mut screen = ui.scr_act(); - let font_roboto_28 = unsafe { &lvgl_sys::lv_font_roboto_28 }; + let font_roboto_28 = unsafe { &lvgl_sys::lv_theme_get_font_normal() }; let font_noto_sans_numeric_28 = unsafe { ¬o_sans_numeric_80 }; - let mut screen_style = Default::default(); - screen_style.set_body_main_color(Color::from_rgb((0, 0, 0))); - screen_style.set_body_grad_color(Color::from_rgb((0, 0, 0))); - screen_style.set_body_radius(0); - screen.set_style(screen_style); + 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(ObjPart::Main, screen_style); let mut time = Label::new(&mut screen); - let mut style_time = Default::default(); - style_time.set_text_font(font_noto_sans_numeric_28); - style_time.set_text_color(lvgl::Color::from_rgb((255, 255, 255))); - time.set_style(style_time); - time.set_align(&mut screen, Align::InLeftMid, 20, 0); + let mut style_time = Style::default(); + //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(ObjPart::Main, style_time); + time.set_align(&mut screen, Align::Center, 0, 0); time.set_text("20:46"); time.set_width(240); time.set_height(240); let mut bt = Label::new(&mut screen); - let mut style_bt = Default::default(); - style_bt.set_text_font(font_roboto_28); + let mut style_bt = Style::default(); + //style_bt.set_text_font(font_roboto_28); let style_power = style_bt.clone(); - bt.set_style(style_bt); + bt.add_style(ObjPart::Main, style_bt); bt.set_width(50); bt.set_height(80); bt.set_recolor(true); @@ -61,7 +61,7 @@ fn main() -> Result<(), String> { bt.set_align(&mut screen, Align::InTopLeft, 0, 0); let mut power = Label::new(&mut screen); - power.set_style(style_power); + power.add_style(ObjPart::Main, style_power); power.set_recolor(true); power.set_width(80); power.set_height(20); diff --git a/examples/include/lv_conf.h b/examples/include/lv_conf.h index 605db54..6fe446c 100644 --- a/examples/include/lv_conf.h +++ b/examples/include/lv_conf.h @@ -1,3 +1,14 @@ +/** + * @file lv_conf.h + * + */ + +/* + * COPY THIS FILE AS `lv_conf.h` NEXT TO the `lvgl` FOLDER + */ + +#if 1 /*Set it to "1" to enable content*/ + #ifndef LV_CONF_H #define LV_CONF_H /* clang-format off */ @@ -14,7 +25,7 @@ /* Color depth: * - 1: 1 byte per pixel - * - 8: RGB233 + * - 8: RGB332 * - 16: RGB565 * - 32: ARGB8888 */ @@ -32,9 +43,6 @@ /*Images pixels with this color will not be drawn (with chroma keying)*/ #define LV_COLOR_TRANSP LV_COLOR_LIME /*LV_COLOR_LIME: pure green*/ -/* Enable chroma keying for indexed images. */ -#define LV_INDEXED_CHROMA 1 - /* Enable anti-aliasing (lines, and radiuses will be smoothed) */ #define LV_ANTIALIAS 1 @@ -45,7 +53,18 @@ /* Dot Per Inch: used to initialize default sizes. * E.g. a button with width = LV_DPI / 2 -> half inch wide * (Not so important, you can adjust it to modify default sizes and spaces)*/ -#define LV_DPI 298 /*[px]*/ +#define LV_DPI 130 /*[px]*/ + +/* The the real width of the display changes some default values: + * default object sizes, layout of examples, etc. + * According to the width of the display (hor. res. / dpi) + * the displays fall in 4 categories. + * The 4th is extra large which has no upper limit so not listed here + * The upper limit of the categories are set below in 0.1 inch unit. + */ +#define LV_DISP_SMALL_LIMIT 30 +#define LV_DISP_MEDIUM_LIMIT 50 +#define LV_DISP_LARGE_LIMIT 70 /* Type of coordinates. Should be `int16_t` (or `int32_t` for extreme cases) */ typedef int16_t lv_coord_t; @@ -61,7 +80,7 @@ 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 (4U * 1024U) +# define LV_MEM_SIZE (32U * 1024U) /* Complier prefix for a big array declaration */ # define LV_MEM_ATTR @@ -101,7 +120,7 @@ typedef int16_t lv_coord_t; #define LV_INDEV_DEF_DRAG_LIMIT 10 /* Drag throw slow-down in [%]. Greater value -> faster slow-down */ -#define LV_INDEV_DEF_DRAG_THROW 20 +#define LV_INDEV_DEF_DRAG_THROW 10 /* Long press time in milliseconds. * Time to send `LV_EVENT_LONG_PRESSSED`) */ @@ -111,6 +130,13 @@ typedef int16_t lv_coord_t; * 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 + +/* Gesture min velocity at release before swipe (pixels)*/ +#define LV_INDEV_DEF_GESTURE_MIN_VELOCITY 3 + /*================== * Feature usage *==================*/ @@ -126,6 +152,22 @@ typedef void * lv_anim_user_data_t; /* 1: Enable shadow drawing*/ #define LV_USE_SHADOW 1 +#if LV_USE_SHADOW +/* Allow buffering some shadow calculation + * LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer, + * where shadow size is `shadow_width + radius` + * Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/ +#define LV_SHADOW_CACHE_SIZE 0 +#endif + +/* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/ +#define LV_USE_BLEND_MODES 1 + +/* 1: Use the `opa_scale` style property to set the opacity of an object and its children at once*/ +#define LV_USE_OPA_SCALE 1 + +/* 1: Use image zoom and rotation*/ +#define LV_USE_IMG_TRANSFORM 1 /* 1: Enable object groups (for keyboard/encoder navigation) */ #define LV_USE_GROUP 1 @@ -134,10 +176,11 @@ typedef void * lv_group_user_data_t; #endif /*LV_USE_GROUP*/ /* 1: Enable GPU interface*/ -#define LV_USE_GPU 0 +#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 /* 1: Enable file system (might be required for images */ -#define LV_USE_FILESYSTEM 0 +#define LV_USE_FILESYSTEM 1 #if LV_USE_FILESYSTEM /*Declare the type of the user data of file system drivers (can be e.g. `void *`, `int`, `struct`)*/ typedef void * lv_fs_drv_user_data_t; @@ -146,6 +189,12 @@ typedef void * lv_fs_drv_user_data_t; /*1: Add a `user_data` to drivers and objects*/ #define LV_USE_USER_DATA 1 +/*1: Show CPU usage and FPS count in the right bottom corner*/ +#define LV_USE_PERF_MONITOR 0 + +/*1: Use the functions and types from the older API if possible */ +#define LV_USE_API_EXTENSION_V6 1 + /*======================== * Image decoder and cache *========================*/ @@ -176,6 +225,9 @@ typedef void * lv_img_decoder_user_data_t; /* Define a custom attribute to `lv_task_handler` function */ #define LV_ATTRIBUTE_TASK_HANDLER +/* Define a custom attribute to `lv_disp_flush_ready` function */ +#define LV_ATTRIBUTE_FLUSH_READY + /* With size optimization (-Os) the compiler might not align data to * 4 or 8 byte boundary. This alignment will be explicitly applied where needed. * E.g. __attribute__((aligned(4))) */ @@ -185,6 +237,10 @@ typedef void * lv_img_decoder_user_data_t; * font's bitmaps */ #define LV_ATTRIBUTE_LARGE_CONST +/* Prefix performance critical functions to place them into a faster memory (e.g RAM) + * Uses 15-20 kB extra memory */ +#define LV_ATTRIBUTE_FAST_MEM + /* Export integer constant to binding. * This macro is used with constants in the form of LV_ that * should also appear on lvgl binding API such as Micropython @@ -242,7 +298,7 @@ typedef void * lv_indev_drv_user_data_t; /*Type of user data in the i * The behavior of asserts can be overwritten by redefining them here. * E.g. #define LV_ASSERT_MEM(p) */ -#define LV_USE_DEBUG 0 +#define LV_USE_DEBUG 1 #if LV_USE_DEBUG /*Check if the parameter is NULL. (Quite fast) */ @@ -251,6 +307,9 @@ typedef void * lv_indev_drv_user_data_t; /*Type of user data in the i /*Checks is the memory is successfully allocated or no. (Quite fast)*/ #define LV_USE_ASSERT_MEM 1 +/*Check the integrity of `lv_mem` after critical operations. (Slow)*/ +#define LV_USE_ASSERT_MEM_INTEGRITY 0 + /* Check the strings. * Search for NULL, very long strings, invalid characters, and unnatural repetitions. (Slow) * If disabled `LV_USE_ASSERT_NULL` will be performed instead (if it's enabled) */ @@ -261,44 +320,47 @@ typedef void * lv_indev_drv_user_data_t; /*Type of user data in the i #define LV_USE_ASSERT_OBJ 0 /*Check if the styles are properly initialized. (Fast)*/ -#define LV_USE_ASSERT_STYLE 1 +#define LV_USE_ASSERT_STYLE 0 #endif /*LV_USE_DEBUG*/ -/*================ - * THEME USAGE - *================*/ -#define LV_THEME_LIVE_UPDATE 0 /*1: Allow theme switching at run time. Uses 8..10 kB of RAM*/ - -#define LV_USE_THEME_TEMPL 0 /*Just for test*/ -#define LV_USE_THEME_DEFAULT 0 /*Built mainly from the built-in styles. Consumes very few RAM*/ -#define LV_USE_THEME_ALIEN 0 /*Dark futuristic theme*/ -#define LV_USE_THEME_NIGHT 0 /*Dark elegant theme*/ -#define LV_USE_THEME_MONO 0 /*Mono color theme for monochrome displays*/ -#define LV_USE_THEME_MATERIAL 0 /*Flat theme with bold colors and light shadows*/ -#define LV_USE_THEME_ZEN 0 /*Peaceful, mainly light theme */ -#define LV_USE_THEME_NEMO 0 /*Water-like theme based on the movie "Finding Nemo"*/ - /*================== * FONT USAGE *===================*/ /* 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.littlevgl.com/#Fonts - * To create a new font go to: https://littlevgl.com/ttf-font-to-c-array + * More info about fonts: https://docs.lvgl.com/#Fonts + * To create a new font go to: https://lvgl.com/ttf-font-to-c-array */ -/* Robot fonts with bpp = 4 - * https://fonts.google.com/specimen/Roboto */ -#define LV_FONT_ROBOTO_12 0 -#define LV_FONT_ROBOTO_16 0 -#define LV_FONT_ROBOTO_22 0 -#define LV_FONT_ROBOTO_28 1 +/* Montserrat fonts with bpp = 4 + * https://fonts.google.com/specimen/Montserrat */ +#define LV_FONT_MONTSERRAT_12 0 +#define LV_FONT_MONTSERRAT_14 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 +#define LV_FONT_MONTSERRAT_24 0 +#define LV_FONT_MONTSERRAT_26 0 +#define LV_FONT_MONTSERRAT_28 0 +#define LV_FONT_MONTSERRAT_30 0 +#define LV_FONT_MONTSERRAT_32 0 +#define LV_FONT_MONTSERRAT_34 0 +#define LV_FONT_MONTSERRAT_36 0 +#define LV_FONT_MONTSERRAT_38 0 +#define LV_FONT_MONTSERRAT_40 0 +#define LV_FONT_MONTSERRAT_42 0 +#define LV_FONT_MONTSERRAT_44 0 +#define LV_FONT_MONTSERRAT_46 0 +#define LV_FONT_MONTSERRAT_48 0 /* Demonstrate special features */ -#define LV_FONT_ROBOTO_12_SUBPX 1 -#define LV_FONT_ROBOTO_28_COMPRESSED 1 /*bpp = 3*/ +#define LV_FONT_MONTSERRAT_12_SUBPX 0 +#define LV_FONT_MONTSERRAT_28_COMPRESSED 0 /*bpp = 3*/ +#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0 /*Hebrew, Arabic, PErisan letters and all their forms*/ +#define LV_FONT_SIMSUN_16_CJK 0 /*1000 most common CJK radicals*/ /*Pixel perfect monospace font * http://pelulamu.net/unscii/ */ @@ -312,9 +374,6 @@ typedef void * lv_indev_drv_user_data_t; /*Type of user data in the i */ #define LV_FONT_CUSTOM_DECLARE -/*Always set a default font from the built-in fonts*/ -#define LV_FONT_DEFAULT &lv_font_roboto_28 - /* Enable it if you have fonts with a lot of characters. * The limit depends on the font size, font face and bpp * but with > 10,000 characters if you see issues probably you need to enable it.*/ @@ -329,6 +388,43 @@ typedef void * lv_indev_drv_user_data_t; /*Type of user data in the i /*Declare the type of the user data of fonts (can be e.g. `void *`, `int`, `struct`)*/ typedef void * lv_font_user_data_t; +/*================ + * THEME USAGE + *================*/ + +/*Always enable at least on theme*/ + +/* No theme, you can apply your styles as you need + * No flags. Set LV_THEME_DEFAULT_FLAG 0 */ + #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 + +/* A fast and impressive theme. + * Flags: + * LV_THEME_MATERIAL_FLAG_LIGHT: light theme + * LV_THEME_MATERIAL_FLAG_DARK: dark theme*/ + #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_THEME_DEFAULT_INCLUDE /*Include a header for the init. function*/ +#define LV_THEME_DEFAULT_INIT lv_theme_material_init +#define LV_THEME_DEFAULT_COLOR_PRIMARY LV_COLOR_RED +#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_16 +#define LV_THEME_DEFAULT_FONT_NORMAL &lv_font_montserrat_16 +#define LV_THEME_DEFAULT_FONT_SUBTITLE &lv_font_montserrat_16 +#define LV_THEME_DEFAULT_FONT_TITLE &lv_font_montserrat_16 + /*================= * Text settings *=================*/ @@ -340,13 +436,12 @@ typedef void * lv_font_user_data_t; * */ #define LV_TXT_ENC LV_TXT_ENC_UTF8 -/*Can break (wrap) texts on these chars*/ + /*Can break (wrap) texts on these chars*/ #define LV_TXT_BREAK_CHARS " ,.;:-_" - /* If a word is at least this long, will break wherever "prettiest" * To disable, set to a value <= 0 */ -#define LV_TXT_LINE_BREAK_LONG_LEN 12 +#define LV_TXT_LINE_BREAK_LONG_LEN 0 /* Minimum number of characters in a long word to put on a line before a break. * Depends on LV_TXT_LINE_BREAK_LONG_LEN. */ @@ -372,20 +467,36 @@ typedef void * lv_font_user_data_t; #define LV_BIDI_BASE_DIR_DEF LV_BIDI_DIR_AUTO #endif +/* Enable Arabic/Persian processing + * In these languages characters should be replaced with + * an other form based on their position in the text */ +#define LV_USE_ARABIC_PERSIAN_CHARS 0 + /*Change the built in (v)snprintf functions*/ #define LV_SPRINTF_CUSTOM 0 #if LV_SPRINTF_CUSTOM # define LV_SPRINTF_INCLUDE # define lv_snprintf snprintf # define lv_vsnprintf vsnprintf +#else /*!LV_SPRINTF_CUSTOM*/ +# define LV_SPRINTF_DISABLE_FLOAT 1 #endif /*LV_SPRINTF_CUSTOM*/ /*=================== * LV_OBJ SETTINGS *==================*/ +#if LV_USE_USER_DATA /*Declare the type of the user data of object (can be e.g. `void *`, `int`, `struct`)*/ typedef void * lv_obj_user_data_t; +/*Provide a function to free user data*/ +#define LV_USE_USER_DATA_FREE 0 +#if LV_USE_USER_DATA_FREE +# define LV_USER_DATA_FREE_INCLUDE "something.h" /*Header for user data free function*/ +/* Function prototype : void user_data_free(lv_obj_t * obj); */ +# define LV_USER_DATA_FREE (user_data_free) /*Invoking for user data free function*/ +#endif +#endif /*1: enable `lv_obj_realaign()` based on `lv_obj_align()` parameters*/ #define LV_USE_OBJ_REALIGN 1 @@ -395,13 +506,13 @@ typedef void * lv_obj_user_data_t; * LV_EXT_CLICK_AREA_TINY: The extra area can be adjusted horizontally and vertically (0..255 px) * LV_EXT_CLICK_AREA_FULL: The extra area can be adjusted in all 4 directions (-32k..+32k px) */ -#define LV_USE_EXT_CLICK_AREA LV_EXT_CLICK_AREA_OFF +#define LV_USE_EXT_CLICK_AREA LV_EXT_CLICK_AREA_TINY /*================== * LV OBJ X USAGE *================*/ /* - * Documentation of the object types: https://docs.littlevgl.com/#Object-types + * Documentation of the object types: https://docs.lvgl.com/#Object-types */ /*Arc (dependencies: -)*/ @@ -412,13 +523,9 @@ typedef void * lv_obj_user_data_t; /*Button (dependencies: lv_cont*/ #define LV_USE_BTN 1 -#if LV_USE_BTN != 0 -/*Enable button-state animations - draw a circle on click (dependencies: LV_USE_ANIMATION)*/ -# define LV_BTN_INK_EFFECT 0 -#endif /*Button matrix (dependencies: -)*/ -#define LV_USE_BTNM 1 +#define LV_USE_BTNMATRIX 1 /*Calendar (dependencies: -)*/ #define LV_USE_CALENDAR 1 @@ -427,12 +534,12 @@ typedef void * lv_obj_user_data_t; #define LV_USE_CANVAS 1 /*Check box (dependencies: lv_btn, lv_label)*/ -#define LV_USE_CB 1 +#define LV_USE_CHECKBOX 1 /*Chart (dependencies: -)*/ #define LV_USE_CHART 1 #if LV_USE_CHART -# define LV_CHART_AXIS_TICK_LABEL_MAX_LEN 20 +# define LV_CHART_AXIS_TICK_LABEL_MAX_LEN 256 #endif /*Container (dependencies: -*/ @@ -442,13 +549,13 @@ typedef void * lv_obj_user_data_t; #define LV_USE_CPICKER 1 /*Drop down list (dependencies: lv_page, lv_label, lv_symbol_def.h)*/ -#define LV_USE_DDLIST 1 -#if LV_USE_DDLIST != 0 +#define LV_USE_DROPDOWN 1 +#if LV_USE_DROPDOWN != 0 /*Open and close default animation time [ms] (0: no animation)*/ -# define LV_DDLIST_DEF_ANIM_TIME 200 +# define LV_DROPDOWN_DEF_ANIM_TIME 200 #endif -/*Gauge (dependencies:lv_bar, lv_lmeter)*/ +/*Gauge (dependencies:lv_bar, lv_linemeter)*/ #define LV_USE_GAUGE 1 /*Image (dependencies: lv_label*/ @@ -462,7 +569,7 @@ typedef void * lv_obj_user_data_t; #endif /*Keyboard (dependencies: lv_btnm)*/ -#define LV_USE_KB 1 +#define LV_USE_KEYBOARD 1 /*Label (dependencies: -*/ #define LV_USE_LABEL 1 @@ -482,6 +589,10 @@ typedef void * lv_obj_user_data_t; /*LED (dependencies: -)*/ #define LV_USE_LED 1 +#if LV_USE_LED +# define LV_LED_BRIGHT_MIN 120 /*Minimal brightness*/ +# define LV_LED_BRIGHT_MAX 255 /*Maximal brightness*/ +#endif /*Line (dependencies: -*/ #define LV_USE_LINE 1 @@ -494,10 +605,22 @@ typedef void * lv_obj_user_data_t; #endif /*Line meter (dependencies: *;)*/ -#define LV_USE_LMETER 1 +#define LV_USE_LINEMETER 1 +#if LV_USE_LINEMETER +/* Draw line more precisely at cost of performance. + * Useful if there are lot of lines any minor are visible + * 0: No extra precision + * 1: Some extra precision + * 2: Best precision + */ +# define LV_LINEMETER_PRECISE 0 +#endif + +/*Mask (dependencies: -)*/ +#define LV_USE_OBJMASK 1 /*Message box (dependencies: lv_rect, lv_btnm, lv_label)*/ -#define LV_USE_MBOX 1 +#define LV_USE_MSGBOX 1 /*Page (dependencies: lv_cont)*/ #define LV_USE_PAGE 1 @@ -507,11 +630,11 @@ typedef void * lv_obj_user_data_t; #endif /*Preload (dependencies: lv_arc, lv_anim)*/ -#define LV_USE_PRELOAD 1 -#if LV_USE_PRELOAD != 0 -# define LV_PRELOAD_DEF_ARC_LENGTH 60 /*[deg]*/ -# define LV_PRELOAD_DEF_SPIN_TIME 1000 /*[ms]*/ -# define LV_PRELOAD_DEF_ANIM LV_PRELOAD_TYPE_SPINNING_ARC +#define LV_USE_SPINNER 1 +#if LV_USE_SPINNER != 0 +# define LV_SPINNER_DEF_ARC_LENGTH 60 /*[deg]*/ +# define LV_SPINNER_DEF_SPIN_TIME 1000 /*[ms]*/ +# define LV_SPINNER_DEF_ANIM LV_SPINNER_TYPE_SPINNING_ARC #endif /*Roller (dependencies: lv_ddlist)*/ @@ -531,13 +654,13 @@ typedef void * lv_obj_user_data_t; #define LV_USE_SPINBOX 1 /*Switch (dependencies: lv_slider)*/ -#define LV_USE_SW 1 +#define LV_USE_SWITCH 1 /*Text area (dependencies: lv_label, lv_page)*/ -#define LV_USE_TA 1 -#if LV_USE_TA != 0 -# define LV_TA_DEF_CURSOR_BLINK_TIME 400 /*ms*/ -# define LV_TA_DEF_PWD_SHOW_TIME 1500 /*ms*/ +#define LV_USE_TEXTAREA 1 +#if LV_USE_TEXTAREA != 0 +# define LV_TEXTAREA_DEF_CURSOR_BLINK_TIME 400 /*ms*/ +# define LV_TEXTAREA_DEF_PWD_SHOW_TIME 1500 /*ms*/ #endif /*Table (dependencies: lv_label)*/ @@ -573,7 +696,6 @@ typedef void * lv_obj_user_data_t; /*--END OF LV_CONF_H--*/ -/*Be sure every define has a default value*/ -#include "lvgl/src/lv_conf_checker.h" - #endif /*LV_CONF_H*/ + +#endif /*End of "Content enable"*/ diff --git a/lvgl-codegen/Cargo.toml b/lvgl-codegen/Cargo.toml new file mode 100644 index 0000000..a2781c0 --- /dev/null +++ b/lvgl-codegen/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "lvgl-codegen" +version = "0.1.0" +authors = ["Rafael Caricio "] +edition = "2018" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +tera = "1.3.0" +regex = "1.3.9" diff --git a/lvgl-codegen/src/main.rs b/lvgl-codegen/src/main.rs new file mode 100644 index 0000000..4659e47 --- /dev/null +++ b/lvgl-codegen/src/main.rs @@ -0,0 +1,35 @@ +use regex::Regex; +use tera::{Context, Tera}; + +fn main() { + let re = Regex::new(r"\((?P[^,]+), (?P[^,]+), (?P[^,]+), (?P[^)]+), [a-z]+\)").unwrap(); + + let input = include_str!("../../lvgl-sys/vendor/lvgl/src/lv_core/lv_obj_style_dec.h"); + + let mut tera = Tera::default(); + tera.add_raw_template("styles.rs", include_str!("../templates/style.rs.j2")) + .unwrap(); + + for line in input.lines() { + if !line.starts_with("_LV_OBJ_STYLE_SET_GET_DECLARE") { + continue; + } + + if let Some(cap) = re.captures(line) { + let style_type = cap.get(4).unwrap().as_str().to_string(); + if style_type.eq("_ptr") { + // Just a few, we will take care of this manually. + continue; + } + + let value_type = cap.get(3).unwrap().as_str().to_string(); + + let mut ctx = Context::new(); + ctx.insert("prop_name", cap.get(1).unwrap().as_str()); + ctx.insert("func_name", cap.get(2).unwrap().as_str()); + ctx.insert("value_type", value_type.as_str()); + ctx.insert("style_type", style_type.as_str()); + println!("{}", tera.render("styles.rs", &ctx).unwrap()); + } + } +} diff --git a/lvgl-codegen/templates/style.rs.j2 b/lvgl-codegen/templates/style.rs.j2 new file mode 100644 index 0000000..8b9a287 --- /dev/null +++ b/lvgl-codegen/templates/style.rs.j2 @@ -0,0 +1,33 @@ +pub fn set_{{func_name}}(&mut self, state: State, + + {% if style_type == "_color" %} + value: Color + {% elif style_type == "_int" %} + value: i16 + {% elif style_type == "_ptr" %} + value: Any + {% elif style_type == "_opa" %} + value: u8 + {% endif %} + +) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set{{style_type}}( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_{{prop_name}} + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + + {% if style_type == "_color" %} + value.raw, + {% elif style_type == "_int" %} + value + {% elif style_type == "_opa" %} + value + {% elif style_type == "_ptr" %} + value.into() + {% endif %} + + ); + } +} diff --git a/lvgl-sys/build.rs b/lvgl-sys/build.rs index c4186af..005a296 100644 --- a/lvgl-sys/build.rs +++ b/lvgl-sys/build.rs @@ -47,11 +47,11 @@ fn main() { add_c_files(&mut cfg, vendor_src.join("lv_core")); add_c_files(&mut cfg, vendor_src.join("lv_draw")); add_c_files(&mut cfg, vendor_src.join("lv_font")); + add_c_files(&mut cfg, vendor_src.join("lv_gpu")); add_c_files(&mut cfg, vendor_src.join("lv_hal")); add_c_files(&mut cfg, vendor_src.join("lv_misc")); - add_c_files(&mut cfg, vendor_src.join("lv_objx")); - add_c_files(&mut cfg, vendor_src.join("lv_themes")); add_c_files(&mut cfg, vendor_src.join("lv_themes")); + add_c_files(&mut cfg, vendor_src.join("lv_widgets")); add_c_files(&mut cfg, &lv_config_dir); add_c_files(&mut cfg, &shims_dir); diff --git a/lvgl-sys/vendor/lvgl b/lvgl-sys/vendor/lvgl index 9eeaf61..91b9977 160000 --- a/lvgl-sys/vendor/lvgl +++ b/lvgl-sys/vendor/lvgl @@ -1 +1 @@ -Subproject commit 9eeaf61fa7ec2b5ea151374b135b85f15438938c +Subproject commit 91b997769e7a2b7eb410371725b1e3a7cb6ecde8 diff --git a/lvgl/src/lib.rs b/lvgl/src/lib.rs index 75fd41e..5fd1cf1 100644 --- a/lvgl/src/lib.rs +++ b/lvgl/src/lib.rs @@ -6,10 +6,12 @@ extern crate bitflags; mod display; mod global; -#[macro_use] mod support; +#[macro_use] +mod lv_core; pub mod widgets; pub use display::DisplayDriver; pub use global::{LvError, UI}; +pub use lv_core::*; pub use support::*; diff --git a/lvgl/src/lv_core/mod.rs b/lvgl/src/lv_core/mod.rs new file mode 100644 index 0000000..b509c13 --- /dev/null +++ b/lvgl/src/lv_core/mod.rs @@ -0,0 +1,5 @@ +#[macro_use] +mod object; +pub mod style; + +pub use object::*; diff --git a/lvgl/src/lv_core/object.rs b/lvgl/src/lv_core/object.rs new file mode 100644 index 0000000..7f77380 --- /dev/null +++ b/lvgl/src/lv_core/object.rs @@ -0,0 +1,204 @@ +use crate::lv_core::style::Style; +use crate::Align; +use alloc::boxed::Box; +use core::ptr; + +const PANIC_MESSAGE: &str = "Value was dropped by LittlevGL"; + +/// Represents a native LittlevGL object +pub trait NativeObject { + /// Provide common way to access to the underlying native object pointer. + fn raw(&self) -> ptr::NonNull; +} + +/// Generic LVGL object. +/// +/// This is the parent object of all widget types. It stores the native LVGL raw pointer. +pub struct GenericObject { + // We use a raw pointer here because we do not control this memory address, it is controlled + // by LVGL's global state. + raw: *mut lvgl_sys::lv_obj_t, +} + +impl NativeObject for GenericObject { + fn raw(&self) -> ptr::NonNull { + ptr::NonNull::new(self.raw).expect(PANIC_MESSAGE) + } +} + +/// A wrapper for all LittlevGL common operations on generic objects. +pub trait Object: NativeObject { + type SpecialEvent; + type Part: Into; + + /// Construct an instance of the object from a raw pointer. + /// + /// # Safety + /// Provided the LVGL library can allocate memory this should be safe. + /// + unsafe fn from_raw(raw_pointer: ptr::NonNull) -> Self; + + fn add_style(&mut self, part: Self::Part, style: Style) { + unsafe { + lvgl_sys::lv_obj_add_style(self.raw().as_mut(), part.into(), Box::into_raw(style.raw)); + }; + } + + fn set_pos(&mut self, x: i16, y: i16) { + unsafe { + lvgl_sys::lv_obj_set_pos( + self.raw().as_mut(), + x as lvgl_sys::lv_coord_t, + y as lvgl_sys::lv_coord_t, + ); + } + } + + fn set_size(&mut self, w: i16, h: i16) { + unsafe { + lvgl_sys::lv_obj_set_size( + self.raw().as_mut(), + w as lvgl_sys::lv_coord_t, + h as lvgl_sys::lv_coord_t, + ); + } + } + + fn set_width(&mut self, w: u32) { + unsafe { + lvgl_sys::lv_obj_set_width(self.raw().as_mut(), w as lvgl_sys::lv_coord_t); + } + } + + fn set_height(&mut self, h: u32) { + unsafe { + lvgl_sys::lv_obj_set_height(self.raw().as_mut(), h as lvgl_sys::lv_coord_t); + } + } + + fn set_align(&mut self, base: &mut C, align: Align, x_mod: i32, y_mod: i32) + where + C: NativeObject, + { + unsafe { + lvgl_sys::lv_obj_align( + self.raw().as_mut(), + base.raw().as_mut(), + align.into(), + x_mod as lvgl_sys::lv_coord_t, + y_mod as lvgl_sys::lv_coord_t, + ); + } + } +} + +impl Object for GenericObject { + type SpecialEvent = (); + type Part = ObjPart; + + unsafe fn from_raw(raw: ptr::NonNull) -> Self { + Self { raw: raw.as_ptr() } + } +} + +impl Default for GenericObject { + fn default() -> Self { + Self { + raw: unsafe { lvgl_sys::lv_obj_create(ptr::null_mut(), ptr::null_mut()) }, + } + } +} + +macro_rules! define_object { + ($item:ident) => { + define_object!($item, event = (), part = $crate::ObjPart); + }; + ($item:ident, event = $event_type:ty) => { + define_object!($item, event = $event_type, part = $crate::ObjPart); + }; + ($item:ident, part = $part_type:ty) => { + define_object!($item, event = (), part = $part_type); + }; + ($item:ident, part = $part_type:ty, event = $event_type:ty) => { + define_object!($item, event = $event_type, part = $part_type); + }; + ($item:ident, event = $event_type:ty, part = $part_type:ty) => { + pub struct $item { + core: $crate::GenericObject, + } + + impl $item { + pub fn on_event(&mut self, f: F) + where + F: FnMut(Self, $crate::support::Event<::SpecialEvent>), + { + unsafe { + let mut raw = self.raw(); + let obj = raw.as_mut(); + let user_closure = alloc::boxed::Box::new(f); + obj.user_data = alloc::boxed::Box::into_raw(user_closure) as *mut cty::c_void; + lvgl_sys::lv_obj_set_event_cb( + obj, + lvgl_sys::lv_event_cb_t::Some($crate::support::event_callback::), + ); + } + } + } + + impl $crate::NativeObject for $item { + fn raw(&self) -> core::ptr::NonNull { + self.core.raw() + } + } + + impl $crate::Object for $item { + type SpecialEvent = $event_type; + type Part = $part_type; + + unsafe fn from_raw(raw_pointer: core::ptr::NonNull) -> Self { + Self { + core: $crate::GenericObject::from_raw(raw_pointer), + } + } + } + }; +} + +bitflags! { + pub struct State: u32 { + /// Normal, released + const DEFAULT = lvgl_sys::LV_STATE_DEFAULT; + /// Toggled or checked + const CHECKED = lvgl_sys::LV_STATE_CHECKED; + /// Focused via keypad or encoder or clicked via touchpad/mouse + const FOCUSED = lvgl_sys::LV_STATE_FOCUSED; + /// Edit by an encoder + const EDITED = lvgl_sys::LV_STATE_EDITED; + /// Hovered by mouse (not supported now) + const HOVERED = lvgl_sys::LV_STATE_HOVERED; + /// Pressed + const PRESSED = lvgl_sys::LV_STATE_PRESSED; + /// Disabled or inactive + const DISABLED = lvgl_sys::LV_STATE_DISABLED; + } +} + +impl State { + pub(crate) fn get_bits(&self) -> u32 { + self.bits + } +} + +pub enum ObjPart { + Main, + All, +} + +impl Into for ObjPart { + fn into(self) -> u8 { + match self { + ObjPart::Main => lvgl_sys::LV_OBJ_PART_MAIN as u8, + ObjPart::All => lvgl_sys::LV_OBJ_PART_ALL as u8, + } + } +} diff --git a/lvgl/src/lv_core/style.rs b/lvgl/src/lv_core/style.rs new file mode 100644 index 0000000..2a66aff --- /dev/null +++ b/lvgl/src/lv_core/style.rs @@ -0,0 +1,1195 @@ +use crate::{Color, State}; +use alloc::boxed::Box; +use core::mem; +use cstr_core::CString; +use lvgl_sys; + +pub enum Themes { + Pretty, +} + +pub struct Style { + pub(crate) raw: Box, +} + +impl Style { + pub fn set_value_str(&mut self, state: State, value: &str) { + let native_state: u32 = state.get_bits(); + let string = CString::new(value).unwrap(); + unsafe { + lvgl_sys::_lv_style_set_ptr( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_STR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + string.into_raw() as *mut cty::c_void, + ); + } + } +} + +impl Default for Style { + fn default() -> Self { + let raw = unsafe { + let mut style = mem::MaybeUninit::::uninit(); + lvgl_sys::lv_style_init(style.as_mut_ptr()); + Box::new(style.assume_init()) + }; + Self { raw } + } +} + +impl Clone for Style { + fn clone(&self) -> Self { + let mut native_style = mem::MaybeUninit::::uninit(); + unsafe { + lvgl_sys::lv_style_copy(native_style.as_mut_ptr(), self.raw.as_ref()); + Self { + raw: Box::new(native_style.assume_init()), + } + } + } +} + +bitflags! { + pub struct StyleProp: u32 { + const RADIUS = lvgl_sys::LV_STYLE_RADIUS; + const CLIP_CORNER = lvgl_sys::LV_STYLE_CLIP_CORNER; + const SIZE = lvgl_sys::LV_STYLE_SIZE; + const TRANSFORM_WIDTH = lvgl_sys::LV_STYLE_TRANSFORM_WIDTH; + const TRANSFORM_HEIGHT = lvgl_sys::LV_STYLE_TRANSFORM_HEIGHT; + const TRANSFORM_ANGLE = lvgl_sys::LV_STYLE_TRANSFORM_ANGLE; + const TRANSFORM_ZOOM = lvgl_sys::LV_STYLE_TRANSFORM_ZOOM; + const OPA_SCALE = lvgl_sys::LV_STYLE_OPA_SCALE; + const PAD_TOP = lvgl_sys::LV_STYLE_PAD_TOP; + const PAD_BOTTOM = lvgl_sys::LV_STYLE_PAD_BOTTOM; + const PAD_LEFT = lvgl_sys::LV_STYLE_PAD_LEFT; + const PAD_RIGHT = lvgl_sys::LV_STYLE_PAD_RIGHT; + const PAD_INNER = lvgl_sys::LV_STYLE_PAD_INNER; + const MARGIN_TOP = lvgl_sys::LV_STYLE_MARGIN_TOP; + const MARGIN_BOTTOM = lvgl_sys::LV_STYLE_MARGIN_BOTTOM; + const MARGIN_LEFT = lvgl_sys::LV_STYLE_MARGIN_LEFT; + const MARGIN_RIGHT = lvgl_sys::LV_STYLE_MARGIN_RIGHT; + const BG_BLEND_MODE = lvgl_sys::LV_STYLE_BG_BLEND_MODE; + const BG_MAIN_STOP = lvgl_sys::LV_STYLE_BG_MAIN_STOP; + const BG_GRAD_STOP = lvgl_sys::LV_STYLE_BG_GRAD_STOP; + const BG_GRAD_DIR = lvgl_sys::LV_STYLE_BG_GRAD_DIR; + const BG_COLOR = lvgl_sys::LV_STYLE_BG_COLOR; + const BG_GRAD_COLOR = lvgl_sys::LV_STYLE_BG_GRAD_COLOR; + const BG_OPA = lvgl_sys::LV_STYLE_BG_OPA; + const BORDER_WIDTH = lvgl_sys::LV_STYLE_BORDER_WIDTH; + const BORDER_SIDE = lvgl_sys::LV_STYLE_BORDER_SIDE; + const BORDER_BLEND_MODE = lvgl_sys::LV_STYLE_BORDER_BLEND_MODE; + const BORDER_POST = lvgl_sys::LV_STYLE_BORDER_POST; + const BORDER_COLOR = lvgl_sys::LV_STYLE_BORDER_COLOR; + const BORDER_OPA = lvgl_sys::LV_STYLE_BORDER_OPA; + const OUTLINE_WIDTH = lvgl_sys::LV_STYLE_OUTLINE_WIDTH; + const OUTLINE_PAD = lvgl_sys::LV_STYLE_OUTLINE_PAD; + const OUTLINE_BLEND_MODE = lvgl_sys::LV_STYLE_OUTLINE_BLEND_MODE; + const OUTLINE_COLOR = lvgl_sys::LV_STYLE_OUTLINE_COLOR; + const OUTLINE_OPA = lvgl_sys::LV_STYLE_OUTLINE_OPA; + const SHADOW_WIDTH = lvgl_sys::LV_STYLE_SHADOW_WIDTH; + const SHADOW_OFS_X = lvgl_sys::LV_STYLE_SHADOW_OFS_X; + const SHADOW_OFS_Y = lvgl_sys::LV_STYLE_SHADOW_OFS_Y; + const SHADOW_SPREAD = lvgl_sys::LV_STYLE_SHADOW_SPREAD; + const SHADOW_BLEND_MODE = lvgl_sys::LV_STYLE_SHADOW_BLEND_MODE; + const SHADOW_COLOR = lvgl_sys::LV_STYLE_SHADOW_COLOR; + const SHADOW_OPA = lvgl_sys::LV_STYLE_SHADOW_OPA; + const PATTERN_BLEND_MODE = lvgl_sys::LV_STYLE_PATTERN_BLEND_MODE; + const PATTERN_REPEAT = lvgl_sys::LV_STYLE_PATTERN_REPEAT; + const PATTERN_RECOLOR = lvgl_sys::LV_STYLE_PATTERN_RECOLOR; + const PATTERN_OPA = lvgl_sys::LV_STYLE_PATTERN_OPA; + const PATTERN_RECOLOR_OPA = lvgl_sys::LV_STYLE_PATTERN_RECOLOR_OPA; + const PATTERN_IMAGE = lvgl_sys::LV_STYLE_PATTERN_IMAGE; + const VALUE_LETTER_SPACE = lvgl_sys::LV_STYLE_VALUE_LETTER_SPACE; + const VALUE_LINE_SPACE = lvgl_sys::LV_STYLE_VALUE_LINE_SPACE; + const VALUE_BLEND_MODE = lvgl_sys::LV_STYLE_VALUE_BLEND_MODE; + const VALUE_OFS_X = lvgl_sys::LV_STYLE_VALUE_OFS_X; + const VALUE_OFS_Y = lvgl_sys::LV_STYLE_VALUE_OFS_Y; + const VALUE_ALIGN = lvgl_sys::LV_STYLE_VALUE_ALIGN; + const VALUE_COLOR = lvgl_sys::LV_STYLE_VALUE_COLOR; + const VALUE_OPA = lvgl_sys::LV_STYLE_VALUE_OPA; + const VALUE_FONT = lvgl_sys::LV_STYLE_VALUE_FONT; + const VALUE_STR = lvgl_sys::LV_STYLE_VALUE_STR; + const TEXT_LETTER_SPACE = lvgl_sys::LV_STYLE_TEXT_LETTER_SPACE; + const TEXT_LINE_SPACE = lvgl_sys::LV_STYLE_TEXT_LINE_SPACE; + const TEXT_DECOR = lvgl_sys::LV_STYLE_TEXT_DECOR; + const TEXT_BLEND_MODE = lvgl_sys::LV_STYLE_TEXT_BLEND_MODE; + const TEXT_COLOR = lvgl_sys::LV_STYLE_TEXT_COLOR; + const TEXT_SEL_COLOR = lvgl_sys::LV_STYLE_TEXT_SEL_COLOR; + const TEXT_OPA = lvgl_sys::LV_STYLE_TEXT_OPA; + const TEXT_FONT = lvgl_sys::LV_STYLE_TEXT_FONT; + const LINE_WIDTH = lvgl_sys::LV_STYLE_LINE_WIDTH; + const LINE_BLEND_MODE = lvgl_sys::LV_STYLE_LINE_BLEND_MODE; + const LINE_DASH_WIDTH = lvgl_sys::LV_STYLE_LINE_DASH_WIDTH; + const LINE_DASH_GAP = lvgl_sys::LV_STYLE_LINE_DASH_GAP; + const LINE_ROUNDED = lvgl_sys::LV_STYLE_LINE_ROUNDED; + const LINE_COLOR = lvgl_sys::LV_STYLE_LINE_COLOR; + const LINE_OPA = lvgl_sys::LV_STYLE_LINE_OPA; + const IMAGE_BLEND_MODE = lvgl_sys::LV_STYLE_IMAGE_BLEND_MODE; + const IMAGE_RECOLOR = lvgl_sys::LV_STYLE_IMAGE_RECOLOR; + const IMAGE_OPA = lvgl_sys::LV_STYLE_IMAGE_OPA; + const IMAGE_RECOLOR_OPA = lvgl_sys::LV_STYLE_IMAGE_RECOLOR_OPA; + const TRANSITION_TIME = lvgl_sys::LV_STYLE_TRANSITION_TIME; + const TRANSITION_DELAY = lvgl_sys::LV_STYLE_TRANSITION_DELAY; + const TRANSITION_PROP_1 = lvgl_sys::LV_STYLE_TRANSITION_PROP_1; + const TRANSITION_PROP_2 = lvgl_sys::LV_STYLE_TRANSITION_PROP_2; + const TRANSITION_PROP_3 = lvgl_sys::LV_STYLE_TRANSITION_PROP_3; + const TRANSITION_PROP_4 = lvgl_sys::LV_STYLE_TRANSITION_PROP_4; + const TRANSITION_PROP_5 = lvgl_sys::LV_STYLE_TRANSITION_PROP_5; + const TRANSITION_PROP_6 = lvgl_sys::LV_STYLE_TRANSITION_PROP_6; + const TRANSITION_PATH = lvgl_sys::LV_STYLE_TRANSITION_PATH; + const SCALE_WIDTH = lvgl_sys::LV_STYLE_SCALE_WIDTH; + const SCALE_BORDER_WIDTH = lvgl_sys::LV_STYLE_SCALE_BORDER_WIDTH; + const SCALE_END_BORDER_WIDTH = lvgl_sys::LV_STYLE_SCALE_END_BORDER_WIDTH; + const SCALE_END_LINE_WIDTH = lvgl_sys::LV_STYLE_SCALE_END_LINE_WIDTH; + const SCALE_GRAD_COLOR = lvgl_sys::LV_STYLE_SCALE_GRAD_COLOR; + const SCALE_END_COLOR = lvgl_sys::LV_STYLE_SCALE_END_COLOR; + } +} + +// Auto-gen code, please look into lvgl-codegen for any changes. +impl Style { + pub fn set_radius(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + 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)) + as u16, + value, + ); + } + } + + pub fn set_clip_corner(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_CLIP_CORNER + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_size(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + 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)) + as u16, + value, + ); + } + } + + pub fn set_transform_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSFORM_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transform_height(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSFORM_HEIGHT + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transform_angle(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSFORM_ANGLE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transform_zoom(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSFORM_ZOOM + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_opa_scale(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_OPA_SCALE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_pad_top(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + 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)) + as u16, + value, + ); + } + } + + pub fn set_pad_bottom(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PAD_BOTTOM + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_pad_left(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PAD_LEFT + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_pad_right(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PAD_RIGHT + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_pad_inner(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PAD_INNER + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_margin_top(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_MARGIN_TOP + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_margin_bottom(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_MARGIN_BOTTOM + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_margin_left(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_MARGIN_LEFT + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_margin_right(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_MARGIN_RIGHT + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_bg_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BG_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_bg_main_stop(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BG_MAIN_STOP + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_bg_grad_stop(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BG_GRAD_STOP + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_bg_grad_dir(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BG_GRAD_DIR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_bg_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BG_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_bg_grad_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BG_GRAD_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_bg_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + 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)) + as u16, + value, + ); + } + } + + pub fn set_border_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BORDER_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_border_side(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BORDER_SIDE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_border_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BORDER_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_border_post(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BORDER_POST + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_border_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BORDER_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_border_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_BORDER_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_outline_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_OUTLINE_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_outline_pad(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_OUTLINE_PAD + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_outline_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_OUTLINE_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_outline_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_OUTLINE_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_outline_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_OUTLINE_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_shadow_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SHADOW_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_shadow_ofs_x(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SHADOW_OFS_X + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_shadow_ofs_y(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SHADOW_OFS_Y + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_shadow_spread(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SHADOW_SPREAD + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_shadow_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SHADOW_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_shadow_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SHADOW_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_shadow_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SHADOW_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_pattern_repeat(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PATTERN_REPEAT + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_pattern_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PATTERN_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_pattern_recolor(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PATTERN_RECOLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_pattern_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PATTERN_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_pattern_recolor_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_PATTERN_RECOLOR_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_value_letter_space(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_LETTER_SPACE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_value_line_space(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_LINE_SPACE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_value_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_value_ofs_x(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_OFS_X + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_value_ofs_y(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_OFS_Y + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_value_align(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_ALIGN + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_value_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_value_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_VALUE_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_text_letter_space(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TEXT_LETTER_SPACE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_text_line_space(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TEXT_LINE_SPACE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_text_decor(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TEXT_DECOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_text_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TEXT_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_text_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TEXT_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_text_sel_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TEXT_SEL_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_text_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TEXT_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_line_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_LINE_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_line_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_LINE_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_line_dash_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_LINE_DASH_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_line_dash_gap(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_LINE_DASH_GAP + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_line_rounded(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_LINE_ROUNDED + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_line_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_LINE_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_line_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_LINE_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_image_blend_mode(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_IMAGE_BLEND_MODE + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_image_recolor(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_IMAGE_RECOLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_image_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_IMAGE_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_image_recolor_opa(&mut self, state: State, value: u8) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_opa( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_IMAGE_RECOLOR_OPA + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transition_time(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSITION_TIME + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transition_delay(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSITION_DELAY + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transition_prop_1(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSITION_PROP_1 + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transition_prop_2(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSITION_PROP_2 + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transition_prop_3(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSITION_PROP_3 + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transition_prop_4(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSITION_PROP_4 + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transition_prop_5(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSITION_PROP_5 + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_transition_prop_6(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_TRANSITION_PROP_6 + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_scale_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SCALE_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_scale_border_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SCALE_BORDER_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_scale_end_border_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SCALE_END_BORDER_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_scale_end_line_width(&mut self, state: State, value: i16) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_int( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SCALE_END_LINE_WIDTH + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value, + ); + } + } + + pub fn set_scale_grad_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SCALE_GRAD_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } + + pub fn set_scale_end_color(&mut self, state: State, value: Color) { + let native_state: u32 = state.get_bits(); + unsafe { + lvgl_sys::_lv_style_set_color( + self.raw.as_mut(), + (lvgl_sys::LV_STYLE_SCALE_END_COLOR + | (native_state << lvgl_sys::LV_STYLE_STATE_POS as u32)) as u16, + value.raw, + ); + } + } +} diff --git a/lvgl/src/support.rs b/lvgl/src/support.rs index 58b53ed..71a55bd 100644 --- a/lvgl/src/support.rs +++ b/lvgl/src/support.rs @@ -1,340 +1,11 @@ -use alloc::boxed::Box; +use crate::Object; use core::convert::{TryFrom, TryInto}; -use core::mem; -use core::ptr; use core::ptr::NonNull; use embedded_graphics::pixelcolor::{Rgb565, Rgb888}; -const PANIC_MESSAGE: &str = "Value was dropped by LittlevGL"; - -/// Represents a native LittlevGL object -pub trait NativeObject { - /// Provide common way to access to the underlying native object pointer. - fn raw(&self) -> ptr::NonNull; -} - -/// Generic LVGL object. -/// -/// This is the parent object of all widget types. It stores the native LVGL raw pointer. -pub struct GenericObject { - // We use a raw pointer here because we do not control this memory address, it is controlled - // by LVGL's global state. - raw: *mut lvgl_sys::lv_obj_t, -} - -impl NativeObject for GenericObject { - fn raw(&self) -> ptr::NonNull { - ptr::NonNull::new(self.raw).expect(PANIC_MESSAGE) - } -} - -/// A wrapper for all LittlevGL common operations on generic objects. -pub trait Object: NativeObject { - type SpecialEvent; - - /// Construct an instance of the object from a raw pointer. - /// - /// # Safety - /// Provided the LVGL library can allocate memory this should be safe. - /// - unsafe fn from_raw(raw_pointer: ptr::NonNull) -> Self; - - fn set_pos(&mut self, x: i16, y: i16) { - unsafe { - lvgl_sys::lv_obj_set_pos( - self.raw().as_mut(), - x as lvgl_sys::lv_coord_t, - y as lvgl_sys::lv_coord_t, - ); - } - } - - fn set_size(&mut self, w: i16, h: i16) { - unsafe { - lvgl_sys::lv_obj_set_size( - self.raw().as_mut(), - w as lvgl_sys::lv_coord_t, - h as lvgl_sys::lv_coord_t, - ); - } - } - - fn set_width(&mut self, w: u32) { - unsafe { - lvgl_sys::lv_obj_set_width(self.raw().as_mut(), w as lvgl_sys::lv_coord_t); - } - } - - fn set_height(&mut self, h: u32) { - unsafe { - lvgl_sys::lv_obj_set_height(self.raw().as_mut(), h as lvgl_sys::lv_coord_t); - } - } - - fn set_align(&mut self, base: &mut C, align: Align, x_mod: i32, y_mod: i32) - where - C: NativeObject, - { - let align = match align { - 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, - Align::InTopRight => lvgl_sys::LV_ALIGN_IN_TOP_RIGHT, - Align::InBottomLeft => lvgl_sys::LV_ALIGN_IN_BOTTOM_LEFT, - Align::InBottomMid => lvgl_sys::LV_ALIGN_IN_BOTTOM_MID, - Align::InBottomRight => lvgl_sys::LV_ALIGN_IN_BOTTOM_RIGHT, - Align::InLeftMid => lvgl_sys::LV_ALIGN_IN_LEFT_MID, - Align::InRightMid => lvgl_sys::LV_ALIGN_IN_RIGHT_MID, - Align::OutTopLeft => lvgl_sys::LV_ALIGN_OUT_TOP_LEFT, - Align::OutTopMid => lvgl_sys::LV_ALIGN_OUT_TOP_MID, - Align::OutTopRight => lvgl_sys::LV_ALIGN_OUT_TOP_RIGHT, - Align::OutBottomLeft => lvgl_sys::LV_ALIGN_OUT_BOTTOM_LEFT, - Align::OutBottomMid => lvgl_sys::LV_ALIGN_OUT_BOTTOM_MID, - Align::OutBottomRight => lvgl_sys::LV_ALIGN_OUT_BOTTOM_RIGHT, - Align::OutLeftTop => lvgl_sys::LV_ALIGN_OUT_LEFT_TOP, - Align::OutLeftMid => lvgl_sys::LV_ALIGN_OUT_LEFT_MID, - Align::OutLeftBottom => lvgl_sys::LV_ALIGN_OUT_LEFT_BOTTOM, - Align::OutRightTop => lvgl_sys::LV_ALIGN_OUT_RIGHT_TOP, - Align::OutRightMid => lvgl_sys::LV_ALIGN_OUT_RIGHT_MID, - Align::OutRightBottom => lvgl_sys::LV_ALIGN_OUT_RIGHT_BOTTOM, - } as lvgl_sys::lv_align_t; - unsafe { - lvgl_sys::lv_obj_align( - self.raw().as_mut(), - base.raw().as_mut(), - align, - x_mod as lvgl_sys::lv_coord_t, - y_mod as lvgl_sys::lv_coord_t, - ); - } - } - - fn set_style(&mut self, style: Style) { - unsafe { - let boxed = Box::new(style.raw); - lvgl_sys::lv_obj_set_style(self.raw().as_mut(), Box::into_raw(boxed)); - }; - } -} - -impl Object for GenericObject { - type SpecialEvent = (); - - unsafe fn from_raw(raw: ptr::NonNull) -> Self { - Self { raw: raw.as_ptr() } - } -} - -impl Default for GenericObject { - fn default() -> Self { - Self { - raw: unsafe { lvgl_sys::lv_obj_create(ptr::null_mut(), ptr::null_mut()) }, - } - } -} - -macro_rules! define_object { - ($item:ident) => { - pub struct $item { - core: $crate::support::GenericObject, - } - - impl $item { - pub fn on_event(&mut self, f: F) - where - F: FnMut( - Self, - $crate::support::Event<::SpecialEvent>, - ), - { - unsafe { - let mut raw = self.raw(); - let obj = raw.as_mut(); - let user_closure = alloc::boxed::Box::new(f); - obj.user_data = alloc::boxed::Box::into_raw(user_closure) as *mut cty::c_void; - lvgl_sys::lv_obj_set_event_cb( - obj, - lvgl_sys::lv_event_cb_t::Some($crate::support::event_callback::), - ); - } - } - } - - impl $crate::support::NativeObject for $item { - fn raw(&self) -> core::ptr::NonNull { - self.core.raw() - } - } - - impl $crate::support::Object for $item { - type SpecialEvent = (); - - unsafe fn from_raw(raw_pointer: core::ptr::NonNull) -> Self { - Self { - core: $crate::support::GenericObject::from_raw(raw_pointer), - } - } - } - }; - ($item:ident, $event_type:ident) => { - pub struct $item { - core: $crate::support::GenericObject, - } - - impl $item { - pub fn on_event(&mut self, f: F) - where - F: FnMut( - Self, - $crate::support::Event<::SpecialEvent>, - ), - { - unsafe { - let mut raw = self.raw(); - let obj = raw.as_mut(); - let user_closure = alloc::boxed::Box::new(f); - obj.user_data = alloc::boxed::Box::into_raw(user_closure) as *mut cty::c_void; - lvgl_sys::lv_obj_set_event_cb( - obj, - lvgl_sys::lv_event_cb_t::Some($crate::support::event_callback::), - ); - } - } - } - - impl $crate::support::NativeObject for $item { - fn raw(&self) -> core::ptr::NonNull { - self.core.raw() - } - } - - impl $crate::support::Object for $item { - type SpecialEvent = $event_type; - - unsafe fn from_raw(raw_pointer: core::ptr::NonNull) -> Self { - Self { - core: $crate::support::GenericObject::from_raw(raw_pointer), - } - } - } - }; -} - -pub enum Themes { - Pretty, -} - -bitflags! { - pub struct Border: u32 { - const NONE = lvgl_sys::LV_BORDER_NONE; - const BOTTOM = lvgl_sys::LV_BORDER_BOTTOM; - const TOP = lvgl_sys::LV_BORDER_TOP; - const LEFT = lvgl_sys::LV_BORDER_LEFT; - const RIGHT = lvgl_sys::LV_BORDER_RIGHT; - const FULL = lvgl_sys::LV_BORDER_FULL; - } -} - -pub struct Style { - pub(crate) raw: lvgl_sys::lv_style_t, -} - -impl Style { - /// Object's main background color - pub fn set_body_main_color(&mut self, color: Color) { - self.raw.body.main_color = color.raw; - } - - /// Second color. If not equal to `set_body_main_color` a gradient will be drawn for the background. - pub fn set_body_grad_color(&mut self, color: Color) { - self.raw.body.grad_color = color.raw; - } - - /// Body radius for rounded corners - pub fn set_body_radius(&mut self, radius: i16) { - self.raw.body.radius = radius; - } - - /// Border color - pub fn set_body_border_color(&mut self, color: Color) { - self.raw.body.border.color = color.raw; - } - - /// Border opacity - pub fn set_body_border_opa(&mut self, opa: u8) { - self.raw.body.border.opa = opa; - } - - /// Border width - pub fn set_body_border_width(&mut self, width: i16) { - self.raw.body.border.width = width; - } - - /// Which borders to draw - pub fn set_body_border_part(&mut self, part: Border) { - self.raw.body.border.part = part.bits as u8; - } - - /// Text color - pub fn set_text_color(&mut self, color: Color) { - self.raw.text.color = color.raw; - } - - /// Font used for displaying the text - pub fn set_text_font(&mut self, font: &lvgl_sys::lv_font_t) { - self.raw.text.font = font; - } - - /// Space between letters - pub fn set_text_letter_space(&mut self, space: i16) { - self.raw.text.letter_space = space; - } - - /// Space between lines (vertical) - pub fn set_text_line_space(&mut self, space: i16) { - self.raw.text.line_space = space; - } - - /// Text opacity - pub fn set_text_opa(&mut self, opa: u8) { - self.raw.text.opa = opa; - } - - /// Text selection background color - pub fn set_text_sel_color(&mut self, color: Color) { - self.raw.text.sel_color = color.raw; - } -} - -impl Default for Style { - fn default() -> Self { - let raw = unsafe { - let mut native_style = mem::MaybeUninit::::uninit(); - lvgl_sys::lv_style_copy(native_style.as_mut_ptr(), &lvgl_sys::lv_style_pretty); - native_style.assume_init() - }; - Self { raw } - } -} - -impl Clone for Style { - fn clone(&self) -> Self { - let mut native_style = mem::MaybeUninit::::uninit(); - unsafe { - lvgl_sys::lv_style_copy( - native_style.as_mut_ptr(), - &self.raw as *const lvgl_sys::lv_style_t, - ); - Self { - raw: native_style.assume_init(), - } - } - } -} - #[derive(Clone)] pub struct Color { - raw: lvgl_sys::lv_color_t, + pub(crate) raw: lvgl_sys::lv_color_t, } impl Color { @@ -508,6 +179,35 @@ pub enum Align { OutRightBottom, } +impl Into for Align { + fn into(self) -> u8 { + 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, + Align::InTopRight => lvgl_sys::LV_ALIGN_IN_TOP_RIGHT, + Align::InBottomLeft => lvgl_sys::LV_ALIGN_IN_BOTTOM_LEFT, + Align::InBottomMid => lvgl_sys::LV_ALIGN_IN_BOTTOM_MID, + Align::InBottomRight => lvgl_sys::LV_ALIGN_IN_BOTTOM_RIGHT, + Align::InLeftMid => lvgl_sys::LV_ALIGN_IN_LEFT_MID, + Align::InRightMid => lvgl_sys::LV_ALIGN_IN_RIGHT_MID, + Align::OutTopLeft => lvgl_sys::LV_ALIGN_OUT_TOP_LEFT, + Align::OutTopMid => lvgl_sys::LV_ALIGN_OUT_TOP_MID, + Align::OutTopRight => lvgl_sys::LV_ALIGN_OUT_TOP_RIGHT, + Align::OutBottomLeft => lvgl_sys::LV_ALIGN_OUT_BOTTOM_LEFT, + Align::OutBottomMid => lvgl_sys::LV_ALIGN_OUT_BOTTOM_MID, + Align::OutBottomRight => lvgl_sys::LV_ALIGN_OUT_BOTTOM_RIGHT, + Align::OutLeftTop => lvgl_sys::LV_ALIGN_OUT_LEFT_TOP, + Align::OutLeftMid => lvgl_sys::LV_ALIGN_OUT_LEFT_MID, + Align::OutLeftBottom => lvgl_sys::LV_ALIGN_OUT_LEFT_BOTTOM, + Align::OutRightTop => lvgl_sys::LV_ALIGN_OUT_RIGHT_TOP, + Align::OutRightMid => lvgl_sys::LV_ALIGN_OUT_RIGHT_MID, + Align::OutRightBottom => lvgl_sys::LV_ALIGN_OUT_RIGHT_BOTTOM, + }; + native as u8 + } +} + pub enum Animation { ON, OFF, diff --git a/lvgl/src/widgets/bar.rs b/lvgl/src/widgets/bar.rs index 6ac66dd..8fd2c95 100644 --- a/lvgl/src/widgets/bar.rs +++ b/lvgl/src/widgets/bar.rs @@ -1,9 +1,8 @@ -use crate::support::{Animation, GenericObject, NativeObject, Style}; -use crate::Object; -use alloc::boxed::Box; +use crate::support::Animation; +use crate::{GenericObject, NativeObject, Object}; use core::ptr; -define_object!(Bar); +define_object!(Bar, part = BarPart); impl Bar { pub fn new(parent: &mut C) -> Self @@ -31,22 +30,10 @@ impl Bar { lvgl_sys::lv_bar_set_value(self.core.raw().as_mut(), value, anim.into()); } } - - /// Set the style, for the given `BarComponent` - pub fn set_bar_style(&mut self, component: BarComponent, style: Style) { - let boxed = Box::new(style.raw); - unsafe { - lvgl_sys::lv_bar_set_style( - self.core.raw().as_mut(), - component.into(), - Box::into_raw(boxed), - ); - } - } } -/// The different components, of a bar object. -pub enum BarComponent { +/// The different parts, of a bar object. +pub enum BarPart { /// The background of the bar. Background, /// The indicator of the bar. @@ -54,11 +41,11 @@ pub enum BarComponent { Indicator, } -impl From for lvgl_sys::lv_bar_style_t { - fn from(component: BarComponent) -> Self { +impl From for u8 { + fn from(component: BarPart) -> Self { match component { - BarComponent::Background => lvgl_sys::LV_BAR_STYLE_BG as u8, - BarComponent::Indicator => lvgl_sys::LV_BAR_STYLE_INDIC as u8, + BarPart::Background => lvgl_sys::LV_BAR_PART_BG as u8, + BarPart::Indicator => lvgl_sys::LV_BAR_PART_INDIC as u8, } } }