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/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..af07c94 --- /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.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/src/lib.rs b/lvgl/src/lib.rs index 75fd41e..d3967d7 100644 --- a/lvgl/src/lib.rs +++ b/lvgl/src/lib.rs @@ -8,8 +8,10 @@ mod display; mod global; #[macro_use] mod support; +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..6fbda92 --- /dev/null +++ b/lvgl/src/lv_core/mod.rs @@ -0,0 +1,3 @@ +pub mod style; + +use style::*; diff --git a/lvgl/src/lv_core/style.rs b/lvgl/src/lv_core/style.rs new file mode 100644 index 0000000..1ca04fb --- /dev/null +++ b/lvgl/src/lv_core/style.rs @@ -0,0 +1,1215 @@ +use crate::Color; +use alloc::boxed::Box; +use core::borrow::BorrowMut; +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.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 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; + } +} + +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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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..aaa5828 100644 --- a/lvgl/src/support.rs +++ b/lvgl/src/support.rs @@ -1,3 +1,4 @@ +use crate::lv_core::style::Style; use alloc::boxed::Box; use core::convert::{TryFrom, TryInto}; use core::mem; @@ -109,10 +110,13 @@ pub trait Object: NativeObject { } } - fn set_style(&mut self, style: Style) { + fn add_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)); + lvgl_sys::lv_obj_add_style( + self.raw().as_mut(), + lvgl_sys::LV_OBJ_PART_MAIN as u8, + Box::into_raw(style.raw), + ); }; } } @@ -220,121 +224,9 @@ macro_rules! define_object { }; } -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 { diff --git a/lvgl/src/widgets/bar.rs b/lvgl/src/widgets/bar.rs index 6ac66dd..0c80c44 100644 --- a/lvgl/src/widgets/bar.rs +++ b/lvgl/src/widgets/bar.rs @@ -1,4 +1,5 @@ -use crate::support::{Animation, GenericObject, NativeObject, Style}; +use crate::style::Style; +use crate::support::{Animation, GenericObject, NativeObject}; use crate::Object; use alloc::boxed::Box; use core::ptr; @@ -33,12 +34,12 @@ impl Bar { } /// Set the style, for the given `BarComponent` - pub fn set_bar_style(&mut self, component: BarComponent, style: Style) { - let boxed = Box::new(style.raw); + pub fn set_bar_style(&mut self, style: Style) { + let boxed = style.raw; unsafe { - lvgl_sys::lv_bar_set_style( + lvgl_sys::lv_obj_add_style( self.core.raw().as_mut(), - component.into(), + lvgl_sys::LV_OBJ_PART_MAIN as u8, Box::into_raw(boxed), ); }