rafaelcaricio/lvgl-rs
1
0
Fork 0
Code Issues 12 Pull requests 2 Projects Releases 4 Wiki Activity

Upgrade LVGL 7.0.1 #17

Merged
rafaelcaricio merged 8 commits from upgrade-lvgl-7.0.1 into master 2020-06-04 18:47:41 +00:00
Conversation 0 Commits 8 Files changed 18 +1765 -481
18 changed files with 1765 additions and 481 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.gitmodules vendored
View file

@ -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

1
Cargo.toml
View file

@ -2,5 +2,6 @@
members = [
"lvgl",
"lvgl-sys",
"lvgl-codegen",
"examples"
]

17
README.md
View file

@ -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.

37
examples/bar.rs
View file

@ -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));

9
examples/button_click.rs
View file

@ -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);

32
examples/demo.rs
View file

@ -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 { &noto_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);

262
examples/include/lv_conf.h
View file

@ -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_<CONST> 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) <my_assert_code>
*/
#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 <stdint.h> /*Include a header for the init. function*/
#define LV_THEME_DEFAULT_INIT lv_theme_material_init
#define LV_THEME_DEFAULT_COLOR_PRIMARY LV_COLOR_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 <stdio.h>
# 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"*/

11
lvgl-codegen/Cargo.toml Normal file
View file

@ -0,0 +1,11 @@
[package]
name = "lvgl-codegen"
version = "0.1.0"
authors = ["Rafael Caricio <rafael@caricio.com>"]
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"

35
lvgl-codegen/src/main.rs Normal file
View file

@ -0,0 +1,35 @@
use regex::Regex;
use tera::{Context, Tera};
fn main() {
let re = Regex::new(r"\((?P<prop_name>[^,]+), (?P<func_name>[^,]+), (?P<value_type>[^,]+), (?P<style_type>[^)]+), [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());
}
}
}

33
lvgl-codegen/templates/style.rs.j2 Normal file
View file

@ -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 %}
);
}
}

4
lvgl-sys/build.rs
View file

@ -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);

2
lvgl-sys/vendor/lvgl vendored

@ -1 +1 @@
Subproject commit 9eeaf61fa7ec2b5ea151374b135b85f15438938c
Subproject commit 91b997769e7a2b7eb410371725b1e3a7cb6ecde8

4
lvgl/src/lib.rs
View file

@ -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::*;

5
lvgl/src/lv_core/mod.rs Normal file
View file

@ -0,0 +1,5 @@
#[macro_use]
mod object;
pub mod style;
pub use object::*;

204
lvgl/src/lv_core/object.rs Normal file
View file

@ -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<lvgl_sys::lv_obj_t>;
}
/// 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<lvgl_sys::lv_obj_t> {
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<u8>;
/// 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<lvgl_sys::lv_obj_t>) -> 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<C>(&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<lvgl_sys::lv_obj_t>) -> 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<F>(&mut self, f: F)
where
F: FnMut(Self, $crate::support::Event<<Self as $crate::Object>::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::<Self, F>),
);
}
}
}
impl $crate::NativeObject for $item {
fn raw(&self) -> core::ptr::NonNull<lvgl_sys::lv_obj_t> {
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<lvgl_sys::lv_obj_t>) -> 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<u8> 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,
}
}
}

1195
lvgl/src/lv_core/style.rs Normal file
View file

File diff suppressed because it is too large Load diff

362
lvgl/src/support.rs
View file

@ -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<lvgl_sys::lv_obj_t>;
}
/// 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<lvgl_sys::lv_obj_t> {
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<lvgl_sys::lv_obj_t>) -> 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<C>(&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<lvgl_sys::lv_obj_t>) -> 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<F>(&mut self, f: F)
where
F: FnMut(
Self,
$crate::support::Event<<Self as $crate::support::Object>::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::<Self, F>),
);
}
}
}
impl $crate::support::NativeObject for $item {
fn raw(&self) -> core::ptr::NonNull<lvgl_sys::lv_obj_t> {
self.core.raw()
}
}
impl $crate::support::Object for $item {
type SpecialEvent = ();
unsafe fn from_raw(raw_pointer: core::ptr::NonNull<lvgl_sys::lv_obj_t>) -> 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<F, S>(&mut self, f: F)
where
F: FnMut(
Self,
$crate::support::Event<<Self as $crate::support::Object>::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::<Self, F>),
);
}
}
}
impl $crate::support::NativeObject for $item {
fn raw(&self) -> core::ptr::NonNull<lvgl_sys::lv_obj_t> {
self.core.raw()
}
}
impl $crate::support::Object for $item {
type SpecialEvent = $event_type;
unsafe fn from_raw(raw_pointer: core::ptr::NonNull<lvgl_sys::lv_obj_t>) -> 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::<lvgl_sys::lv_style_t>::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::<lvgl_sys::lv_style_t>::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<u8> 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,

31
lvgl/src/widgets/bar.rs
View file

@ -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<C>(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<BarComponent> for lvgl_sys::lv_bar_style_t {
fn from(component: BarComponent) -> Self {
impl From<BarPart> 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,
}
}
}