Update README.md

page: Use padding when focus an child item

.github/FUNDING.yml

@@ -1 +1 @@
-custom: ["https://littlevgl.com/donate"]
+custom: ["https://www.paypal.com/paypalme/my/profile"]

.github/auto-comment.yml

@@ -0,0 +1,12 @@
+# Comment to a new issue.
+pullRequestOpened: |
+  Thank you for raising your pull request.
+  
+  To ensure that all licensing criteria is met all repositories of the LVGL project apply a process called DCO (Developer's Certificate of Origin). 
+  
+  The text of DCO can be read here: https://developercertificate.org/
+  For a more detailed description see the [Documentation](https://docs.lvgl.io/latest/en/html/contributing/index.html#developer-certification-of-origin-dco) site.
+  
+  By contributing to any repositories of the LVGL project you state that your contribution corresponds with the DCO.
+  
+  No further action is required if your contribution fulfills the DCO. If you are not sure about it feel free to ask us in a comment. 

.github/workflows/merge-to-dev.yml

@@ -0,0 +1,17 @@
+name: Merge master branch to dev
+on:
+  push:
+    branches:
+      - 'master'
+jobs:
+  merge-branch:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@master
+      - name: Merge to dev branch
+        uses: devmasx/merge-branch@v1.1.0
+        with:
+          type: now
+          target_branch: 'dev'
+        env:
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

CHANGELOG.md

@@ -1,8 +1,86 @@
 # Changelog
 
+## v7.4.0 (planned on 01.09.2020)
+*Available in the `dev` branch*
+
+## v7.3.1 (planned on 18.08.2020)
+*Available in the `master` branch*
+
+## v7.3.0 (04.08.2020)
+
+### New features
+- Add `lv_task_get_next`
+- Add `lv_event_send_refresh`, `lv_event_send_refresh_recursive` to easily send `LV_EVENT_REFRESH` to object
+- Add `lv_tabview_set_tab_name()` function - used to change a tab's name
+- Add `LV_THEME_MATERIAL_FLAG_NO_TRANSITION` and `LV_THEME_MATERIAL_FLAG_NO_FOCUS` flags
+- Reduce code size by adding: `LV_USE_FONT_COMPRESSED`, `LV_FONT_USE_SUBPX`, `LV_USE_OUTLINE`, `LV_USE_PATTERN`, `LV_USE_VALUE_STR`  and applying some optimization
+- Add `LV_MEMCPY_MEMSET_STD` to use standard `memcpy` and `memset`
+
+
+### Bugfixes
+- Do not print warning for missing glyph if its height OR width is zero.
+- Prevent duplicated sending of `LV_EVENT_INSERT` from text area
+- Tidy outer edges of cpicker widget.
+- Remove duplicated lines from `lv_tabview_add_tab`
+- btnmatrix: hadle combined states of buttons (e.g. chacked + disabled)
+- textarea: fix typo in lv_textarea_set_sscrollbar_mode
+- gauge: fix image needle drawing
+- fix using freed memory in _lv_style_list_remove_style
+
+
+## v7.2.0 (21.07.2020)
+
+### New features
+- Add screen transitions with `lv_scr_load_anim()`
+- Add display background color, wallpaper and opacity. Shown when the screen is transparent. Can be used with `lv_disp_set_bg_opa/color/image()`.
+- Add `LV_CALENDAR_WEEK_STARTS_MONDAY`
+- Add `lv_chart_set_x_start_point()` function - Set the index of the x-axis start point in the data array
+- Add `lv_chart_set_ext_array()` function - Set an external array of data points to use for the chart
+- Add `lv_chart_set_point_id()` function - Set an individual point value in the chart series directly based on index
+- Add `lv_chart_get_x_start_point()` function - Get the current index of the x-axis start point in the data array
+- Add `lv_chart_get_point_id()` function - Get an individual point value in the chart series directly based on index
+- Add `ext_buf_assigned` bit field to `lv_chart_series_t` structure - it's true if external buffer is assigned to series
+- Add `lv_chart_set_series_axis()` to assign series to primary or secondary axis
+- Add `lv_chart_set_y_range()` to allow setting range of secondary y axis (based on `lv_chart_set_range` but extended with an axis parameter)
+- Allow setting different font for the selected text in `lv_roller`
+- Add `theme->apply_cb` to replace `theme->apply_xcb` to make it compatible with the MicroPython binding
+- Add `lv_theme_set_base()` to allow easy extension of built-in (or any) themes
+- Add `lv_obj_align_x()` and `lv_obj_align_y()` functions
+- Add `lv_obj_align_origo_x()` and `lv_obj_align_origo_y()` functions
+
+### Bugfixes
+- `tileview` fix navigation when not screen sized
+- Use 14px font by default to for better compatibility with smaller displays 
+- `linemeter` fix conversation of current value to "level"
+- Fix drawing on right border
+- Set the cursor image non clickable by default
+- Improve mono theme when used with keyboard or encoder
+
+## v7.1.0 (07.07.2020)
+
+### New features
+- Add `focus_parent` attribute to `lv_obj`
+- Allow using buttons in encoder input device
+- Add lv_btnmatrix_set/get_align capability
+- DMA2D: Remove dependency on ST CubeMX HAL
+- Added `max_used` propriety to `lv_mem_monitor_t` struct
+- In `lv_init` test if the the strings are UTF-8 encoded.
+- Add `user_data` to themes
+- Add LV_BIG_ENDIAN_SYSTEM flag to lv_conf.h in order to fix displaying images on big endian systems.
+- Add inline function lv_checkbox_get_state(const lv_obj_t * cb) to extend the checkbox functionality.
+- Add inline function lv_checkbox_set_state(const lv_obj_t * cb, lv_btn_state_t state ) to extend the checkbox functionality.
+
+### Bugfixes
+- `lv_img` fix invalidation area when angle or zoom changes
+- Update the style handling to support Big endian MCUs
+- Change some methods to support big endian hardware.
+- remove use of c++ keyword 'new' in parameter of function lv_theme_set_base().
+- Add LV_BIG_ENDIAN_SYSTEM flag to lv_conf.h in order to fix displaying images on big endian systems.
+- Fix inserting chars in text area in big endian hardware.
 
 ## v7.0.2 (16.06.2020)
 
+### Bugfixes
 - `lv_textarea` fix wrong cursor position when clicked after the last character
 - Change all text related indices from 16-bit to 32-bit integers throughout whole library. #1545
 - Fix gestures
@@ -23,6 +101,7 @@
 - `tabview` by default allow auto expanding the page only to right and bottom (#1573)
 - fix crash when drawing gradient to the same color
 - chart: fix memory leak
+- `img`: improve hit test for transformed images
 
 ## v7.0.1 (01.06.2020)
 

README.md

@@ -1,8 +1,4 @@
 <h1 align="center"> LVGL - Light and Versatile Graphics Library</h1>
-<p align="center">
-<a href="https://github.com/lvgl/lvgl/blob/master/LICENCE.txt"><img src="https://img.shields.io/badge/licence-MIT-blue.svg"></a>
-<a href="https://github.com/lvgl/lvgl/releases/tag/v7.0.0"><img src="https://img.shields.io/badge/version-7.0.0-blue.svg"></a>
-</p>
 
 <p align="center">
 <img src="https://lvgl.io/assets/images/img_1.png">
@@ -14,221 +10,115 @@ LVGL provides everything you need to create embedded GUI with easy-to-use graphi
 
 <h4 align="center">
 <a href="https://lvgl.io">Website </a> &middot; 
-<a href="https://lvgl.io/demos">Live demo</a> &middot; 
+<a href="https://lvgl.io/demos">Online demo</a> &middot; 
 <a href="https://docs.lvgl.io/">Docs</a> &middot; 
-<a href="https://forum.lvgl.io">Forum</a> &middot;
-<a href="https://blog.lvgl.io/">Blog</a>
+<a href="https://forum.lvgl.io">Forum</a>
 </h4>
 
 ---
 
-- [Features](#features)
-- [Supported devices](#supported-devices)
-- [Quick start in a simulator](#quick-start-in-a-simulator)
-- [Add LVGL to your project](#add-lvgl-to-your-project)
-- [Learn the basics](#learn-the-basics)
-- [Examples](#examples)
-- [Release policy](#release-policy)
-- [Contributing](#contributing)
-
-
 ## Features
-* **Powerful building blocks** buttons, charts, lists, sliders, images, etc.
-* **Advanced graphics** with animations, anti-aliasing, opacity, smooth scrolling
-* **Simultaneously use various input devices** touchscreen, mouse, keyboard, encoder, buttons, etc.
-* **Simultaneously use multiple displays** i.e. monochrome and color display
-* **Multi-language support** with UTF-8 encoding, Bidirectional support, and Arabic text handling
-* **Fully customizable** graphical elements
-* **Hardware independent** to use with any microcontroller or display
-* **Scalable** to operate with little memory (64 kB Flash, 10 kB RAM)
-* **OS, External memory and GPU** supported but not required
-* **Single frame buffer** operation even with advances graphical effects
-* **Written in C** for maximal compatibility (C++ compatible)
-* **Micropython Binding** exposes [LVGL API in Micropython](https://blog.lvgl.io/2019-02-20/micropython-bindings)
-* **Simulator** to develop on PC without embedded hardware
-* **Tutorials, examples, themes** for rapid development
-* **Documentation** and API references
+* Powerful [building blocks](https://docs.lvgl.io/latest/en/html/widgets/index.html): buttons, charts, lists, sliders, images, etc.
+* Advanced graphics: animations, anti-aliasing, opacity, smooth scrolling
+* Use [various input devices](https://docs.lvgl.io/latest/en/html/overview/indev.html): touchscreen, mouse, keyboard, encoder, buttons, etc.
+* Use [multiple displays](https://docs.lvgl.io/latest/en/html/overview/display.html): e.g. monochrome and color display
+* Hardware independent to use with any microcontroller or display
+* Scalable to operate with little memory (64 kB Flash, 10 kB RAM)
+* Multi-language support with UTF-8 handling, Bidirectional and Arabic script support
+* Fully customizable graphical elements via [CSS-like styles](https://docs.lvgl.io/latest/en/html/overview/style.html)
+* OS, External memory and GPU are supported but not required
+* Smooth rendering even with a [single frame buffer](https://docs.lvgl.io/latest/en/html/porting/display.html)
+* Written in C for maximal compatibility (C++ compatible)
+* Micropython Binding exposes [LVGL API in Micropython](https://blog.lvgl.io/2019-02-20/micropython-bindings)
+* [Simulator](https://docs.lvgl.io/latest/en/html/get-started/pc-simulator.html) to develop on PC without embedded hardware
+* [Examples](lv_examples) and tutorials for rapid development
+* [Documentation](http://docs.lvgl.io/) and API references
 
-## Supported devices
-Basically, every modern controller  (which is able to drive a display) is suitable to run LVGL. The minimal requirements are:
-- 16, 32 or 64 bit microcontroller or processor
-- &gt; 16 MHz clock speed is recommended
-- Flash/ROM: &gt; 64 kB for the very essential components (&gt; 180 kB is recommended)
-- RAM: 
-  - Static RAM usage: ~2 kB depending on the used features and objects types
-  - Stack: &gt; 2kB (&gt; 8 kB is recommended)
-  - Dynamic data (heap): &gt; 2 KB (&gt; 16 kB is recommended if using several objects).
-    Set by `LV_MEM_SIZE` in *lv_conf.h*. 
-  - Display buffer:  &gt; *"Horizontal resolution"* pixels (&gt; 10 &times; *"Horizontal resolution"* is recommended) 
-- C99 or newer compiler
+## Requirements
+Basically, every modern controller (which is able to drive a display) is suitable to run LVGL. The minimal requirements are:
+
+<table>
+  <tr>
+    <td> <strong>Name</strong> </td>
+    <td><strong>Minimal</strong></td>
+    <td><strong>Recommended</strong></td>
+  </tr>
+  <tr>
+    <td><strong>Architecture</strong></td>
+    <td colspan="2">16, 32 or 64 bit microcontroller or processor</td>
+  </tr>
+  <tr>
+    <td> <strong>Clock</strong></td>
+    <td> &gt; 16 MHz </td>
+    <td> &gt; 48 MHz</td>
+  </tr>
+  
+  <tr>
+    <td> <strong>Flash/ROM</strong></td>
+    <td> &gt; 64 kB </td>
+    <td> &gt; 180 kB</td>
+  </tr>
+  
+  <tr>
+    <td> <strong>Static RAM</strong></td>
+    <td> &gt; 2 kB </td>
+    <td> &gt; 4 kB</td>
+  </tr>
+  
+  <tr>
+    <td> <strong>Stack</strong></td>
+    <td> &gt; 2 kB </td>
+    <td> &gt; 8 kB</td>
+  </tr>
+  
+  <tr>
+    <td> <strong>Heap</strong></td>
+    <td> &gt; 2 kB </td>
+    <td> &gt; 8 kB</td>
+  </tr>
+  
+  <tr>
+    <td> <strong>Display buffer</strong></td>
+    <td> &gt; 1 &times; <em>hor. res.</em> pixels </td>
+    <td> &gt; 10 &times; <em>hor. res.</em> pixels </td>
+  </tr>
+  
+  <tr>
+    <td> <strong>Compiler</strong></td>
+    <td colspan="2"> C99 or newer </td>
+  </tr>
+</table>
 
 *Note that the memory usage might vary depending on the architecture, compiler and build options.*
 
-Just to mention some **platforms**:
-- STM32F1, STM32F3, [STM32F4](https://blog.lvgl.io/2017-07-15/stm32f429_disco_port), [STM32F7](https://github.com/lvgl/lv_port_stm32f746_disco_sw4stm32)
+Just to mention some platforms:
+- STM32F1, STM32F3, STM32F4, STM32F7, STM32L4, STM32L5, STM32H7
 - Microchip dsPIC33, PIC24, PIC32MX, PIC32MZ
-- NXP Kinetis, LPC, iMX
+- NXP: Kinetis, LPC, iMX, iMX RT
 - [Linux frame buffer](https://blog.lvgl.io/2018-01-03/linux_fb) (/dev/fb)
-- [Raspberry PI](http://www.vk3erw.com/index.php/16-software/63-raspberry-pi-official-7-touchscreen-and-littlevgl)
+- [Raspberry Pi](http://www.vk3erw.com/index.php/16-software/63-raspberry-pi-official-7-touchscreen-and-littlevgl)
 - [Espressif ESP32](https://github.com/lvgl/lv_port_esp32)
-- Nordic nrf52
-- Quectell M66
-
-## Quick start in a simulator
-The easiest way to get started with LVGL is to run it in a simulator on your PC without any embedded hardware. 
-
-Choose a project with your favourite IDE:
-
-|   Eclipse   |  CodeBlocks | Visual Studio | PlatformIO | Qt Creator |
-|-------------|-------------|---------------|-----------|------------|
-|  [![Eclipse](https://raw.githubusercontent.com/lvgl/docs/master/v7/misc//eclipse.jpg)](https://github.com/lvgl/lv_sim_eclipse_sdl) | [![CodeBlocks](https://raw.githubusercontent.com/lvgl/docs/master/v7/misc//codeblocks.jpg)](https://github.com/lvgl/lv_sim_codeblocks_win) | [![VisualStudio](https://raw.githubusercontent.com/lvgl/docs/master/v7/misc//visualstudio.jpg)](https://github.com/lvgl/lv_sim_visual_studio_sdl) |   [![PlatformIO](https://raw.githubusercontent.com/lvgl/docs/master/v7/misc//platformio.jpg)](https://github.com/lvgl/lv_platformio) | [![QtCreator](https://raw.githubusercontent.com/lvgl/docs/master/v7/misc//qtcreator.jpg)](https://blog.lvgl.io/2019-01-03/qt-creator) |
-| Cross-platform<br>with SDL<br>(Recommended on<br>Linux and Mac) | Native Windows | Windows<br>with SDL | Cross-platform<br>with SDL | Cross-platform<br>with SDL |
-
-
-## Add LVGL to your project
-
-The steps below show how to setup LVGL on an embedded system with a display and a touchpad. 
-You can use the [Simulators](https://docs.lvgl.io/v7/en/html/get-started/pc-simulator) to get ready to use projects which can be run on your PC. 
-
-1. [Download](https://github.com/lvgl/lvgl/archive/master.zip) or [Clone](https://github.com/lvgl/lvgl) the library
-2. Copy the `lvgl` folder into your project
-3. Copy `lvgl/lv_conf_template.h` as `lv_conf.h` next to the `lvgl` folder, change the `#if 0` statement near the top of the file to `#if 1` and set at least `LV_HOR_RES_MAX`, `LV_VER_RES_MAX` and `LV_COLOR_DEPTH`.
-4. Include `lvgl/lvgl.h` where you need to use LVGL related functions.
-5. Call `lv_tick_inc(x)` every `x` milliseconds (should be 1..10) in a Timer or Task. It is required for the internal timing of LVGL.
-6. Call `lv_init()`
-7. Create a display buffer for LVGL
-```c
-static lv_disp_buf_t disp_buf;
-static lv_color_t buf[LV_HOR_RES_MAX * 10];                     /*Declare a buffer for 10 lines*/
-lv_disp_buf_init(&disp_buf, buf, NULL, LV_HOR_RES_MAX * 10);    /*Initialize the display buffer*/
-```
-8. Implement and register a function which can copy a pixel array to an area of your display:
-```c
-lv_disp_drv_t disp_drv;               /*Descriptor of a display driver*/
-lv_disp_drv_init(&disp_drv);          /*Basic initialization*/
-disp_drv.flush_cb = my_disp_flush;    /*Set your driver function*/
-disp_drv.buffer = &disp_buf;          /*Assign the buffer to the display*/
-lv_disp_drv_register(&disp_drv);      /*Finally register the driver*/
-    
-void my_disp_flush(lv_disp_t * disp, const lv_area_t * area, lv_color_t * color_p)
-{
-    int32_t x, y;
-    for(y = area->y1; y <= area->y2; y++) {
-        for(x = area->x1; x <= area->x2; x++) {
-            my_set_pixel(x, y, *color_p);  /* Put a pixel to the display.*/
-            color_p++;
-        }
-    }
-
-    lv_disp_flush_ready(disp);         /* Indicate you are ready with the flushing*/
-}
-    
-```
-9. Implement and register a function which can read an input device. E.g. for a touch pad:
-```c
-lv_indev_drv_init(&indev_drv);             /*Descriptor of a input device driver*/
-indev_drv.type = LV_INDEV_TYPE_POINTER;    /*Touch pad is a pointer-like device*/
-indev_drv.read_cb = my_touchpad_read;      /*Set your driver function*/
-lv_indev_drv_register(&indev_drv);         /*Finally register the driver*/
-
-bool my_touchpad_read(lv_indev_drv_t * indev_driver, lv_indev_data_t * data)
-{
-    data->state = my_touchpad_is_pressed() ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL; 
-    if(data->state == LV_INDEV_STATE_PR) touchpad_get_xy(&data->point.x, &data->point.y);
-
-    return false; /*Return `false` because we are not buffering and no more data to read*/
-}
-```
-10. Call `lv_task_handler()` periodically every few milliseconds in the main `while(1)` loop, in Timer interrupt or in an Operation system task. 
-It will redraw the screen if required, handle input devices etc. 
-
-For more detailed desription visit the [Porting](https://docs.lvgl.io/v7/en/html/porting/index.html) section of the documentation.
-
-## Learn the basics
-
-In this section you can read the very basics of LVGL. 
-For a more detailed guide check the [Quick overview](https://docs.lvgl.io/v7/en/html/get-started/quick-overview.html#learn-the-basics) in the documentation. 
-
-### Widgets (Objects)
-
-The graphical elements like Buttons, Labels, Sliders, Charts etc are called objects or widgets in LVGL. Go to [Widgets](https://docs.lvgl.io/v7/en/html/widgets/index) to see the full list of available types.
-
-Every object has a parent object. The child object moves with the parent and if you delete the parent the children will be deleted too. Children can be visible only on their parent.
-
-The *screen* are the "root" parents. To get the current screen call `lv_scr_act()`.
-
-You can create a new object with `lv_<type>_create(parent, obj_to_copy)`. It will return an `lv_obj_t *` variable which should be used as a reference to the object to set its parameters later. 
-The first parameter is the desired *parent*, the second parameters can be an object to copy (`NULL` if unused). 
-For example:
-```c
-lv_obj_t * slider1 = lv_slider_create(lv_scr_act(), NULL);
-```
-
-To set some basic attribute `lv_obj_set_<paramters_name>(obj, <value>)` function can be used. For example:
-```c
-lv_obj_set_x(btn1, 30);
-lv_obj_set_y(btn1, 10);
-lv_obj_set_size(btn1, 200, 50);
-```
-
-The objects have type specific parameters too which can be set by `lv_<type>_set_<paramters_name>(obj, <value>)` functions. For example:
-```c
-lv_slider_set_value(slider1, 70, LV_ANIM_ON);
-```
-
-To see the full API visit the documentation of the object types or the related header file (e.g. `lvgl/src/lv_objx/lv_slider.h`).
-
-
-To create a new screen pass `NULL` as the fisrt paramater of a *create* function:
-```c
-lv_obj_t * scr2 = lv_obj_create(NULL, NULL);    /*Create a screen*/
-lv_scr_load(scr2);                              /*Load the new screen*/
-```
-
-### Styles
-Widgets are created with a default appearance but it can be changed by adding new styles to them. A new style can be created like this:
-```c
-static lv_style_t style1; /*Should be static, global or dynamically allocated*/
-lv_style_init(&style1);
-lv_style_set_bg_color(&style1, LV_STATE_DEFAULT, LV_COLOR_RED);  /*Default background color*/ 
-lv_style_set_bg_color(&style1, LV_STATE_PRESSED, LV_COLOR_BLUE); /*Pressed background color*/
-```
-
-The wigedt have *parts* which can be referenced via `LV_<TYPE>_PART_<PART_NAME>`. E.g. `LV_BTN_PART_MAIN` or `LV_SLIDER_PART_KNOB`. See the documentation of the widgets to see the exisitng parts.
-
-To add the style to a button:
-```c
-lv_obj_add_style(btn1, LV_BTN_PART_MAIN, &style1);
-```
-
-To remove all styles from a part of an object:
-```cc
-lv_obj_reset_style_list(obj, LV_OBJ_PART_MAIN);
-```
-
-Learn more in [Style overview](https://docs.lvgl.io/v7/en/html/overview/style) section.
-
-### Events
-Events are used to inform the user if something has happened with an object. You can assign a callback to an object which will be called if the object is clicked, released, dragged, being deleted etc. It should look like this: 
-
-```c
-lv_obj_set_event_cb(btn, btn_event_cb);     /*Assign a callback to the button*/
-
-...
-
-void btn_event_cb(lv_obj_t * btn, lv_event_t event)
-{
-    if(event == LV_EVENT_CLICKED) {
-        printf("Clicked\n");
-    }
-}
-```
-
-Learn more about the events in the [Event overview](https://docs.lvgl.io/v7/en/html/overview/event) section. 
+- [Infineon Aurix](https://github.com/lvgl/lv_port_aurix)
+- Nordic NRF52 Bluetooth modules
+- Quectel modems
 
+## Get started
+This list shows the recommended way of learning the library:
+1. Check the [Online demos](https://lvgl.io/demos) to see LVGL in action (3 minutes)
+2. Read the [Introduction](https://docs.lvgl.io/latest/en/html/intro/index.html) page of the documentation (5 minutes)
+3. Get familiar with the basics on the [Quick overview](https://docs.lvgl.io/latest/en/html/get-started/quick-overview.html) page (15 minutes)
+4. Set up a [Simulator](https://docs.lvgl.io/latest/en/html/get-started/pc-simulator.html) (10 minutes)
+5. Try out some [Examples](https://github.com/lvgl/lv_examples/)
+6. Port LVGL to a board. See the [Porting](https://docs.lvgl.io/latest/en/html/porting/index.html) guide or check the ready to use [Projects](https://github.com/lvgl?q=lv_port_&type=&language=)
+7. Read the [Overview](https://docs.lvgl.io/latest/en/html/overview/index.html) page to get a better understanding of the library (2-3 hours)
+8. Check the documentation of the [Widgets](https://docs.lvgl.io/latest/en/html/widgets/index.html) to see their features and usage
+9. If you have questions go to the [Forum](http://forum.lvgl.io/)
+10. Read the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) guide to see how you can help to improve LVGL (15 minutes) 
 
 ## Examples 
 
+For more examples see the [lv_examples](https://github.com/lvgl/lv_examples) repository.
+
 ### Button with label
 ```c
 lv_obj_t * btn = lv_btn_create(lv_scr_act(), NULL);     /*Add a button the current screen*/
@@ -248,10 +138,10 @@ void btn_event_cb(lv_obj_t * btn, lv_event_t event)
     }
 }
 ```
-![LVGL button with label example](https://docs.lvgl.io/v7/en/misc/simple_button_example.gif)
+![LVGL button with label example](https://raw.githubusercontent.com/lvgl/docs/latest/misc/simple_button_example.gif)
 
-### Use LVGL from Micropython
-Learn more about [Micropython](https://docs.lvgl.io/en/html/get-started/micropython).
+### LVGL from Micropython
+Learn more about [Micropython](https://docs.lvgl.io/latest/en/html/get-started/micropython.html).
 ```python
 # Create a Button and a Label
 scr = lv.obj()
@@ -264,38 +154,7 @@ label.set_text("Button")
 lv.scr_load(scr)
 ```
 
-## Release policy
-LVGL follows the rules of [Semantic versioning](https://semver.org/):
-- Major versions for incompatible API changes. E.g. v5.0.0, v6.0.0
-- Minor version for new but backward-compatible functionalities. E.g. v6.1.0, v6.2.0
-- Patch version for backward-compatible bug fixes. E.g. v6.1.1, v6.1.2
-
-Branches:
-- `master` most recent version, patches are merged directly here. 
-- `dev` merge new features here until they are merged into `master`.
-- `release/vX` there is a branch for every major version to allow adding specific, not forward compatible fixes.
-
-LVGL has a monthly periodic release cycle.
-- **1st Tuesday of the month** 
-  - Make a major, minor, or patch release from `master` depending on the new features.
-  - After that merge only patches into `master` and add new features into the `dev`.
-- **3rd Tuesday of the month** 
-  - Make a patch release from `master`.
-  - After that merge the new features from the `dev` to `master` branch. 
-  - In the rest of the month merge only patches into `master` and new features into `dev` branch.
-  
 ## Contributing
-To ask questions please use the [Forum](https://forum.lvgl.io).
-For development-related things (bug reports, feature suggestions) use [GitHub's Issue tracker](https://github.com/lvgl/lvgl/issues). 
+LVGL is an open project and contribution is very welcome. There are many ways to contribute from simply speaking about your project, through writing examples, improving the documentation, fixing bugs to hosing your own project under in LVGL.
 
-If you are interested in contributing to LVGL you can
-- **Help others** in the [Forum](https://forum.lvgl.io).
-- **Inspire people** by speaking about your project in [My project](https://forum.lvgl.io/c/my-projects) category in the Forum.
-- **Improve and/or translate the documentation.** Go to the [Documentation](https://github.com/lvgl/docs) repository to learn more
-- **Write a blog post** about your experiences. See how to do it in the [Blog](https://github.com/lvgl/blog) repository
-- **Report and/or fix bugs** in [GitHub's issue tracker](https://github.com/lvgl/lvgl/issues)
-- **Help in the developement**. Check the [Open issues](https://github.com/lvgl/lvgl/issues) especially the ones with [Help wanted](https://github.com/lvgl/lvgl/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) label and tell your ideas about a topic or implement a feature.
-
-Before sending Pull requests, please read the following guides:
-- [Contributing guide](https://github.com/lvgl/lvgl/blob/master/docs/CONTRIBUTING.md)
-- [Coding style guide](https://github.com/lvgl/lvgl/blob/master/docs/CODING_STYLE.md)
+For a detailed description of contribution opportunities visit the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) section of the documentation.

docs/CONTRIBUTING.md

@@ -1,114 +1,5 @@
 # Contributing to LVGL
 
-Thank you for considering contributing to LVGL. If you have some spare time to spend with programming you will certainly find a way to helpimproving LVGL. Do not afraid to take the first step! Everybody is welcome independently from gender, age, color, location, or skill level. So don't be shy, pick a point from the list below that you are interested in, and let's go! :rocket: 
+Thank you for considering contributing to LVGL. 
 
-- [Overview](#overview)
-- [How to send a pull request?](#how-to-send-a-pull-request) 
-- [Help others in the Forum](help-others-in-the-forum)
-- [Improve or translate the documentation](#improve-or-translate-the-documentation)
-- [Write a blog post](#write-a-blog-post)
-- [Report or fix bugs](#report-or-fix-bugs)
-- [Suggest or implement new features](#suggest-or-implement-new-features)
-- [Summary](#summary)
-
-
-## Overview
-
-There are many ways to join the community. If you have some time to work with us you will surely find something that fits you! You can:
-- **Help others** in the [Forum](https://forum.lvgl.io).
-- **Inspire people** by speaking about your project in [My project](https://forum.lvgl.io/c/my-projects) category in the Forum.
-- **Improve and/or translate the documentation.** Go to the [Documentation](https://github.com/lvgl/docs) repository to learn more.
-- **Write a blog post** about your experiences. See how to do it in the [Blog](https://github.com/lvgl/blog) repository
-- **Report and/or fix bugs** in [GitHub's issue tracker](https://github.com/lvgl/lvgl/issues)
-- **Help the development**. Check the [Open issues](https://github.com/lvgl/lvgl/issues) especially the ones with [Help wanted](https://github.com/lvgl/lvgl/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) label and tell your ideas about a topic or implement a feature.
-
-We have some simple rules:
-- Be kind and friendly.
-- Speak about one thing in one issue/topic.
-- Give feedback and close the issue or mark the topic as solved if your question is answered. 
-- Tell what you experience or expect. _"The button is not working"_ is not enough info to get help.
-- Use [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) to format your post.
-- We use the [Forum](https://forum.lvgl.io/) to ask and answer questions and [GitHub's issue tracker](https://github.com/lvgl/lvgl/issues) for development-related discussion.
-- If possible send an absolute minimal code example in order to reproduce the issue
-
-
-## How to send a pull request?
-
-Merging new code into LVGL, documentation, blog, and examples happens via *Pull requests*. If you are still not familiar with  Pull Requests (PR for short) here is a short guide. It's about the `lvgl` repository but it works the same way for other repositories too.
-1. **Fork** the [lvgl repository](https://github.com/lvgl/lvgl). To do this click the "Fork" button in the top right corner. It will "copy" the `lvgl` repository to your GitHub account (`https://github.com/your_name?tab=repositories`)
-2. **Clone**  the forked repository and add your changes
-3. **Create a PR** on GitHub from the page of your `lvgl` repository (`https://github.com/your_name/lvgl`) by hitting the "New pull request" button 
-4. **Set the base branch**. It means where you want to merge your update. Fixes go to `master`, new features to feature branch. 
-5. **Describe** what is in the update. An example code is welcome if applicable.
-6. **Update** your `lvgl` branch with new commits. They will appear in the PR too.
-
-Some advice:
-- For non-trivial fixes and features it's better open an issue first to discuss the details.
-- Maybe your fix or update won't be perfect at first. Don't be afraid, just improve it and push the new commits. The PR will be updated accordingly. 
-- If your update needs some extra work it's okay to say: _"I'm busy now and I will improve it soon"_ or _"Sorry, I don't have time to improve it, I hope it helps in this form too"_. 
-So it's better to say don't have time to continue than saying nothing.
-- Please read and follow this [guide about the coding style](https://github.com/lvgl/lvgl/blob/master/docs/CODING_STYLE.md)
-
-## Help others in the Forum
-
-It's a great way to contribute to the library if you already use it. 
-Just go to [https://forum.lvgl.io/](https://forum.lvgl.io/) a register (Google and GitHub login also works).
-Log in, read the titles and if you are already familiar with a topic, don't be shy, and write your suggestion.
-
-## Improve or translate the documentation
-
-If you would like to contribute to LVGL the documentation is the best place to start.
-
-### Fix typos, add missing parts
-
-If you find a typo, an obscure sentence or something which is not explained well enough in the [English documentation](https://docs.lvgl.io/en/html/index.html) 
-click the *"Edit on GitHub"* button in the top right corner and fix the issue by sending a Pull Request.
-
-### Translate the documentation
-
-If you have time and interest you can translate the documentation to your native language or any language you speak well. 
-You can join others to work on an already existing language or you can start a new one.  
-
-To translate the documentation we use [Zanata](https://zanata.org) which is an online translation platform. 
-You will find the LVGL project here: [LVGL on Zanata](https://translate.zanata.org/iteration/view/littlevgl-docs/v6.0-doc1?dswid=3430) 
-
-To get started you need to:
-- register at [Zanata](https://zanata.org) which is an online translation platform.  
-- comment to [this post](https://forum.lvgl.io/t/translate-the-documentation/238?u=kisvegabor)
-- tell your username at *Zanata* and your selected language(s) to get permission the edit the translations
-
-Note that a translation will be added to the documentation only if the following parts are translated: 
-- [Home page](https://docs.lvgl.io/en/v7/)
-- [Porting section](https://docs.lvgl.io/en/v7/html/porting/index.html) 
-- [Quick overview](https://docs.lvgl.io/v7/en/html/get-started/quick-overview.html)
-
-## Write a blog post
-
-Have you ported LVGL to a new platform or created a fancy GUI? Do you know a great trick? 
-You can share your knowledge on LVGL's blog! It's super easy to add your own post:
-- Fork and clone the [blog repository](https://github.com/lvgl/blog)
-- Add your post in Markdown to the `_posts` folder. 
-- Store the images and other resources in a dedicated folder in `assets`
-- Create a Pull Request
-
-The blog uses [Jekyll](https://jekyllrb.com/) to convert the `.md` files to a webpage. You can easily [run Jekyll offline](https://jekyllrb.com/docs/) to check your post before creating the Pull request
-
-## Report or fix bugs
-For simple bugfixes (typos, missing error handling, fixing a warning) it's fine to send a Pull request directly. However, for more complex bugs it's better to open an issue first. In the issue, you should describe how to reproduce the bug and add the minimal code snippet.
-
-## Suggest or implement new features
-If you have a good idea don't hesitate to share with us. It's even better if you have time to deal with its implementation. Don't be afraid if you still don't know LVGL well enough. We will help you to get started. 
-
-To share your ideas use [Feature request](https://forum.lvgl.io/c/feature-request/9) category of the forum.
-
-If you are ready to get involved into the development of this faetures feel free to pen a [new issue](https://github.com/lvgl/lvgl/issues) for it on GitHub.
-
-During the implementation don't forget the [Code style guide](https://github.com/lvgl/lvgl/blob/master/docs/CODING_STYLE.md).
-
-If you implemented a new feature it's important to record it in the documentation and if applicable create an example for it:
-- Go to the [docs](https://github.com/lvgl/docs/tree/master/v7/en) repository and update the relevant part of the English documentation.
-- Go to the [examples](https://github.com/lvgl/lv_examples) repository and add a new file about the new feature in the related directory. 
-
-## Summary
-
-I hope you have taken a liking to contribute to LVGL. A helpful and friendly community is waiting for you! :) 
+For a detailed description of contribution opportunities, please visit the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) section of the documentation.

docs/ROADMAP.md

@@ -0,0 +1,34 @@
+# Roadmap
+
+This is a summary for thenew fatures of the major releases and a collection of ideas. 
+
+This list indicates only the current intention and can be changed.
+
+## v8
+Planned to September/October 2020
+- New scrolling:
+  - See [feat/new-scroll](https://github.com/lvgl/lvgl/tree/feat/new-scroll) branch and  [#1614](https://github.com/lvgl/lvgl/issues/1614)) issue.
+  - Remove `lv_page` and support scrolling on `lv_obj`
+  - Support "elastic" scrolling when scrolled in
+  - Support scroll chaining among any objects types (not only `lv_pages`s)
+  - Remove `lv_drag`. Similar effect can be achieved by setting the position in `LV_EVENT_PRESSING`
+  - Add snapping?
+  - Already working
+- New layouts:
+  - See [#1615](https://github.com/lvgl/lvgl/issues/1615) issue
+  - [CSS Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/)-like layout support
+  - Besides setting width/height in `px` add support to `partent percentage` and `screen percentage`.
+  - Work in progress
+- Simplified File system interface ([feat/new_fs_api](https://github.com/lvgl/lvgl/tree/feat/new-fs-api) branch) to make porting easier
+  - Work in progress
+- Add new label alignment modes
+  - See [#1656](https://github.com/lvgl/lvgl/issues/1656)
+
+## Ideas
+- Unit testing (gtest?). See [#1658](https://github.com/lvgl/lvgl/issues/1658)
+- Benchmarking (gem5?). See [#1660](https://github.com/lvgl/lvgl/issues/1660)
+- CPP binding. See [Forum](https://forum.lvgl.io/t/is-it-possible-to-officially-support-optional-cpp-api/2736)
+- Optmize font decompression
+- Switch to RGBA colors in styles
+- Need coverage report for tests
+- Need static analize (via coverity.io or somehing else). 

examples/arduino/ESP32_TFT_eSPI/ESP32_TFT_eSPI.ino

@@ -0,0 +1,119 @@
+#include <lvgl.h>
+#include <TFT_eSPI.h>
+
+TFT_eSPI tft = TFT_eSPI(); /* TFT instance */
+static lv_disp_buf_t disp_buf;
+static lv_color_t buf[LV_HOR_RES_MAX * 10];
+
+#if USE_LV_LOG != 0
+/* Serial debugging */
+void my_print(lv_log_level_t level, const char * file, uint32_t line, const char * dsc)
+{
+
+    Serial.printf("%s@%d->%s\r\n", file, line, dsc);
+    Serial.flush();
+}
+#endif
+
+/* Display flushing */
+void my_disp_flush(lv_disp_drv_t *disp, const lv_area_t *area, lv_color_t *color_p)
+{
+    uint32_t w = (area->x2 - area->x1 + 1);
+    uint32_t h = (area->y2 - area->y1 + 1);
+
+    tft.startWrite();
+    tft.setAddrWindow(area->x1, area->y1, w, h);
+    tft.pushColors(&color_p->full, w * h, true);
+    tft.endWrite();
+
+    lv_disp_flush_ready(disp);
+}
+
+/*Read the touchpad*/
+bool my_touchpad_read(lv_indev_drv_t * indev_driver, lv_indev_data_t * data)
+{
+    uint16_t touchX, touchY;
+
+    bool touched = tft.getTouch(&touchX, &touchY, 600);
+
+    if(!touched)
+    {
+      data->state = LV_INDEV_STATE_REL;
+      return false;
+    }
+    else
+    {
+      data->state = LV_INDEV_STATE_PR;
+    }
+
+    if(touchX>screenWidth || touchY > screenHeight)
+    {
+      Serial.println("Y or y outside of expected parameters..");
+      Serial.print("y:");
+      Serial.print(touchX);
+      Serial.print(" x:");
+      Serial.print(touchY);
+    }
+    else
+    {
+      /*Set the coordinates*/
+      data->point.x = touchX;
+      data->point.y = touchY;
+  
+      Serial.print("Data x");
+      Serial.println(touchX);
+      
+      Serial.print("Data y");
+      Serial.println(touchY);
+
+    }
+
+    return false; /*Return `false` because we are not buffering and no more data to read*/
+}
+
+void setup()
+{
+    Serial.begin(115200); /* prepare for possible serial debug */
+
+    lv_init();
+
+#if USE_LV_LOG != 0
+    lv_log_register_print_cb(my_print); /* register print function for debugging */
+#endif
+
+    tft.begin(); /* TFT init */
+    tft.setRotation(1); /* Landscape orientation */
+
+    uint16_t calData[5] = { 275, 3620, 264, 3532, 1 };
+    tft.setTouch(calData);
+  
+    lv_disp_buf_init(&disp_buf, buf, NULL, LV_HOR_RES_MAX * 10);
+
+    /*Initialize the display*/
+    lv_disp_drv_t disp_drv;
+    lv_disp_drv_init(&disp_drv);
+    disp_drv.hor_res = 320;
+    disp_drv.ver_res = 240;
+    disp_drv.flush_cb = my_disp_flush;
+    disp_drv.buffer = &disp_buf;
+    lv_disp_drv_register(&disp_drv);
+
+    /*Initialize the (dummy) input device driver*/
+    lv_indev_drv_t indev_drv;
+    lv_indev_drv_init(&indev_drv);
+    indev_drv.type = LV_INDEV_TYPE_POINTER;
+    indev_drv.read_cb = my_touchpad_read;
+    lv_indev_drv_register(&indev_drv);
+
+		/* Try an example from the lv_examples repository
+		 * https://github.com/lvgl/lv_examples*/
+		lv_ex_btn_1();
+}
+
+
+void loop()
+{
+
+    lv_task_handler(); /* let the GUI do its work */
+    delay(5);
+}

examples/arduino/ESP32_TFT_eSPI/README.md

@@ -0,0 +1,44 @@
+# Example for lv_arduino using a slider
+
+This example has the screen set to 320x480 (ILI9488), change this by altering the following lines in the main ino file:
+
+```C
+int screenWidth = 480;
+int screenHeight = 320;
+```
+
+## Backlight
+
+Change pin 32 to your preferred backlight pin using a PNP transistor (2N3906) or remove the following code and connect directly to +ve:
+
+```C
+  ledcSetup(10, 5000/*freq*/, 10 /*resolution*/);
+  ledcAttachPin(32, 10);
+  analogReadResolution(10);
+  ledcWrite(10,768);
+```
+
+## Theme selection
+
+Change the following to change the theme:
+
+```C
+  lv_theme_t * th = lv_theme_night_init(210, NULL);     //Set a HUE value and a Font for the Night Theme
+  lv_theme_set_current(th);
+```
+
+## Calibration
+
+This is using the bodmer tft_espi driver for touch. To correctly set the calibration load the calibration sketch and replace the following with your values:
+
+```C
+uint16_t calData[5] = { 275, 3620, 264, 3532, 1 };
+```
+
+## Screen rotation
+
+Check the following if you need to alter your screen rotation:
+
+```C
+  tft.setRotation(3);
+```

examples/arduino/README.md

@@ -0,0 +1,37 @@
+# LVGL Arduino examples
+
+LVGL can be installed via Arduino IDE Library Manager or as an .ZIP library.
+It will install [lv_exmaples](https://github.com/lvgl/lv_examples) which contains a lot of examples and demos to try LVGL.
+
+## Example
+
+There are simple examples which use the [TFT_eSPI](https://github.com/Bodmer/TFT_eSPI) library as a TFT driver to simplify testing. 
+To get all this to work you have to setup TFT_eSPI to work with your TFT display type via editing the `User_Setup.h` file in TFT_eSPI library folder, or by selecting your own configurtion in the `User_Setup_Select.h` file in TFT_eSPI library folder.
+
+LVGL library has its own configuration file called `lv_conf.h`. When LVGL is installed to followings needs to be done to configure it:
+1. Go to directory of the installed Arduno libraries
+2. Go to `lvgl` and copy `lv_conf_template.h` as `lvgl.h` next to the `lvgl` folder.
+3. Open `lv_conf.h` and change the first `#if 0` to `#if 1`
+4. Set the resolution of your display in `LV_HOR_RES_MAX` and `LV_VER_RES_MAX`
+5. Set the color depth of you display in `LV_COLOR_DEPTH`
+6. Set `LV_TICK_CUSTOM 1`
+
+## Debugging
+
+In case of trouble there are debug informations inside LVGL. In the `ESP32_TFT_eSPI` example there is `my_print` method, which allow to send this debug informations to the serial interface. To enable this feature you have to edit `lv_conf.h` file and enable logging in section `log settings`:
+
+```c
+/*Log settings*/
+#define USE_LV_LOG      1   /*Enable/disable the log module*/
+#if LV_USE_LOG
+/* How important log should be added:
+ * LV_LOG_LEVEL_TRACE       A lot of logs to give detailed information
+ * LV_LOG_LEVEL_INFO        Log important events
+ * LV_LOG_LEVEL_WARN        Log if something unwanted happened but didn't cause a problem
+ * LV_LOG_LEVEL_ERROR       Only critical issue, when the system may fail
+ * LV_LOG_LEVEL_NONE        Do not log anything
+ */
+#  define LV_LOG_LEVEL    LV_LOG_LEVEL_WARN
+```
+
+After enabling log module and setting LV_LOG_LEVEL accordingly the output log is sent to the `Serial` port @ 115200 Bd.

library.json

@@ -1,14 +1,17 @@
 {
-    "name": "lvgl",
-    "version": "v7.0.2",
-    "keywords": "graphics, gui, embedded, littlevgl",
-    "description": "Graphics library to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint. It offers anti-aliasing, opacity, and animations using only one frame buffer.",
-    "repository":
-    {
-        "type": "git",
-        "url": "https://github.com/lvgl/lvgl.git"
-    },
-    "build": {
-        "includeDir": "."
-    }
+	"name": "lvgl",
+    "version": "7.3.0",
+	"keywords": "graphics, gui, embedded, tft, lvgl",
+	"description": "Graphics library to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint. It offers anti-aliasing, opacity, and animations using only one frame buffer.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/lvgl/lvgl.git"
+	},
+	"build": {
+		"includeDir": "."
+	},
+	"license": "MIT",
+	"homepage": "https://lvgl.io",
+	"frameworks": "*",
+	"platforms": "*"
 }

library.properties

@@ -0,0 +1,10 @@
+name=lvgl
+version=7.3.0
+author=kisvegabor
+maintainer=kisvegabor,embeddedt,pete-pjb
+sentence=Full-featured Graphics Library for Embedded Systems
+paragraph=Powerful and easy-to-use embedded GUI with many widgets, advanced visual effects (opacity, antialiasing, animations) and low memory requirements (16K RAM, 64K Flash).
+category=Display
+url=https://lvgl.io
+architectures=*
+includes=lvgl.h

lv_conf_template.h

@@ -1,6 +1,6 @@
 /**
  * @file lv_conf.h
- * Configuration file for LVGL v7.0.2
+ * Configuration file for LVGL v7.3.0
  */
 
 /*
@@ -97,6 +97,10 @@ typedef int16_t lv_coord_t;
 #  define LV_MEM_CUSTOM_FREE    free         /*Wrapper to free*/
 #endif     /*LV_MEM_CUSTOM*/
 
+/* Use the standard memcpy and memset instead of LVGL's own functions.
+ * The standard functions might or might not be faster depending on their implementation. */
+#define LV_MEMCPY_MEMSET_STD    0
+
 /* Garbage Collector settings
  * Used if lvgl is binded to higher level language and the memory is managed by that language */
 #define LV_ENABLE_GC 0
@@ -150,7 +154,7 @@ typedef void * lv_anim_user_data_t;
 
 #endif
 
-/* 1: Enable shadow drawing*/
+/* 1: Enable shadow drawing on rectangles*/
 #define LV_USE_SHADOW           1
 #if LV_USE_SHADOW
 /* Allow buffering some shadow calculation
@@ -160,6 +164,15 @@ typedef void * lv_anim_user_data_t;
 #define LV_SHADOW_CACHE_SIZE    0
 #endif
 
+/*1: enable outline drawing on rectangles*/
+#define LV_USE_OUTLINE  1
+
+/*1: enable pattern drawing on rectangles*/
+#define LV_USE_PATTERN  1
+
+/*1: enable value string drawing on rectangles*/
+#define LV_USE_VALUE_STR    1
+
 /* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
 #define LV_USE_BLEND_MODES      1
 
@@ -178,6 +191,9 @@ typedef void * lv_group_user_data_t;
 /* 1: Enable GPU interface*/
 #define LV_USE_GPU              1   /*Only enables `gpu_fill_cb` and `gpu_blend_cb` in the disp. drv- */
 #define LV_USE_GPU_STM32_DMA2D  0
+/*If enabling LV_USE_GPU_STM32_DMA2D, LV_GPU_DMA2D_CMSIS_INCLUDE must be defined to include path of CMSIS header of target processor
+e.g. "stm32f769xx.h" or "stm32f429xx.h" */
+#define LV_GPU_DMA2D_CMSIS_INCLUDE
 
 /* 1: Enable file system (might be required for images */
 #define LV_USE_FILESYSTEM       1
@@ -194,6 +210,7 @@ typedef void * lv_fs_drv_user_data_t;
 
 /*1: Use the functions and types from the older API if possible */
 #define LV_USE_API_EXTENSION_V6  1
+#define LV_USE_API_EXTENSION_V7  1
 
 /*========================
  * Image decoder and cache
@@ -219,6 +236,10 @@ typedef void * lv_img_decoder_user_data_t;
 /*=====================
  *  Compiler settings
  *====================*/
+
+/* For big endian systems set to 1 */
+#define LV_BIG_ENDIAN_SYSTEM    0
+
 /* Define a custom attribute to `lv_tick_inc` function */
 #define LV_ATTRIBUTE_TICK_INC
 
@@ -249,6 +270,10 @@ typedef void * lv_img_decoder_user_data_t;
  */
 #define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning
 
+/* Prefix variables that are used in GPU accelerated operations, often these need to be
+ * placed in RAM sections that are DMA accessible */
+#define LV_ATTRIBUTE_DMA
+
 /*===================
  *  HAL settings
  *==================*/
@@ -257,8 +282,8 @@ typedef void * lv_img_decoder_user_data_t;
  * It removes the need to manually update the tick with `lv_tick_inc`) */
 #define LV_TICK_CUSTOM     0
 #if LV_TICK_CUSTOM == 1
-#define LV_TICK_CUSTOM_INCLUDE  "something.h"       /*Header for the sys time function*/
-#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current systime in ms*/
+#define LV_TICK_CUSTOM_INCLUDE  "Arduino.h"         /*Header for the system time function*/
+#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current system time in ms*/
 #endif   /*LV_TICK_CUSTOM*/
 
 typedef void * lv_disp_drv_user_data_t;             /*Type of user data in the display driver*/
@@ -337,8 +362,8 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
 /* 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_14    1
+#define LV_FONT_MONTSERRAT_16    0
 #define LV_FONT_MONTSERRAT_18    0
 #define LV_FONT_MONTSERRAT_20    0
 #define LV_FONT_MONTSERRAT_22    0
@@ -379,11 +404,20 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
  * but with > 10,000 characters if you see issues probably you need to enable it.*/
 #define LV_FONT_FMT_TXT_LARGE   0
 
+/* Enables/disables support for compressed fonts. If it's disabled, compressed
+ * glyphs cannot be processed by the library and won't be rendered.
+ */
+#define LV_USE_FONT_COMPRESSED 1
+
+/* Enable subpixel rendering */
+#define LV_USE_FONT_SUBPX 1
+#if LV_USE_FONT_SUBPX
 /* Set the pixel order of the display.
  * Important only if "subpx fonts" are used.
  * With "normal" font it doesn't matter.
  */
 #define LV_FONT_SUBPX_BGR    0
+#endif
 
 /*Declare the type of the user data of fonts (can be e.g. `void *`, `int`, `struct`)*/
 typedef void * lv_font_user_data_t;
@@ -405,7 +439,10 @@ typedef void * lv_font_user_data_t;
 /* A fast and impressive theme.
  * Flags:
  * LV_THEME_MATERIAL_FLAG_LIGHT: light theme
- * LV_THEME_MATERIAL_FLAG_DARK: dark theme*/
+ * LV_THEME_MATERIAL_FLAG_DARK: dark theme
+ * LV_THEME_MATERIAL_FLAG_NO_TRANSITION: disable transitions (state change animations)
+ * LV_THEME_MATERIAL_FLAG_NO_FOCUS: disable indication of focused state)
+ * */
  #define LV_USE_THEME_MATERIAL    1
 
 /* Mono-color theme for monochrome displays.
@@ -417,13 +454,13 @@ typedef void * lv_font_user_data_t;
 
 #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_COLOR_PRIMARY      lv_color_hex(0x01a2b1)
+#define LV_THEME_DEFAULT_COLOR_SECONDARY    lv_color_hex(0x44d1b6)
 #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
+#define LV_THEME_DEFAULT_FONT_SMALL         &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_NORMAL        &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_SUBTITLE      &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_TITLE         &lv_font_montserrat_14
 
 /*=================
  *  Text settings
@@ -529,6 +566,9 @@ typedef void * lv_obj_user_data_t;
 
 /*Calendar (dependencies: -)*/
 #define LV_USE_CALENDAR 1
+#if LV_USE_CALENDAR
+#  define LV_CALENDAR_WEEK_STARTS_MONDAY    0
+#endif
 
 /*Canvas (dependencies: lv_img)*/
 #define LV_USE_CANVAS   1

lvgl.h

@@ -2,7 +2,7 @@
  * @file lvgl.h
  * Include all LittleV GL related headers
  */
-
+ 
 #ifndef LVGL_H
 #define LVGL_H
 
@@ -77,9 +77,9 @@ extern "C" {
  *********************/
 /*Current version of LVGL*/
 #define LVGL_VERSION_MAJOR   7
-#define LVGL_VERSION_MINOR   0
-#define LVGL_VERSION_PATCH   2
-#define LVGL_VERSION_INFO ""
+#define LVGL_VERSION_MINOR   3
+#define LVGL_VERSION_PATCH   1
+#define LVGL_VERSION_INFO "dev"
 
 /**********************
  *      TYPEDEFS

scripts/lv_conf_checker.py

@@ -1,12 +1,17 @@
-#!/usr/bin/env python3.6
+#!/usr/bin/env python3
 
 '''
 Generates a checker file for lv_conf.h from lv_conf_templ.h define all the not defined values
 '''
 
 
+import sys
 import re
 
+if sys.version_info < (3,6,0):
+  print("Python >=3.6 is required", file=sys.stderr)
+  exit(1)
+
 fin = open("../lv_conf_template.h", "r")
 fout = open("../src/lv_conf_internal.h", "w")
 

scripts/release.py

@@ -1,240 +1,233 @@
+#!/usr/bin/env python
+ 
 import re
 import os
 lastNum = re.compile(r'(?:[^\d]*(\d+)[^\d]*)+')
 
    
 def title(t):
-	print("\n---------------------------------")
-	print(t)
-	print("---------------------------------")
+  print("\n---------------------------------")
+  print(t)
+  print("---------------------------------")
 
    
 def cmd(c):
-	print("\n" + c)
-	os.system(c)		   
-   
-
-def increment(s):
-    """ look for the last sequence of number(s) in a string and increment """
-    m = lastNum.search(s)
-    if m:
-        next = str(int(m.group(1))+1)
-        start, end = m.span(1)
-        s = s[:max(end-len(next), start)] + next + s[end:]
-    return s, str(next)
-
+  print("\n" + c)
+  r = os.system(c)       
+  if r:
+    print("### Error: " + str(r))
 
 def lvgl_clone():
-	title("lvgl: Clone")
-	cmd("git clone https://github.com/lvgl/lvgl.git")
-	os.chdir("./lvgl")
-	cmd("git co master") 
+  title("lvgl: Clone")
+  cmd("git clone https://github.com/lvgl/lvgl.git")
+  os.chdir("./lvgl")
+  cmd("git co master") 
 
 def lvgl_format():
   title("lvgl: Run code formatter")
   os.chdir("./scripts")
-  cmd("./code-formatter.sh")
-  cmd("git ci -am 'Run code formatter'")
+  cmd("./code-format.sh")
+  os.system("git ci -am 'Run code formatter'")
   os.chdir("..")
 
 def lvgl_update_version():
-	title("lvgl: Update version number")
+  title("lvgl: Update version number")
 
-	f = open("./lvgl.h", "r")
-		  
-	outbuf = ""
-	major_ver = -1
-	minor_ver = -1
-	patch_ver = -1
-		  
-	for i in f.read().splitlines():
-		r = re.search(r'^#define LVGL_VERSION_MAJOR ', i)
-		if r: 
-		  m = lastNum.search(i)
-		  if m: major_ver = m.group(1)
+  f = open("./lvgl.h", "r")
+      
+  outbuf = ""
+  major_ver = -1
+  minor_ver = -1
+  patch_ver = -1
+      
+  for i in f.read().splitlines():
+    r = re.search(r'^#define LVGL_VERSION_MAJOR ', i)
+    if r: 
+      m = lastNum.search(i)
+      if m: major_ver = m.group(1)
 
-		r = re.search(r'^#define LVGL_VERSION_MINOR ', i)
-		if r: 
-		  m = lastNum.search(i)
-		  if m: minor_ver = m.group(1)
-		  
-		r = re.search(r'^#define LVGL_VERSION_PATCH ', i)
-		if r: 
-		  m = lastNum.search(i)
-		  if m: patch_ver = m.group(1)
-		 
-		  
-		r = re.search(r'^#define LVGL_VERSION_INFO ', i)
-		if r: 
-		  i = "#define LVGL_VERSION_INFO \"\""
-		   
-		outbuf += i + '\n'
-	 
-	f.close()
+    r = re.search(r'^#define LVGL_VERSION_MINOR ', i)
+    if r: 
+      m = lastNum.search(i)
+      if m: minor_ver = m.group(1)
+      
+    r = re.search(r'^#define LVGL_VERSION_PATCH ', i)
+    if r: 
+      m = lastNum.search(i)
+      if m: patch_ver = m.group(1)
+     
+      
+    r = re.search(r'^#define LVGL_VERSION_INFO ', i)
+    if r: 
+      i = "#define LVGL_VERSION_INFO \"\""
+       
+    outbuf += i + '\n'
+   
+  f.close()
 
-	f = open("./lvgl.h", "w")
-		  
-	f.write(outbuf)
-	f.close()
+  f = open("./lvgl.h", "w")
+      
+  f.write(outbuf)
+  f.close()
     
-	s = "v" + str(major_ver) + "." + str(minor_ver) + "." + str(patch_ver)
-	print("New version:" + s)
-	return s
+  s = "v" + str(major_ver) + "." + str(minor_ver) + "." + str(patch_ver)
+  print("New version:" + s)
+  return s
 
 
 
 def lvgl_update_library_json(v):
-	title("lvgl: Update version number in library.json")
+  title("lvgl: Update version number in library.json")
 
-	f = open("./library.json", "r")
-		  
-	outbuf = ""
-		  
-	for i in f.read().splitlines():
-		r = re.search(r'"version": ', i)
-		if r: 
-		  i = '    "version": "' + v + '",'
-		   
-		outbuf += i + '\n'
-	 
-	f.close()
+  f = open("./library.json", "r")
+  vn = v[1:]    
+  outbuf = ""
+      
+  for i in f.read().splitlines():
+    r = re.search(r'"version": ', i)
+    if r: 
+      i = '    "version": "' + vn + '",'
+       
+    outbuf += i + '\n'
+   
+  f.close()
 
-	f = open("./library.json", "w")
-		  
-	f.write(outbuf)
-	f.close()
+  f = open("./library.json", "w")
+      
+  f.write(outbuf)
+  f.close()
 
 def lvgl_update_lv_conf_templ(ver_str):
-	title("lvgl: Update version number in lv_conf_template.h")
-	cmd("sed -i -r 's/v[0-9]+\.[0-9]+\.[0-9]+/"+ ver_str +"/' lv_conf_template.h ")
+  title("lvgl: Update version number in lv_conf_template.h")
+  cmd("sed -i -r 's/v[0-9]+\.[0-9]+\.[0-9]+/"+ ver_str +"/' lv_conf_template.h ")
 
 
 def lvgl_commit_push(v):
-	title("lvgl: commit and push release")
+  title("lvgl: commit and push release")
 
-	cmd('git ci -am "Release ' + v + '"')
-	cmd('git tag -a ' + v + ' -m "Release ' + v +'"')
-	cmd('git push origin master')
-	cmd('git push origin ' + v)
+  os.system('git ci -am "Release ' + v + '"')
+  cmd('git tag -a ' + v + ' -m "Release ' + v +'"')
+  cmd('git push origin master')
+  cmd('git push origin ' + v)
 
 
 def lvgl_merge_to_release_branch(v):
-	title("lvgl: merge to release branch")
-	cmd('git co release/v7')
-	cmd('git merge master')
-	cmd('git push origin release/v7')
-	
-	
+  title("lvgl: merge to release branch")
+  cmd('git co release/v7')
+  cmd('git merge master')
+  cmd('git push origin release/v7')
+  os.chdir("../")
+  
+  
 def lvgl_update_api_docs():
-	title("lvgl: Update API with Doxygen")
+  title("lvgl: Update API with Doxygen")
 
-	cmd("cd scripts; doxygen");
-	os.chdir("../")
+  cmd("cd scripts; doxygen");
 
 
 def examples_clone():
-	title("examples: Clone")
-	cmd("git clone https://github.com/lvgl/lv_examples.git")
-	os.chdir("./lv_examples")
-	cmd("git co master") 
+  title("examples: Clone")
+  cmd("git clone https://github.com/lvgl/lv_examples.git")
+  os.chdir("./lv_examples")
+  cmd("git co master") 
 
 def examples_commit_push(v):
-	title("examples: commit and push release")
+  title("examples: commit and push release")
 
-	cmd('git ci -am "Release ' + v + '"')
-	cmd('git tag -a ' + v + ' -m "Release ' + v +'"')
-	cmd('git push origin master')
-	cmd('git push origin ' + v)
+  os.system('git ci -am "Release ' + v + '"')
+  cmd('git tag -a ' + v + ' -m "Release ' + v +'"')
+  cmd('git push origin master')
+  cmd('git push origin ' + v)
 
 
 def examples_merge_to_release_branch(v):
-	title("examples: merge to release branch")
-	cmd('git co release/v7')
-	cmd('git merge master')
-	cmd('git push origin release/v7')
-	os.chdir("../")
-	
-	
+  title("examples: merge to release branch")
+  cmd('git co release/v7')
+  cmd('git merge master')
+  cmd('git push origin release/v7')
+  os.chdir("../")
+  
+  
 def drivers_clone():
-	title("drivers: Clone")
-	cmd("git clone https://github.com/lvgl/lv_drivers.git")
-	os.chdir("./lv_drivers")
-	cmd("git co master") 
+  title("drivers: Clone")
+  cmd("git clone https://github.com/lvgl/lv_drivers.git")
+  os.chdir("./lv_drivers")
+  cmd("git co master") 
 
 def drivers_commit_push(v):
-	title("drivers: commit and push release")
+  title("drivers: commit and push release")
 
-	cmd('git ci -am "Release ' + v + '"')
-	cmd('git tag -a ' + v + ' -m "Release ' + v +'"')
-	cmd('git push origin master')
-	cmd('git push origin ' + v)
+  os.system('git ci -am "Release ' + v + '"')
+  cmd('git tag -a ' + v + ' -m "Release ' + v +'"')
+  cmd('git push origin master')
+  cmd('git push origin ' + v)
 
 def drivers_merge_to_release_branch(v):
-	title("drivers: merge to release branch")
-	cmd('git co release/v7')
-	cmd('git merge master')
-	cmd('git push origin release/v7')
-	os.chdir("../")
+  title("drivers: merge to release branch")
+  cmd('git co release/v7')
+  cmd('git merge master')
+  cmd('git push origin release/v7')
+  os.chdir("../")
 
 def docs_clone():
-	title("docs: Clone")
-	cmd("git clone --recursive https://github.com/lvgl/docs.git")
-	os.chdir("./docs/v7")
-	cmd("git co master") 
+  title("docs: Clone")
+  cmd("git clone --recursive https://github.com/lvgl/docs.git")
+  os.chdir("./docs")
 
 def docs_get_api():
-	title("docs: Get API files")
-	
-	cmd("rm -rf xml");	
-	cmd("cp -r ../../lvgl/docs/api_doc/xml .");	
+  title("docs: Get API files")
+  
+  cmd("git co latest --") 
+  cmd("rm -rf xml");  
+  cmd("cp -r ../lvgl/docs/api_doc/xml .");  
+  cmd("git add xml");
+  cmd('git commit -m "update API"')  
 
 def docs_update_version(v):
-	title("docs: Update version number")
+  title("docs: Update version number")
 
-	f = open("./conf.py", "r")
-		  
-	outbuf = ""
-		  
-	for i in f.read().splitlines():
-		r = re.search(r'^version = ', i)
-		if r: 
-		  i = "version = '" + v + "'"
+  f = open("./conf.py", "r")
+      
+  outbuf = ""
+      
+  for i in f.read().splitlines():
+    r = re.search(r'^version = ', i)
+    if r: 
+      i = "version = '" + v + "'"
 
-		r = re.search(r'^release = ', i)
-		if r: 
-		  i = "version = '" + v + "'"
-		   
-		outbuf += i + '\n'
-	 
-	f.close()
+    r = re.search(r'^release = ', i)
+    if r: 
+      i = "version = '" + v + "'"
+       
+    outbuf += i + '\n'
+   
+  f.close()
 
-	f = open("./conf.py", "w")
-		  
-	f.write(outbuf)
-	f.close()
+  f = open("./conf.py", "w")
+      
+  f.write(outbuf)
+  f.close()
+  cmd("git add conf.py")
+  cmd('git ci -m "update conf.py to ' + v + '"')
 
-def docs_update_trans():
-	title("docs: Update translations")
-	cmd("cd en && ./trans_push.py && ./trans_pull.py")
+
+def docs_merge_to_release_branch(v):
+  title("docs: merge to release branch")
+  cmd('git co release/v7 --')
+  cmd('git clean -fd .')
+  cmd('rm -f LVGL.pdf')	#To avoide possible merge conflict
+  cmd('git merge latest')
+  cmd('git push origin release/v7')
 
 def docs_build():
-	title("docs: Build")
-	cmd("./build.py clean")
-
-	
-def docs_commit_push(v):
-	title("docs: Commit release")
-
-	cmd('git add .')
-	cmd('git ci -am "Release ' + v + '"')
-	cmd('git tag -a ' + v + ' -m "Release ' + v +'"')
-	cmd('git push origin master')
-	cmd('git push origin ' + v)
-	
+  title("docs: Build")
+  cmd("git checkout master")
+  cmd("./update.py latest release/v7")
+  
 def clean_up():
-	title("Clean up repos")
-	os.chdir("../..")
-	cmd("rm -rf lvgl docs lv_examples lv_drivers")
+  title("Clean up repos")
+  os.chdir("../")
+  cmd("rm -rf lvgl docs lv_examples lv_drivers")
 
 lvgl_clone()
 lvgl_format()
@@ -256,8 +249,7 @@ drivers_merge_to_release_branch(ver_str)
 docs_clone()
 docs_get_api()
 docs_update_version(ver_str)
-#docs_update_trans() # Zanata is not working now
+docs_merge_to_release_branch(ver_str)
 docs_build()    
-docs_commit_push(ver_str)
 
 clean_up()

src/lv_api_map.h

@@ -153,7 +153,7 @@ static inline void lv_roller_set_fix_width(lv_obj_t * roller, lv_coord_t w)
 #define lv_scrlbar_mode_t lv_scrollbar_mode_t
 
 #define LV_SCRLBAR_MODE_OFF    LV_SCROLLBAR_MODE_OFF
-#define LV_SCRLBAR_MODE_ON     LV_SCRILLBAR_MODE_ON
+#define LV_SCRLBAR_MODE_ON     LV_SCROLLBAR_MODE_ON
 #define LV_SCRLBAR_MODE_DRAG   LV_SCROLLBAR_MODE_DRAG
 #define LV_SCRLBAR_MODE_AUTO   LV_SCROLLBAR_MODE_AUTO
 #define LV_SCRLBAR_MODE_HIDE   LV_SCROLLBAR_MODE_HIDE
@@ -176,8 +176,33 @@ static inline lv_obj_t * lv_page_get_scrl(lv_obj_t * page)
 }
 #endif
 
+
 #endif /*LV_USE_API_EXTENSION_V6*/
 
+
+
+
+/*---------------------
+ * V7.0 COMPATIBILITY
+ *--------------------*/
+#if LV_USE_API_EXTENSION_V7
+#if LV_USE_WIN
+
+static inline lv_obj_t * lv_win_add_btn(lv_obj_t * win, const void * img_src)
+{
+    return lv_win_add_btn_right(win, img_src);
+}
+
+#endif
+
+#if LV_USE_CHART
+static inline void lv_chart_set_range(lv_obj_t * chart, lv_coord_t ymin, lv_coord_t ymax)
+{
+    lv_chart_set_y_range(chart, LV_CHART_AXIS_PRIMARY_Y, ymin,  ymax);
+}
+#endif
+
+#endif /*LV_USE_API_EXTENSION_V6*/
 /**********************
  *      MACROS
  **********************/

src/lv_conf_internal.h

@@ -147,6 +147,12 @@
 #endif
 #endif     /*LV_MEM_CUSTOM*/
 
+/* Use the standard memcpy and memset instead of LVGL's own functions.
+ * The standard functions might or might not be faster depending on their implementation. */
+#ifndef LV_MEMCPY_MEMSET_STD
+#define LV_MEMCPY_MEMSET_STD    0
+#endif
+
 /* Garbage Collector settings
  * Used if lvgl is binded to higher level language and the memory is managed by that language */
 #ifndef LV_ENABLE_GC
@@ -223,7 +229,7 @@
 
 #endif
 
-/* 1: Enable shadow drawing*/
+/* 1: Enable shadow drawing on rectangles*/
 #ifndef LV_USE_SHADOW
 #define LV_USE_SHADOW           1
 #endif
@@ -237,6 +243,21 @@
 #endif
 #endif
 
+/*1: enable outline drawing on rectangles*/
+#ifndef LV_USE_OUTLINE
+#define LV_USE_OUTLINE  1
+#endif
+
+/*1: enable pattern drawing on rectangles*/
+#ifndef LV_USE_PATTERN
+#define LV_USE_PATTERN  1
+#endif
+
+/*1: enable value string drawing on rectangles*/
+#ifndef LV_USE_VALUE_STR
+#define LV_USE_VALUE_STR    1
+#endif
+
 /* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
 #ifndef LV_USE_BLEND_MODES
 #define LV_USE_BLEND_MODES      1
@@ -266,6 +287,11 @@
 #ifndef LV_USE_GPU_STM32_DMA2D
 #define LV_USE_GPU_STM32_DMA2D  0
 #endif
+/*If enabling LV_USE_GPU_STM32_DMA2D, LV_GPU_DMA2D_CMSIS_INCLUDE must be defined to include path of CMSIS header of target processor
+e.g. "stm32f769xx.h" or "stm32f429xx.h" */
+#ifndef LV_GPU_DMA2D_CMSIS_INCLUDE
+#define LV_GPU_DMA2D_CMSIS_INCLUDE
+#endif
 
 /* 1: Enable file system (might be required for images */
 #ifndef LV_USE_FILESYSTEM
@@ -289,6 +315,9 @@
 #ifndef LV_USE_API_EXTENSION_V6
 #define LV_USE_API_EXTENSION_V6  1
 #endif
+#ifndef LV_USE_API_EXTENSION_V7
+#define LV_USE_API_EXTENSION_V7  1
+#endif
 
 /*========================
  * Image decoder and cache
@@ -319,6 +348,12 @@
 /*=====================
  *  Compiler settings
  *====================*/
+
+/* For big endian systems set to 1 */
+#ifndef LV_BIG_ENDIAN_SYSTEM
+#define LV_BIG_ENDIAN_SYSTEM    0
+#endif
+
 /* Define a custom attribute to `lv_tick_inc` function */
 #ifndef LV_ATTRIBUTE_TICK_INC
 #define LV_ATTRIBUTE_TICK_INC
@@ -363,6 +398,12 @@
 #define LV_EXPORT_CONST_INT(int_value) struct _silence_gcc_warning
 #endif
 
+/* Prefix variables that are used in GPU accelerated operations, often these need to be
+ * placed in RAM sections that are DMA accessible */
+#ifndef LV_ATTRIBUTE_DMA
+#define LV_ATTRIBUTE_DMA
+#endif
+
 /*===================
  *  HAL settings
  *==================*/
@@ -374,10 +415,10 @@
 #endif
 #if LV_TICK_CUSTOM == 1
 #ifndef LV_TICK_CUSTOM_INCLUDE
-#define LV_TICK_CUSTOM_INCLUDE  "something.h"       /*Header for the sys time function*/
+#define LV_TICK_CUSTOM_INCLUDE  "Arduino.h"         /*Header for the system time function*/
 #endif
 #ifndef LV_TICK_CUSTOM_SYS_TIME_EXPR
-#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current systime in ms*/
+#define LV_TICK_CUSTOM_SYS_TIME_EXPR (millis())     /*Expression evaluating to current system time in ms*/
 #endif
 #endif   /*LV_TICK_CUSTOM*/
 
@@ -468,7 +509,7 @@
 
 /* The built-in fonts contains the ASCII range and some Symbols with  4 bit-per-pixel.
  * The symbols are available via `LV_SYMBOL_...` defines
- * More info about fonts: https://docs.lvgl.com/#Fonts
+ * More info about fonts: https://docs.lvgl.io/v7/en/html/overview/font.html
  * To create a new font go to: https://lvgl.com/ttf-font-to-c-array
  */
 
@@ -478,10 +519,10 @@
 #define LV_FONT_MONTSERRAT_12    0
 #endif
 #ifndef LV_FONT_MONTSERRAT_14
-#define LV_FONT_MONTSERRAT_14    0
+#define LV_FONT_MONTSERRAT_14    1
 #endif
 #ifndef LV_FONT_MONTSERRAT_16
-#define LV_FONT_MONTSERRAT_16    1
+#define LV_FONT_MONTSERRAT_16    0
 #endif
 #ifndef LV_FONT_MONTSERRAT_18
 #define LV_FONT_MONTSERRAT_18    0
@@ -569,6 +610,18 @@
 #define LV_FONT_FMT_TXT_LARGE   0
 #endif
 
+/* Enables/disables support for compressed fonts. If it's disabled, compressed
+ * glyphs cannot be processed by the library and won't be rendered.
+ */
+#ifndef LV_USE_FONT_COMPRESSED
+#define LV_USE_FONT_COMPRESSED 1
+#endif
+
+/* Enable subpixel rendering */
+#ifndef LV_USE_FONT_SUBPX
+#define LV_USE_FONT_SUBPX 1
+#endif
+#if LV_USE_FONT_SUBPX
 /* Set the pixel order of the display.
  * Important only if "subpx fonts" are used.
  * With "normal" font it doesn't matter.
@@ -576,6 +629,7 @@
 #ifndef LV_FONT_SUBPX_BGR
 #define LV_FONT_SUBPX_BGR    0
 #endif
+#endif
 
 /*Declare the type of the user data of fonts (can be e.g. `void *`, `int`, `struct`)*/
 
@@ -600,7 +654,10 @@
 /* A fast and impressive theme.
  * Flags:
  * LV_THEME_MATERIAL_FLAG_LIGHT: light theme
- * LV_THEME_MATERIAL_FLAG_DARK: dark theme*/
+ * LV_THEME_MATERIAL_FLAG_DARK: dark theme
+ * LV_THEME_MATERIAL_FLAG_NO_TRANSITION: disable transitions (state change animations)
+ * LV_THEME_MATERIAL_FLAG_NO_FOCUS: disable indication of focused state)
+ * */
 #ifndef LV_USE_THEME_MATERIAL
  #define LV_USE_THEME_MATERIAL    1
 #endif
@@ -621,25 +678,25 @@
 #define LV_THEME_DEFAULT_INIT               lv_theme_material_init
 #endif
 #ifndef LV_THEME_DEFAULT_COLOR_PRIMARY
-#define LV_THEME_DEFAULT_COLOR_PRIMARY      LV_COLOR_RED
+#define LV_THEME_DEFAULT_COLOR_PRIMARY      lv_color_hex(0x01a2b1)
 #endif
 #ifndef LV_THEME_DEFAULT_COLOR_SECONDARY
-#define LV_THEME_DEFAULT_COLOR_SECONDARY    LV_COLOR_BLUE
+#define LV_THEME_DEFAULT_COLOR_SECONDARY    lv_color_hex(0x44d1b6)
 #endif
 #ifndef LV_THEME_DEFAULT_FLAG
 #define LV_THEME_DEFAULT_FLAG               LV_THEME_MATERIAL_FLAG_LIGHT
 #endif
 #ifndef LV_THEME_DEFAULT_FONT_SMALL
-#define LV_THEME_DEFAULT_FONT_SMALL         &lv_font_montserrat_16
+#define LV_THEME_DEFAULT_FONT_SMALL         &lv_font_montserrat_14
 #endif
 #ifndef LV_THEME_DEFAULT_FONT_NORMAL
-#define LV_THEME_DEFAULT_FONT_NORMAL        &lv_font_montserrat_16
+#define LV_THEME_DEFAULT_FONT_NORMAL        &lv_font_montserrat_14
 #endif
 #ifndef LV_THEME_DEFAULT_FONT_SUBTITLE
-#define LV_THEME_DEFAULT_FONT_SUBTITLE      &lv_font_montserrat_16
+#define LV_THEME_DEFAULT_FONT_SUBTITLE      &lv_font_montserrat_14
 #endif
 #ifndef LV_THEME_DEFAULT_FONT_TITLE
-#define LV_THEME_DEFAULT_FONT_TITLE         &lv_font_montserrat_16
+#define LV_THEME_DEFAULT_FONT_TITLE         &lv_font_montserrat_14
 #endif
 
 /*=================
@@ -678,14 +735,14 @@
 #define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3
 #endif
 
-/* The control character to use for signaling text recoloring. */
+/* The control character to use for signalling text recoloring. */
 #ifndef LV_TXT_COLOR_CMD
 #define LV_TXT_COLOR_CMD "#"
 #endif
 
 /* Support bidirectional texts.
  * Allows mixing Left-to-Right and Right-to-Left texts.
- * The direction will be processed according to the Unicode Bidirectional Algorithm:
+ * The direction will be processed according to the Unicode Bidirectioanl Algorithm:
  * https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/
 #ifndef LV_USE_BIDI
 #define LV_USE_BIDI     0
@@ -793,6 +850,11 @@
 #ifndef LV_USE_CALENDAR
 #define LV_USE_CALENDAR 1
 #endif
+#if LV_USE_CALENDAR
+#ifndef LV_CALENDAR_WEEK_STARTS_MONDAY
+#  define LV_CALENDAR_WEEK_STARTS_MONDAY    0
+#endif
+#endif
 
 /*Canvas (dependencies: lv_img)*/
 #ifndef LV_USE_CANVAS

src/lv_core/lv_disp.c

@@ -8,6 +8,7 @@
  *********************/
 #include "lv_disp.h"
 #include "../lv_misc/lv_math.h"
+#include "../lv_core/lv_refr.h"
 
 /*********************
  *      DEFINES
@@ -21,6 +22,12 @@
  *  STATIC PROTOTYPES
  **********************/
 
+#if LV_USE_ANIMATION
+    static void scr_load_anim_start(lv_anim_t * a);
+    static void opa_scale_anim(lv_obj_t * obj, lv_anim_value_t v);
+    static void scr_anim_ready(lv_anim_t * a);
+#endif
+
 /**********************
  *  STATIC VARIABLES
  **********************/
@@ -43,13 +50,30 @@ lv_obj_t * lv_disp_get_scr_act(lv_disp_t * disp)
 {
     if(!disp) disp = lv_disp_get_default();
     if(!disp) {
-        LV_LOG_WARN("lv_scr_act: no display registered to get its act. screen");
+        LV_LOG_WARN("no display registered to get its active screen");
         return NULL;
     }
 
     return disp->act_scr;
 }
 
+/**
+ * Return with a pointer to the previous screen. Only used during screen transitions.
+ * @param disp pointer to display which previous screen should be get. (NULL to use the default
+ * screen)
+ * @return pointer to the previous screen object or NULL if not used now
+ */
+lv_obj_t * lv_disp_get_scr_prev(lv_disp_t * disp)
+{
+    if(!disp) disp = lv_disp_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered to get its previous screen");
+        return NULL;
+    }
+
+    return disp->prev_scr;
+}
+
 /**
  * Make a screen active
  * @param scr pointer to a screen
@@ -96,6 +120,7 @@ lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp)
     return disp->sys_layer;
 }
 
+
 /**
  * Assign a screen to a display.
  * @param disp pointer to a display where to assign the screen
@@ -115,6 +140,176 @@ void lv_disp_assign_screen(lv_disp_t * disp, lv_obj_t * scr)
     _lv_ll_chg_list(&old_disp->scr_ll, &disp->scr_ll, scr, true);
 }
 
+/**
+ * Set the background color of a display
+ * @param disp pointer to a display
+ * @param color color of the background
+ */
+void lv_disp_set_bg_color(lv_disp_t * disp, lv_color_t color)
+{
+    if(!disp) disp = lv_disp_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered");
+        return;
+    }
+
+    disp->bg_color = color;
+
+    lv_area_t a;
+    lv_area_set(&a, 0, 0, lv_disp_get_hor_res(disp) - 1, lv_disp_get_ver_res(disp) - 1);
+    _lv_inv_area(disp, &a);
+
+}
+
+/**
+ * Set the background image of a display
+ * @param disp pointer to a display
+ * @param img_src path to file or pointer to an `lv_img_dsc_t` variable
+ */
+void lv_disp_set_bg_image(lv_disp_t * disp, const void  * img_src)
+{
+    if(!disp) disp = lv_disp_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered");
+        return;
+    }
+
+    disp->bg_img = img_src;
+
+    lv_area_t a;
+    lv_area_set(&a, 0, 0, lv_disp_get_hor_res(disp) - 1, lv_disp_get_ver_res(disp) - 1);
+    _lv_inv_area(disp, &a);
+}
+
+
+/**
+ * Opacity of the background
+ * @param disp pointer to a display
+ * @param opa opacity (0..255)
+ */
+void lv_disp_set_bg_opa(lv_disp_t * disp, lv_opa_t opa)
+{
+    if(!disp) disp = lv_disp_get_default();
+    if(!disp) {
+        LV_LOG_WARN("no display registered");
+        return;
+    }
+
+    disp->bg_opa = opa;
+
+    lv_area_t a;
+    lv_area_set(&a, 0, 0, lv_disp_get_hor_res(disp) - 1, lv_disp_get_ver_res(disp) - 1);
+    _lv_inv_area(disp, &a);
+}
+
+#if LV_USE_ANIMATION
+
+/**
+ * Switch screen with animation
+ * @param scr pointer to the new screen to load
+ * @param anim_type type of the animation from `lv_scr_load_anim_t`. E.g.  `LV_SCR_LOAD_ANIM_MOVE_LEFT`
+ * @param time time of the animation
+ * @param delay delay before the transition
+ * @param auto_del true: automatically delete the old screen
+ */
+void lv_scr_load_anim(lv_obj_t * new_scr, lv_scr_load_anim_t anim_type, uint32_t time, uint32_t delay, bool auto_del)
+{
+    lv_disp_t * d = lv_obj_get_disp(new_scr);
+
+    if(d->prev_scr && d->del_prev) {
+        lv_obj_del(d->prev_scr);
+        d->prev_scr = NULL;
+    }
+
+    d->del_prev = auto_del;
+
+    /*Be sure there is no other animation on the screens*/
+    lv_anim_del(new_scr, NULL);
+    lv_anim_del(lv_scr_act(), NULL);
+
+    /*Be sure both screens are in a normal position*/
+    lv_obj_set_pos(new_scr, 0, 0);
+    lv_obj_set_pos(lv_scr_act(), 0, 0);
+    lv_style_remove_prop(lv_obj_get_local_style(new_scr, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
+    lv_style_remove_prop(lv_obj_get_local_style(lv_scr_act(), LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
+
+    lv_anim_t a_new;
+    lv_anim_init(&a_new);
+    lv_anim_set_var(&a_new, new_scr);
+    lv_anim_set_start_cb(&a_new, scr_load_anim_start);
+    lv_anim_set_ready_cb(&a_new, scr_anim_ready);
+    lv_anim_set_time(&a_new, time);
+    lv_anim_set_delay(&a_new, delay);
+
+    lv_anim_t a_old;
+    lv_anim_init(&a_old);
+    lv_anim_set_var(&a_old, d->act_scr);
+    lv_anim_set_time(&a_old, time);
+    lv_anim_set_delay(&a_old, delay);
+
+    switch(anim_type) {
+        case LV_SCR_LOAD_ANIM_NONE:
+            /* Create a dummy animation to apply the delay*/
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_x);
+            lv_anim_set_values(&a_new, 0, 0);
+            break;
+        case LV_SCR_LOAD_ANIM_OVER_LEFT:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_x);
+            lv_anim_set_values(&a_new, lv_disp_get_hor_res(d), 0);
+            break;
+        case LV_SCR_LOAD_ANIM_OVER_RIGHT:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_x);
+            lv_anim_set_values(&a_new, -lv_disp_get_hor_res(d), 0);
+            break;
+        case LV_SCR_LOAD_ANIM_OVER_TOP:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_y);
+            lv_anim_set_values(&a_new, lv_disp_get_ver_res(d), 0);
+            break;
+        case LV_SCR_LOAD_ANIM_OVER_BOTTOM:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_y);
+            lv_anim_set_values(&a_new, -lv_disp_get_ver_res(d), 0);
+            break;
+        case LV_SCR_LOAD_ANIM_MOVE_LEFT:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_x);
+            lv_anim_set_values(&a_new, lv_disp_get_hor_res(d), 0);
+
+            lv_anim_set_exec_cb(&a_old, (lv_anim_exec_xcb_t) lv_obj_set_x);
+            lv_anim_set_values(&a_old, 0, -lv_disp_get_hor_res(d));
+            break;
+        case LV_SCR_LOAD_ANIM_MOVE_RIGHT:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_x);
+            lv_anim_set_values(&a_new, -lv_disp_get_hor_res(d), 0);
+
+            lv_anim_set_exec_cb(&a_old, (lv_anim_exec_xcb_t) lv_obj_set_x);
+            lv_anim_set_values(&a_old, 0, lv_disp_get_hor_res(d));
+            break;
+        case LV_SCR_LOAD_ANIM_MOVE_TOP:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_y);
+            lv_anim_set_values(&a_new, lv_disp_get_ver_res(d), 0);
+
+            lv_anim_set_exec_cb(&a_old, (lv_anim_exec_xcb_t) lv_obj_set_y);
+            lv_anim_set_values(&a_old, 0, -lv_disp_get_ver_res(d));
+            break;
+        case LV_SCR_LOAD_ANIM_MOVE_BOTTOM:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) lv_obj_set_y);
+            lv_anim_set_values(&a_new, -lv_disp_get_ver_res(d), 0);
+
+            lv_anim_set_exec_cb(&a_old, (lv_anim_exec_xcb_t) lv_obj_set_y);
+            lv_anim_set_values(&a_old, 0, lv_disp_get_ver_res(d));
+            break;
+
+        case LV_SCR_LOAD_ANIM_FADE_ON:
+            lv_anim_set_exec_cb(&a_new, (lv_anim_exec_xcb_t) opa_scale_anim);
+            lv_anim_set_values(&a_new, LV_OPA_TRANSP, LV_OPA_COVER);
+            break;
+    }
+
+    lv_anim_start(&a_new);
+    lv_anim_start(&a_old);
+}
+
+#endif
+
 /**
  * Get elapsed time since last user activity on a display (e.g. click)
  * @param disp pointer to an display (NULL to get the overall smallest inactivity)
@@ -178,3 +373,28 @@ lv_task_t * _lv_disp_get_refr_task(lv_disp_t * disp)
 /**********************
  *   STATIC FUNCTIONS
  **********************/
+
+#if LV_USE_ANIMATION
+static void scr_load_anim_start(lv_anim_t * a)
+{
+    lv_disp_t * d = lv_obj_get_disp(a->var);
+    d->prev_scr = lv_scr_act();
+
+    lv_disp_load_scr(a->var);
+}
+
+static void opa_scale_anim(lv_obj_t * obj, lv_anim_value_t v)
+{
+    lv_obj_set_style_local_opa_scale(obj, LV_OBJ_PART_MAIN, LV_STATE_DEFAULT, v);
+}
+
+
+static void scr_anim_ready(lv_anim_t * a)
+{
+    lv_disp_t * d = lv_obj_get_disp(a->var);
+
+    if(d->prev_scr && d->del_prev) lv_obj_del(d->prev_scr);
+    d->prev_scr = NULL;
+    lv_style_remove_prop(lv_obj_get_local_style(a->var, LV_OBJ_PART_MAIN), LV_STYLE_OPA_SCALE);
+}
+#endif

src/lv_core/lv_disp.h

@@ -24,6 +24,19 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
+typedef enum {
+    LV_SCR_LOAD_ANIM_NONE,
+    LV_SCR_LOAD_ANIM_OVER_LEFT,
+    LV_SCR_LOAD_ANIM_OVER_RIGHT,
+    LV_SCR_LOAD_ANIM_OVER_TOP,
+    LV_SCR_LOAD_ANIM_OVER_BOTTOM,
+    LV_SCR_LOAD_ANIM_MOVE_LEFT,
+    LV_SCR_LOAD_ANIM_MOVE_RIGHT,
+    LV_SCR_LOAD_ANIM_MOVE_TOP,
+    LV_SCR_LOAD_ANIM_MOVE_BOTTOM,
+    LV_SCR_LOAD_ANIM_FADE_ON,
+} lv_scr_load_anim_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
@@ -36,6 +49,14 @@ extern "C" {
  */
 lv_obj_t * lv_disp_get_scr_act(lv_disp_t * disp);
 
+/**
+ * Return with a pointer to the previous screen. Only used during screen transitions.
+ * @param disp pointer to display which previous screen should be get. (NULL to use the default
+ * screen)
+ * @return pointer to the previous screen object or NULL if not used now
+ */
+lv_obj_t * lv_disp_get_scr_prev(lv_disp_t * disp);
+
 /**
  * Make a screen active
  * @param scr pointer to a screen
@@ -64,6 +85,41 @@ lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp);
  */
 void lv_disp_assign_screen(lv_disp_t * disp, lv_obj_t * scr);
 
+
+/**
+ * Set the background color of a display
+ * @param disp pointer to a display
+ * @param color color of the background
+ */
+void lv_disp_set_bg_color(lv_disp_t * disp, lv_color_t color);
+
+/**
+ * Set the background image of a display
+ * @param disp pointer to a display
+ * @param img_src path to file or pointer to an `lv_img_dsc_t` variable
+ */
+void lv_disp_set_bg_image(lv_disp_t * disp, const void  * img_src);
+
+/**
+ * Opacity of the background
+ * @param disp pointer to a display
+ * @param opa opacity (0..255)
+ */
+void lv_disp_set_bg_opa(lv_disp_t * disp, lv_opa_t opa);
+
+#if LV_USE_ANIMATION
+
+/**
+ * Switch screen with animation
+ * @param scr pointer to the new screen to load
+ * @param anim_type type of the animation from `lv_scr_load_anim_t`. E.g.  `LV_SCR_LOAD_ANIM_MOVE_LEFT`
+ * @param time time of the animation
+ * @param delay delay before the transition
+ * @param auto_del true: automatically delete the old screen
+ */
+void lv_scr_load_anim(lv_obj_t * scr, lv_scr_load_anim_t anim_type, uint32_t time, uint32_t delay, bool auto_del);
+
+#endif
 /**
  * Get elapsed time since last user activity on a display (e.g. click)
  * @param disp pointer to an display (NULL to get the overall smallest inactivity)
@@ -122,6 +178,7 @@ static inline void lv_scr_load(lv_obj_t * scr)
     lv_disp_load_scr(scr);
 }
 
+
 /**********************
  *      MACROS
  **********************/
@@ -154,6 +211,11 @@ static inline void lv_scr_load(lv_obj_t * scr)
  */
 #define LV_DPX(n)   LV_MATH_MAX((( lv_disp_get_dpi(NULL) * (n) + 80) / 160), 1) /*+80 for rounding*/
 
+static inline lv_coord_t lv_dpx(lv_coord_t n)
+{
+    return LV_DPX(n);
+}
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

src/lv_core/lv_indev.c

@@ -213,6 +213,7 @@ void lv_indev_set_cursor(lv_indev_t * indev, lv_obj_t * cur_obj)
     indev->cursor = cur_obj;
     lv_obj_set_parent(indev->cursor, lv_disp_get_layer_sys(indev->driver.disp));
     lv_obj_set_pos(indev->cursor, indev->proc.types.pointer.act_point.x, indev->proc.types.pointer.act_point.y);
+    lv_obj_set_click(indev->cursor, false);
 }
 
 #if LV_USE_GROUP
@@ -607,8 +608,163 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
     indev_obj_act = lv_group_get_focused(g);
     if(indev_obj_act == NULL) return;
 
-    /*Process the steps first. They are valid only with released button*/
-    if(data->state == LV_INDEV_STATE_REL) {
+    /*Process the steps they are valid only with released button*/
+    if(data->state != LV_INDEV_STATE_REL) {
+        data->enc_diff = 0;
+    }
+
+    /*Refresh the focused object. It might change due to lv_group_focus_prev/next*/
+    indev_obj_act = lv_group_get_focused(g);
+    if(indev_obj_act == NULL) return;
+
+    /*Button press happened*/
+    if(data->state == LV_INDEV_STATE_PR && last_state == LV_INDEV_STATE_REL) {
+
+        i->proc.pr_timestamp = lv_tick_get();
+
+        if(data->key == LV_KEY_ENTER) {
+            bool editable = false;
+            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_GET_EDITABLE, &editable);
+
+            if(lv_group_get_editing(g) == true || editable == false) {
+                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_PRESSED, NULL);
+                if(indev_reset_check(&i->proc)) return;
+
+                lv_event_send(indev_obj_act, LV_EVENT_PRESSED, NULL);
+                if(indev_reset_check(&i->proc)) return;
+            }
+        }
+        else if(data->key == LV_KEY_LEFT) {
+            /*emulate encoder left*/
+            data->enc_diff--;
+        }
+        else if(data->key == LV_KEY_RIGHT) {
+            /*emulate encoder right*/
+            data->enc_diff++;
+        }
+        else if(data->key == LV_KEY_ESC) {
+            /*Send the ESC as a normal KEY*/
+            lv_group_send_data(g, LV_KEY_ESC);
+
+            lv_event_send(indev_obj_act, LV_EVENT_CANCEL, NULL);
+            if(indev_reset_check(&i->proc)) return;
+        }
+        /*Just send other keys to the object (e.g. 'A' or `LV_GROUP_KEY_RIGHT`)*/
+        else {
+            lv_group_send_data(g, data->key);
+        }
+    }
+    /*Pressing*/
+    else if(data->state == LV_INDEV_STATE_PR && last_state == LV_INDEV_STATE_PR) {
+        /* Long press*/
+        if(i->proc.long_pr_sent == 0 && lv_tick_elaps(i->proc.pr_timestamp) > i->driver.long_press_time) {
+
+            i->proc.long_pr_sent = 1;
+            i->proc.longpr_rep_timestamp = lv_tick_get();
+
+            if(data->key == LV_KEY_ENTER) {
+                bool editable = false;
+                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_GET_EDITABLE, &editable);
+
+                /*On enter long press toggle edit mode.*/
+                if(editable) {
+                    /*Don't leave edit mode if there is only one object (nowhere to navigate)*/
+                    if(_lv_ll_is_empty(&g->obj_ll) == false) {
+                        lv_group_set_editing(g, lv_group_get_editing(g) ? false : true); /*Toggle edit mode on long press*/
+                    }
+                }
+                /*If not editable then just send a long press signal*/
+                else {
+                    indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_LONG_PRESS, NULL);
+                    if(indev_reset_check(&i->proc)) return;
+                    lv_event_send(indev_obj_act, LV_EVENT_LONG_PRESSED, NULL);
+                    if(indev_reset_check(&i->proc)) return;
+                }
+            }
+
+            i->proc.long_pr_sent = 1;
+        }
+        /*Long press repeated time has elapsed?*/
+        else if(i->proc.long_pr_sent != 0 && lv_tick_elaps(i->proc.longpr_rep_timestamp) > i->driver.long_press_rep_time) {
+
+            i->proc.longpr_rep_timestamp = lv_tick_get();
+
+            if(data->key == LV_KEY_ENTER) {
+                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_LONG_PRESS_REP, NULL);
+                if(indev_reset_check(&i->proc)) return;
+                lv_event_send(indev_obj_act, LV_EVENT_LONG_PRESSED_REPEAT, NULL);
+                if(indev_reset_check(&i->proc)) return;
+            }
+            else if(data->key == LV_KEY_LEFT) {
+                /*emulate encoder left*/
+                data->enc_diff--;
+            }
+            else if(data->key == LV_KEY_RIGHT) {
+                /*emulate encoder right*/
+                data->enc_diff++;
+            }
+            else {
+                lv_group_send_data(g, data->key);
+                if(indev_reset_check(&i->proc)) return;
+            }
+
+        }
+
+    }
+    /*Release happened*/
+    else if(data->state == LV_INDEV_STATE_REL && last_state == LV_INDEV_STATE_PR) {
+
+        if(data->key == LV_KEY_ENTER) {
+            bool editable = false;
+            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_GET_EDITABLE, &editable);
+
+            /*The button was released on a non-editable object. Just send enter*/
+            if(editable == false) {
+                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_RELEASED, NULL);
+                if(indev_reset_check(&i->proc)) return;
+
+                if(i->proc.long_pr_sent == 0) lv_event_send(indev_obj_act, LV_EVENT_SHORT_CLICKED, NULL);
+                if(indev_reset_check(&i->proc)) return;
+
+                lv_event_send(indev_obj_act, LV_EVENT_CLICKED, NULL);
+                if(indev_reset_check(&i->proc)) return;
+
+                lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
+                if(indev_reset_check(&i->proc)) return;
+            }
+            /*An object is being edited and the button is released. */
+            else if(g->editing) {
+                /*Ignore long pressed enter release because it comes from mode switch*/
+                if(!i->proc.long_pr_sent || _lv_ll_is_empty(&g->obj_ll)) {
+                    indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_RELEASED, NULL);
+                    if(indev_reset_check(&i->proc)) return;
+
+                    lv_event_send(indev_obj_act, LV_EVENT_SHORT_CLICKED, NULL);
+                    if(indev_reset_check(&i->proc)) return;
+
+                    lv_event_send(indev_obj_act, LV_EVENT_CLICKED, NULL);
+                    if(indev_reset_check(&i->proc)) return;
+
+                    lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
+                    if(indev_reset_check(&i->proc)) return;
+
+                    lv_group_send_data(g, LV_KEY_ENTER);
+                }
+            }
+            /*If the focused object is editable and now in navigate mode then on enter switch edit
+               mode*/
+            else if(editable && !g->editing && !i->proc.long_pr_sent) {
+                lv_group_set_editing(g, true); /*Set edit mode*/
+            }
+        }
+
+        i->proc.pr_timestamp = 0;
+        i->proc.long_pr_sent = 0;
+    }
+    indev_obj_act = NULL;
+
+    /*if encoder steps or simulated steps via left/right keys*/
+    if(data->enc_diff != 0) {
         /*In edit mode send LEFT/RIGHT keys*/
         if(lv_group_get_editing(g)) {
             int32_t s;
@@ -631,96 +787,6 @@ static void indev_encoder_proc(lv_indev_t * i, lv_indev_data_t * data)
         }
     }
 
-    /*Refresh the focused object. It might change due to lv_group_focus_prev/next*/
-    indev_obj_act = lv_group_get_focused(g);
-    if(indev_obj_act == NULL) return;
-
-    /*Button press happened*/
-    if(data->state == LV_INDEV_STATE_PR && last_state == LV_INDEV_STATE_REL) {
-        bool editable = false;
-        indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_GET_EDITABLE, &editable);
-
-        i->proc.pr_timestamp = lv_tick_get();
-        if(lv_group_get_editing(g) == true || editable == false) {
-            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_PRESSED, NULL);
-            if(indev_reset_check(&i->proc)) return;
-
-            lv_event_send(indev_obj_act, LV_EVENT_PRESSED, NULL);
-            if(indev_reset_check(&i->proc)) return;
-        }
-    }
-    /*Pressing*/
-    else if(data->state == LV_INDEV_STATE_PR && last_state == LV_INDEV_STATE_PR) {
-        if(i->proc.long_pr_sent == 0 && lv_tick_elaps(i->proc.pr_timestamp) > i->driver.long_press_time) {
-            bool editable = false;
-            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_GET_EDITABLE, &editable);
-
-            /*On enter long press toggle edit mode.*/
-            if(editable) {
-                /*Don't leave edit mode if there is only one object (nowhere to navigate)*/
-                if(_lv_ll_is_empty(&g->obj_ll) == false) {
-                    lv_group_set_editing(g, lv_group_get_editing(g) ? false : true); /*Toggle edit mode on long press*/
-                }
-            }
-            /*If not editable then just send a long press signal*/
-            else {
-                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_LONG_PRESS, NULL);
-                if(indev_reset_check(&i->proc)) return;
-                lv_event_send(indev_obj_act, LV_EVENT_LONG_PRESSED, NULL);
-                if(indev_reset_check(&i->proc)) return;
-            }
-            i->proc.long_pr_sent = 1;
-        }
-    }
-    /*Release happened*/
-    else if(data->state == LV_INDEV_STATE_REL && last_state == LV_INDEV_STATE_PR) {
-
-        bool editable = false;
-        indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_GET_EDITABLE, &editable);
-
-        /*The button was released on a non-editable object. Just send enter*/
-        if(editable == false) {
-            indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_RELEASED, NULL);
-            if(indev_reset_check(&i->proc)) return;
-
-            if(i->proc.long_pr_sent == 0) lv_event_send(indev_obj_act, LV_EVENT_SHORT_CLICKED, NULL);
-            if(indev_reset_check(&i->proc)) return;
-
-            lv_event_send(indev_obj_act, LV_EVENT_CLICKED, NULL);
-            if(indev_reset_check(&i->proc)) return;
-
-            lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
-            if(indev_reset_check(&i->proc)) return;
-        }
-        /*An object is being edited and the button is released. */
-        else if(g->editing) {
-            /*Ignore long pressed enter release because it comes from mode switch*/
-            if(!i->proc.long_pr_sent || _lv_ll_is_empty(&g->obj_ll)) {
-                indev_obj_act->signal_cb(indev_obj_act, LV_SIGNAL_RELEASED, NULL);
-                if(indev_reset_check(&i->proc)) return;
-
-                lv_event_send(indev_obj_act, LV_EVENT_SHORT_CLICKED, NULL);
-                if(indev_reset_check(&i->proc)) return;
-
-                lv_event_send(indev_obj_act, LV_EVENT_CLICKED, NULL);
-                if(indev_reset_check(&i->proc)) return;
-
-                lv_event_send(indev_obj_act, LV_EVENT_RELEASED, NULL);
-                if(indev_reset_check(&i->proc)) return;
-
-                lv_group_send_data(g, LV_KEY_ENTER);
-            }
-        }
-        /*If the focused object is editable and now in navigate mode then on enter switch edit
-           mode*/
-        else if(editable && !g->editing && !i->proc.long_pr_sent) {
-            lv_group_set_editing(g, true); /*Set edit mode*/
-        }
-
-        i->proc.pr_timestamp = 0;
-        i->proc.long_pr_sent = 0;
-    }
-    indev_obj_act = NULL;
 #else
     (void)data; /*Unused*/
     (void)i;    /*Unused*/
@@ -1092,8 +1158,9 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
 static void indev_click_focus(lv_indev_proc_t * proc)
 {
     /*Handle click focus*/
+    lv_obj_t * obj_to_focus = lv_obj_get_focused_obj(indev_obj_act);
     if(lv_obj_is_protected(indev_obj_act, LV_PROTECT_CLICK_FOCUS) == false &&
-       proc->types.pointer.last_pressed != indev_obj_act) {
+       proc->types.pointer.last_pressed != obj_to_focus) {
 #if LV_USE_GROUP
         lv_group_t * g_act = lv_obj_get_group(indev_obj_act);
         lv_group_t * g_prev = proc->types.pointer.last_pressed ? lv_obj_get_group(proc->types.pointer.last_pressed) : NULL;
@@ -1122,11 +1189,6 @@ static void indev_click_focus(lv_indev_proc_t * proc)
         }
         /*The object are not in the same group (in different group or one in not a group)*/
         else {
-            /*Focus to the act. its group*/
-            if(g_act) {
-                lv_group_focus_obj(indev_obj_act);
-                if(indev_reset_check(proc)) return;
-            }
             /*If the prev. obj. is not in a group then defocus it.*/
             if(g_prev == NULL && proc->types.pointer.last_pressed) {
                 lv_signal_send(proc->types.pointer.last_pressed, LV_SIGNAL_DEFOCUS, NULL);
@@ -1152,7 +1214,14 @@ static void indev_click_focus(lv_indev_proc_t * proc)
                         if(indev_reset_check(proc)) return;
                     }
                 }
+            }
 
+            /*Focus to the act. in its group*/
+            if(g_act) {
+                lv_group_focus_obj(indev_obj_act);
+                if(indev_reset_check(proc)) return;
+            }
+            else {
                 lv_signal_send(indev_obj_act, LV_SIGNAL_FOCUS, NULL);
                 if(indev_reset_check(proc)) return;
                 lv_event_send(indev_obj_act, LV_EVENT_FOCUSED, NULL);
@@ -1172,7 +1241,7 @@ static void indev_click_focus(lv_indev_proc_t * proc)
         lv_event_send(indev_obj_act, LV_EVENT_FOCUSED, NULL);
         if(indev_reset_check(proc)) return;
 #endif
-        proc->types.pointer.last_pressed = indev_obj_act;
+        proc->types.pointer.last_pressed = obj_to_focus;
     }
 
 }

src/lv_core/lv_obj.c

@@ -38,6 +38,10 @@
 
 #include LV_THEME_DEFAULT_INCLUDE
 
+#if LV_USE_GPU_STM32_DMA2D
+    #include "../lv_gpu/lv_gpu_stm32_dma2d.h"
+#endif
+
 /*********************
  *      DEFINES
  *********************/
@@ -81,6 +85,10 @@ static void refresh_children_position(lv_obj_t * obj, lv_coord_t x_diff, lv_coor
 static void report_style_mod_core(void * style_p, lv_obj_t * obj);
 static void refresh_children_style(lv_obj_t * obj);
 static void base_dir_refr_children(lv_obj_t * obj);
+static void obj_align_core(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, bool x_set, bool y_set,
+                           lv_coord_t x_ofs, lv_coord_t y_ofs);
+static void obj_align_origo_core(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align,  bool x_set, bool y_set,
+                                 lv_coord_t x_ofs, lv_coord_t y_ofs);
 #if LV_USE_ANIMATION
 static lv_style_trans_t * trans_create(lv_obj_t * obj, lv_style_property_t prop, uint8_t part, lv_state_t prev_state,
                                        lv_state_t new_state);
@@ -140,8 +148,13 @@ void lv_init(void)
     _lv_group_init();
 #endif
 
+#if LV_USE_GPU_STM32_DMA2D
+    /*Initialize DMA2D GPU*/
+    lv_gpu_stm32_dma2d_init();
+#endif
+
     _lv_ll_init(&LV_GC_ROOT(_lv_obj_style_trans_ll), sizeof(lv_style_trans_t));
-    
+
     _lv_ll_init(&LV_GC_ROOT(_lv_disp_ll), sizeof(lv_disp_t));
     _lv_ll_init(&LV_GC_ROOT(_lv_indev_ll), sizeof(lv_indev_t));
 
@@ -159,6 +172,14 @@ void lv_init(void)
     _lv_img_decoder_init();
     lv_img_cache_set_size(LV_IMG_CACHE_DEF_SIZE);
 
+    /*Test if the IDE has UTF-8 encoding*/
+    char * txt = "Á";
+
+    uint8_t * txt_u8 = (uint8_t *) txt;
+    if(txt_u8[0] != 0xc3 || txt_u8[1] != 0x81 || txt_u8[2] != 0x00) {
+        LV_LOG_WARN("The strings has no UTF-8 encoding. Some characters won't be displayed.")
+    }
+
     lv_initialized = true;
     LV_LOG_INFO("lv_init ready");
 }
@@ -172,13 +193,13 @@ void lv_init(void)
 void lv_deinit(void)
 {
     _lv_gc_clear_roots();
-	
+
     lv_disp_set_default(NULL);
     _lv_mem_deinit();
     lv_initialized = false;
-	
+
     LV_LOG_INFO("lv_deinit done");
-	
+
 #if LV_USE_LOG
     lv_log_register_print_cb(NULL);
 #endif
@@ -298,6 +319,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
 
 #if LV_USE_GROUP
     new_obj->group_p = NULL;
+
 #endif
 
     /*Set attributes*/
@@ -312,6 +334,7 @@ lv_obj_t * lv_obj_create(lv_obj_t * parent, const lv_obj_t * copy)
     new_obj->protect      = LV_PROTECT_NONE;
     new_obj->parent_event = 0;
     new_obj->gesture_parent = parent ? 1 : 0;
+    new_obj->focus_parent  = 0;
     new_obj->state = LV_STATE_DEFAULT;
 
     new_obj->ext_attr = NULL;
@@ -482,10 +505,12 @@ void lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area)
 
     if(lv_obj_get_hidden(obj)) return;
 
-    /*Invalidate the object only if it belongs to the 'LV_GC_ROOT(_lv_act_scr)'*/
+    /*Invalidate the object only if it belongs to the curent or previous'*/
     lv_obj_t * obj_scr = lv_obj_get_screen(obj);
     lv_disp_t * disp   = lv_obj_get_disp(obj_scr);
-    if(obj_scr == lv_disp_get_scr_act(disp) || obj_scr == lv_disp_get_layer_top(disp) ||
+    if(obj_scr == lv_disp_get_scr_act(disp) ||
+       obj_scr == lv_disp_get_scr_prev(disp) ||
+       obj_scr == lv_disp_get_layer_top(disp) ||
        obj_scr == lv_disp_get_layer_sys(disp)) {
 
         /*Truncate the area to the object*/
@@ -665,13 +690,11 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     /*Convert x and y to absolute coordinates*/
     lv_obj_t * par = obj->parent;
 
-    if(par == NULL) {
-        LV_LOG_WARN("lv_obj_set_pos: not changing position of screen object");
-        return;
+    if(par) {
+        x = x + par->coords.x1;
+        y = y + par->coords.y1;
     }
 
-    x = x + par->coords.x1;
-    y = y + par->coords.y1;
 
     /*Calculate and set the movement*/
     lv_point_t diff;
@@ -701,7 +724,7 @@ void lv_obj_set_pos(lv_obj_t * obj, lv_coord_t x, lv_coord_t y)
     obj->signal_cb(obj, LV_SIGNAL_COORD_CHG, &ori);
 
     /*Send a signal to the parent too*/
-    par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
+    if(par) par->signal_cb(par, LV_SIGNAL_CHILD_CHG, obj);
 
     /*Invalidate the new area*/
     lv_obj_invalidate(obj);
@@ -864,7 +887,6 @@ void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h)
     lv_obj_set_height(obj, h - mtop - mbottom);
 }
 
-
 /**
  * Align an object to an other object.
  * @param obj pointer to an object to align
@@ -881,19 +903,7 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
 
     LV_ASSERT_OBJ(base, LV_OBJX_NAME);
 
-    lv_point_t new_pos;
-    _lv_area_align(&base->coords, &obj->coords, align, &new_pos);
-
-    /*Bring together the coordination system of base and obj*/
-    lv_obj_t * par        = lv_obj_get_parent(obj);
-    lv_coord_t par_abs_x  = par->coords.x1;
-    lv_coord_t par_abs_y  = par->coords.y1;
-    new_pos.x += x_ofs;
-    new_pos.y += y_ofs;
-    new_pos.x -= par_abs_x;
-    new_pos.y -= par_abs_y;
-
-    lv_obj_set_pos(obj, new_pos.x, new_pos.y);
+    obj_align_core(obj, base, align, true, true, x_ofs, y_ofs);
 
 #if LV_USE_OBJ_REALIGN
     /*Save the last align parameters to use them in `lv_obj_realign`*/
@@ -905,6 +915,42 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
 #endif
 }
 
+/**
+ * Align an object to an other object horizontally.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param x_ofs x coordinate offset after alignment
+ */
+void lv_obj_align_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    if(base == NULL) base = lv_obj_get_parent(obj);
+
+    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
+
+    obj_align_core(obj, base, align, true, false, x_ofs, 0);
+}
+
+/**
+ * Align an object to an other object vertically.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param y_ofs y coordinate offset after alignment
+ */
+void lv_obj_align_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    if(base == NULL) base = lv_obj_get_parent(obj);
+
+    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
+
+    obj_align_core(obj, base, align, true, false, 0, y_ofs);
+}
+
 /**
  * Align an object's middle point to an other object.
  * @param obj pointer to an object to align
@@ -917,12 +963,6 @@ void lv_obj_align_origo(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align,
 {
     LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
 
-    lv_coord_t new_x = lv_obj_get_x(obj);
-    lv_coord_t new_y = lv_obj_get_y(obj);
-
-    lv_coord_t obj_w_half = lv_obj_get_width(obj) / 2;
-    lv_coord_t obj_h_half = lv_obj_get_height(obj) / 2;
-
     if(base == NULL) {
         base = lv_obj_get_parent(obj);
     }
@@ -930,123 +970,7 @@ void lv_obj_align_origo(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align,
     LV_ASSERT_OBJ(base, LV_OBJX_NAME);
 
 
-    switch(align) {
-        case LV_ALIGN_CENTER:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_TOP_LEFT:
-            new_x = -obj_w_half;
-            new_y = -obj_h_half;
-            break;
-        case LV_ALIGN_IN_TOP_MID:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_TOP_RIGHT:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_BOTTOM_LEFT:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-        case LV_ALIGN_IN_BOTTOM_MID:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_BOTTOM_RIGHT:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_LEFT_MID:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_IN_RIGHT_MID:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_TOP_LEFT:
-            new_x = -obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_TOP_MID:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_TOP_RIGHT:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_BOTTOM_LEFT:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_BOTTOM_MID:
-            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_BOTTOM_RIGHT:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_LEFT_TOP:
-            new_x = -obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_LEFT_MID:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_LEFT_BOTTOM:
-            new_x = -obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_RIGHT_TOP:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = -obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_RIGHT_MID:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
-            break;
-
-        case LV_ALIGN_OUT_RIGHT_BOTTOM:
-            new_x = lv_obj_get_width(base) - obj_w_half;
-            new_y = lv_obj_get_height(base) - obj_h_half;
-            break;
-    }
-
-    /*Bring together the coordination system of base and obj*/
-    lv_obj_t * par        = lv_obj_get_parent(obj);
-    lv_coord_t base_abs_x = base->coords.x1;
-    lv_coord_t base_abs_y = base->coords.y1;
-    lv_coord_t par_abs_x  = par->coords.x1;
-    lv_coord_t par_abs_y  = par->coords.y1;
-    new_x += x_ofs + base_abs_x;
-    new_y += y_ofs + base_abs_y;
-    new_x -= par_abs_x;
-    new_y -= par_abs_y;
-
-    lv_obj_set_pos(obj, new_x, new_y);
+    obj_align_origo_core(obj, base, align, true, true, x_ofs, y_ofs);
 
 #if LV_USE_OBJ_REALIGN
     /*Save the last align parameters to use them in `lv_obj_realign`*/
@@ -1058,6 +982,49 @@ void lv_obj_align_origo(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align,
 #endif
 }
 
+/**
+ * Align an object's middle point to an other object horizontally.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param x_ofs x coordinate offset after alignment
+ */
+void lv_obj_align_origo_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    if(base == NULL) {
+        base = lv_obj_get_parent(obj);
+    }
+
+    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
+
+
+    obj_align_origo_core(obj, base, align, true, false, x_ofs, 0);
+}
+
+
+/**
+ * Align an object's middle point to an other object vertically.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param y_ofs y coordinate offset after alignment
+ */
+void lv_obj_align_origo_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs)
+{
+    LV_ASSERT_OBJ(obj, LV_OBJX_NAME);
+
+    if(base == NULL) {
+        base = lv_obj_get_parent(obj);
+    }
+
+    LV_ASSERT_OBJ(base, LV_OBJX_NAME);
+
+
+    obj_align_origo_core(obj, base, align, true, false, 0, y_ofs);
+}
+
 /**
  * Realign the object based on the last `lv_obj_align` parameters.
  * @param obj pointer to an object
@@ -1543,6 +1510,31 @@ void lv_obj_set_gesture_parent(lv_obj_t * obj, bool en)
     obj->gesture_parent = (en == true ? 1 : 0);
 }
 
+/**
+* Enable to use parent for focus state.
+* When object is focused the parent will get the state instead (visual only)
+* @param obj pointer to an object
+* @param en true: enable the 'focus parent' for the object
+*/
+void lv_obj_set_focus_parent(lv_obj_t * obj, bool en)
+{
+    if(lv_obj_is_focused(obj)) {
+        if(en) {
+            obj->focus_parent = 1;
+            lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
+            lv_obj_set_state(lv_obj_get_focused_obj(obj), LV_STATE_FOCUSED);
+        }
+        else {
+            lv_obj_clear_state(lv_obj_get_focused_obj(obj), LV_STATE_FOCUSED | LV_STATE_EDITED);
+            lv_obj_set_state(obj, LV_STATE_FOCUSED);
+            obj->focus_parent = 0;
+        }
+    }
+    else {
+        obj->focus_parent = (en == true ? 1 : 0);
+    }
+}
+
 /**
  * Propagate the events to the parent too
  * @param obj pointer to an object
@@ -1761,6 +1753,52 @@ lv_res_t lv_event_send(lv_obj_t * obj, lv_event_t event, const void * data)
     return res;
 }
 
+/**
+ * Send LV_EVENT_REFRESH event to an object
+ * @param obj point to an obejct. (Can NOT be NULL)
+ * @return LV_RES_OK: success, LV_RES_INV: to object become invalid (e.g. deleted) due to this event.
+ */
+lv_res_t lv_event_send_refresh(lv_obj_t * obj)
+{
+    return lv_event_send(obj, LV_EVENT_REFRESH, NULL);
+}
+
+/**
+ * Send LV_EVENT_REFRESH event to an object and all of its children.
+ * @param obj pointer to an object or NULL to refresh all objects of all displays
+ */
+void lv_event_send_refresh_recursive(lv_obj_t * obj)
+{
+    if(obj == NULL) {
+        /*If no obj specified refresh all screen of all displays */
+        lv_disp_t * d = lv_disp_get_next(NULL);
+        while(d) {
+            lv_obj_t * scr = _lv_ll_get_head(&d->scr_ll);
+            while(scr) {
+                lv_event_send_refresh_recursive(scr);
+                scr = _lv_ll_get_next(&d->scr_ll, scr);
+            }
+            lv_event_send_refresh_recursive(d->top_layer);
+            lv_event_send_refresh_recursive(d->sys_layer);
+
+            d = lv_disp_get_next(d);
+        }
+    }
+    else {
+
+        lv_res_t res = lv_event_send_refresh(obj);
+        if(res != LV_RES_OK) return; /*If invalid returned do not check the children*/
+
+        lv_obj_t * child = lv_obj_get_child(obj, NULL);
+        while(child) {
+            lv_event_send_refresh_recursive(child);
+
+            child = lv_obj_get_child(obj, child);
+        }
+    }
+}
+
+
 /**
  * Call an event function with an object, event, and data.
  * @param event_xcb an event callback function. If `NULL` `LV_RES_OK` will return without any actions.
@@ -2405,7 +2443,7 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
     lv_style_property_t prop_ori = prop;
 
     lv_style_attr_t attr;
-    attr.full = prop_ori >> 8;
+    attr = prop_ori >> 8;
 
     lv_style_int_t value_act;
     lv_res_t res = LV_RES_INV;
@@ -2419,7 +2457,7 @@ lv_style_int_t _lv_obj_get_style_int(const lv_obj_t * obj, uint8_t part, lv_styl
         res = _lv_style_list_get_int(dsc, prop, &value_act);
         if(res == LV_RES_OK) return value_act;
 
-        if(attr.bits.inherit == 0) break;
+        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
 
         /*If not found, check the `MAIN` style first*/
         if(part != LV_OBJ_PART_MAIN) {
@@ -2468,7 +2506,7 @@ lv_color_t _lv_obj_get_style_color(const lv_obj_t * obj, uint8_t part, lv_style_
     lv_style_property_t prop_ori = prop;
 
     lv_style_attr_t attr;
-    attr.full = prop_ori >> 8;
+    attr = prop_ori >> 8;
 
     lv_color_t value_act;
     lv_res_t res = LV_RES_INV;
@@ -2482,7 +2520,7 @@ lv_color_t _lv_obj_get_style_color(const lv_obj_t * obj, uint8_t part, lv_style_
         res = _lv_style_list_get_color(dsc, prop, &value_act);
         if(res == LV_RES_OK) return value_act;
 
-        if(attr.bits.inherit == 0) break;
+        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
 
         /*If not found, check the `MAIN` style first*/
         if(part != LV_OBJ_PART_MAIN) {
@@ -2524,7 +2562,7 @@ lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_prop
     lv_style_property_t prop_ori = prop;
 
     lv_style_attr_t attr;
-    attr.full = prop_ori >> 8;
+    attr = prop_ori >> 8;
 
     lv_opa_t value_act;
     lv_res_t res = LV_RES_INV;
@@ -2538,7 +2576,7 @@ lv_opa_t _lv_obj_get_style_opa(const lv_obj_t * obj, uint8_t part, lv_style_prop
         res = _lv_style_list_get_opa(dsc, prop, &value_act);
         if(res == LV_RES_OK) return value_act;
 
-        if(attr.bits.inherit == 0) break;
+        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
 
         /*If not found, check the `MAIN` style first*/
         if(part != LV_OBJ_PART_MAIN) {
@@ -2581,7 +2619,7 @@ const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_
     lv_style_property_t prop_ori = prop;
 
     lv_style_attr_t attr;
-    attr.full = prop_ori >> 8;
+    attr = prop_ori >> 8;
 
     const void * value_act;
     lv_res_t res = LV_RES_INV;
@@ -2595,7 +2633,7 @@ const void * _lv_obj_get_style_ptr(const lv_obj_t * obj, uint8_t part, lv_style_
         res = _lv_style_list_get_ptr(dsc, prop, &value_act);
         if(res == LV_RES_OK)  return value_act;
 
-        if(attr.bits.inherit == 0) break;
+        if(LV_STYLE_ATTR_GET_INHERIT(attr) == 0) break;
 
         /*If not found, check the `MAIN` style first*/
         if(part != LV_OBJ_PART_MAIN) {
@@ -2744,6 +2782,16 @@ bool lv_obj_get_gesture_parent(const lv_obj_t * obj)
     return obj->gesture_parent == 0 ? false : true;
 }
 
+/**
+* Get the focus parent attribute of an object
+* @param obj pointer to an object
+* @return true: focus parent is enabled
+*/
+bool lv_obj_get_focus_parent(const lv_obj_t * obj)
+{
+    return obj->focus_parent == 0 ? false : true;
+}
+
 /**
  * Get the drag parent attribute of an object
  * @param obj pointer to an object
@@ -3110,7 +3158,7 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint8_t part, lv_draw_rect_dsc_t
         }
     }
 
-
+#if LV_USE_OUTLINE
     if(draw_dsc->outline_opa != LV_OPA_TRANSP) {
         draw_dsc->outline_width = lv_obj_get_style_outline_width(obj, part);
         if(draw_dsc->outline_width) {
@@ -3124,7 +3172,9 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint8_t part, lv_draw_rect_dsc_t
 #endif
         }
     }
+#endif
 
+#if LV_USE_PATTERN
     if(draw_dsc->pattern_opa != LV_OPA_TRANSP) {
         draw_dsc->pattern_image = lv_obj_get_style_pattern_image(obj, part);
         if(draw_dsc->pattern_image) {
@@ -3145,6 +3195,8 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint8_t part, lv_draw_rect_dsc_t
             }
         }
     }
+#endif
+
 #if LV_USE_SHADOW
     if(draw_dsc->shadow_opa > LV_OPA_MIN) {
         draw_dsc->shadow_width = lv_obj_get_style_shadow_width(obj, part);
@@ -3163,6 +3215,7 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint8_t part, lv_draw_rect_dsc_t
     }
 #endif
 
+#if LV_USE_VALUE_STR
     if(draw_dsc->value_opa > LV_OPA_MIN) {
         draw_dsc->value_str = lv_obj_get_style_value_str(obj, part);
         if(draw_dsc->value_str) {
@@ -3181,6 +3234,7 @@ void lv_obj_init_draw_rect_dsc(lv_obj_t * obj, uint8_t part, lv_draw_rect_dsc_t
             }
         }
     }
+#endif
 
 #if LV_USE_OPA_SCALE
     if(opa_scale < LV_OPA_MAX) {
@@ -3244,8 +3298,9 @@ void lv_obj_init_draw_img_dsc(lv_obj_t * obj, uint8_t part, lv_draw_img_dsc_t *
     draw_dsc->pivot.y = lv_area_get_height(&obj->coords) / 2;
 
     draw_dsc->recolor_opa = lv_obj_get_style_image_recolor_opa(obj, part);
-    draw_dsc->recolor = lv_obj_get_style_image_recolor(obj, part);
-
+    if(draw_dsc->recolor_opa > 0) {
+        draw_dsc->recolor = lv_obj_get_style_image_recolor(obj, part);
+    }
 #if LV_USE_BLEND_MODES
     draw_dsc->blend_mode = lv_obj_get_style_image_blend_mode(obj, part);
 #endif
@@ -3638,6 +3693,23 @@ static lv_design_res_t lv_obj_design(lv_obj_t * obj, const lv_area_t * clip_area
     return LV_DESIGN_RES_OK;
 }
 
+
+/**
+ * Get the really focused object by taking `focus_parent` into account.
+ * @param obj the start object
+ * @return the object to really focus
+ */
+lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj)
+{
+    if(obj == NULL) return NULL;
+    const lv_obj_t * focus_obj = obj;
+    while(lv_obj_get_focus_parent(focus_obj) != false && focus_obj != NULL) {
+        focus_obj = lv_obj_get_parent(focus_obj);
+    }
+
+    return (lv_obj_t *)focus_obj;
+}
+
 /**
  * Signal function of the basic object
  * @param obj pointer to an object
@@ -3681,22 +3753,36 @@ static lv_res_t lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param)
     else if(sign == LV_SIGNAL_RELEASED || sign == LV_SIGNAL_PRESS_LOST) {
         lv_obj_clear_state(obj, LV_STATE_PRESSED);
     }
-#if LV_USE_GROUP
     else if(sign == LV_SIGNAL_FOCUS) {
-        if(lv_group_get_editing(lv_obj_get_group(obj))) {
+        bool editing = false;
+#if LV_USE_GROUP
+        editing = lv_group_get_editing(lv_obj_get_group(obj));
+#endif
+        if(editing) {
             uint8_t state = LV_STATE_FOCUSED;
             state |= LV_STATE_EDITED;
+
+            /*if using focus mode, change target to parent*/
+            obj = lv_obj_get_focused_obj(obj);
+
             lv_obj_add_state(obj, state);
         }
         else {
+
+            /*if using focus mode, change target to parent*/
+            obj = lv_obj_get_focused_obj(obj);
+
             lv_obj_add_state(obj, LV_STATE_FOCUSED);
             lv_obj_clear_state(obj, LV_STATE_EDITED);
         }
     }
     else if(sign == LV_SIGNAL_DEFOCUS) {
+
+        /*if using focus mode, change target to parent*/
+        obj = lv_obj_get_focused_obj(obj);
+
         lv_obj_clear_state(obj, LV_STATE_FOCUSED | LV_STATE_EDITED);
     }
-#endif
     else if(sign == LV_SIGNAL_CLEANUP) {
         lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
     }
@@ -3786,6 +3872,159 @@ static void base_dir_refr_children(lv_obj_t * obj)
     }
 }
 
+static void obj_align_core(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, bool x_set, bool y_set,
+                           lv_coord_t x_ofs, lv_coord_t y_ofs)
+{
+    lv_point_t new_pos;
+    _lv_area_align(&base->coords, &obj->coords, align, &new_pos);
+
+    /*Bring together the coordination system of base and obj*/
+    lv_obj_t * par        = lv_obj_get_parent(obj);
+    lv_coord_t par_abs_x  = par->coords.x1;
+    lv_coord_t par_abs_y  = par->coords.y1;
+    new_pos.x += x_ofs;
+    new_pos.y += y_ofs;
+    new_pos.x -= par_abs_x;
+    new_pos.y -= par_abs_y;
+
+    if(x_set && y_set) lv_obj_set_pos(obj, new_pos.x, new_pos.y);
+    else if(x_set) lv_obj_set_x(obj, new_pos.x);
+    else if(y_set) lv_obj_set_y(obj, new_pos.y);
+}
+
+static void obj_align_origo_core(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align,  bool x_set, bool y_set,
+                                 lv_coord_t x_ofs, lv_coord_t y_ofs)
+{
+    lv_coord_t new_x = lv_obj_get_x(obj);
+    lv_coord_t new_y = lv_obj_get_y(obj);
+
+    lv_coord_t obj_w_half = lv_obj_get_width(obj) / 2;
+    lv_coord_t obj_h_half = lv_obj_get_height(obj) / 2;
+
+
+    switch(align) {
+        case LV_ALIGN_CENTER:
+            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
+            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
+            break;
+
+        case LV_ALIGN_IN_TOP_LEFT:
+            new_x = -obj_w_half;
+            new_y = -obj_h_half;
+            break;
+        case LV_ALIGN_IN_TOP_MID:
+            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
+            new_y = -obj_h_half;
+            break;
+
+        case LV_ALIGN_IN_TOP_RIGHT:
+            new_x = lv_obj_get_width(base) - obj_w_half;
+            new_y = -obj_h_half;
+            break;
+
+        case LV_ALIGN_IN_BOTTOM_LEFT:
+            new_x = -obj_w_half;
+            new_y = lv_obj_get_height(base) - obj_h_half;
+            break;
+        case LV_ALIGN_IN_BOTTOM_MID:
+            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
+            new_y = lv_obj_get_height(base) - obj_h_half;
+            break;
+
+        case LV_ALIGN_IN_BOTTOM_RIGHT:
+            new_x = lv_obj_get_width(base) - obj_w_half;
+            new_y = lv_obj_get_height(base) - obj_h_half;
+            break;
+
+        case LV_ALIGN_IN_LEFT_MID:
+            new_x = -obj_w_half;
+            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
+            break;
+
+        case LV_ALIGN_IN_RIGHT_MID:
+            new_x = lv_obj_get_width(base) - obj_w_half;
+            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_TOP_LEFT:
+            new_x = -obj_w_half;
+            new_y = -obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_TOP_MID:
+            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
+            new_y = -obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_TOP_RIGHT:
+            new_x = lv_obj_get_width(base) - obj_w_half;
+            new_y = -obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_BOTTOM_LEFT:
+            new_x = -obj_w_half;
+            new_y = lv_obj_get_height(base) - obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_BOTTOM_MID:
+            new_x = lv_obj_get_width(base) / 2 - obj_w_half;
+            new_y = lv_obj_get_height(base) - obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_BOTTOM_RIGHT:
+            new_x = lv_obj_get_width(base) - obj_w_half;
+            new_y = lv_obj_get_height(base) - obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_LEFT_TOP:
+            new_x = -obj_w_half;
+            new_y = -obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_LEFT_MID:
+            new_x = -obj_w_half;
+            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_LEFT_BOTTOM:
+            new_x = -obj_w_half;
+            new_y = lv_obj_get_height(base) - obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_RIGHT_TOP:
+            new_x = lv_obj_get_width(base) - obj_w_half;
+            new_y = -obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_RIGHT_MID:
+            new_x = lv_obj_get_width(base) - obj_w_half;
+            new_y = lv_obj_get_height(base) / 2 - obj_h_half;
+            break;
+
+        case LV_ALIGN_OUT_RIGHT_BOTTOM:
+            new_x = lv_obj_get_width(base) - obj_w_half;
+            new_y = lv_obj_get_height(base) - obj_h_half;
+            break;
+    }
+
+    /*Bring together the coordination system of base and obj*/
+    lv_obj_t * par        = lv_obj_get_parent(obj);
+    lv_coord_t base_abs_x = base->coords.x1;
+    lv_coord_t base_abs_y = base->coords.y1;
+    lv_coord_t par_abs_x  = par->coords.x1;
+    lv_coord_t par_abs_y  = par->coords.y1;
+    new_x += x_ofs + base_abs_x;
+    new_y += y_ofs + base_abs_y;
+    new_x -= par_abs_x;
+    new_y -= par_abs_y;
+    if(x_set && y_set) lv_obj_set_pos(obj, new_x, new_y);
+    else if(x_set) lv_obj_set_x(obj, new_x);
+    else if(y_set) lv_obj_set_y(obj, new_y);
+
+}
+
+
+
 #if LV_USE_ANIMATION
 
 /**
@@ -4062,5 +4301,3 @@ static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_fin
 
     return false;
 }
-
-

src/lv_core/lv_obj.h

@@ -47,6 +47,9 @@ extern "C" {
 #define LV_EXT_CLICK_AREA_TINY  1
 #define LV_EXT_CLICK_AREA_FULL  2
 
+#define _LV_OBJ_PART_VIRTUAL_FIRST 0x01
+#define _LV_OBJ_PART_REAL_FIRST    0x40
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -221,7 +224,8 @@ typedef struct _lv_obj_t {
     uint8_t top             : 1; /**< 1: If the object or its children is clicked it goes to the foreground*/
     uint8_t parent_event    : 1; /**< 1: Send the object's events to the parent too. */
     uint8_t adv_hittest     : 1; /**< 1: Use advanced hit-testing (slower) */
-    uint8_t gesture_parent : 1;  /**< 1: Parent will be gesture instead*/
+    uint8_t gesture_parent  : 1; /**< 1: Parent will be gesture instead*/
+    uint8_t focus_parent    : 1; /**< 1: Parent will be focused instead*/
 
     lv_drag_dir_t drag_dir  : 3; /**<  Which directions the object can be dragged in */
     lv_bidi_dir_t base_dir  : 2; /**< Base direction of texts related to this object */
@@ -246,8 +250,8 @@ typedef struct _lv_obj_t {
 
 enum {
     LV_OBJ_PART_MAIN,
-    _LV_OBJ_PART_VIRTUAL_LAST = 0x01,
-    _LV_OBJ_PART_REAL_LAST =    0x40,
+    _LV_OBJ_PART_VIRTUAL_LAST = _LV_OBJ_PART_VIRTUAL_FIRST,
+    _LV_OBJ_PART_REAL_LAST =    _LV_OBJ_PART_REAL_FIRST,
     LV_OBJ_PART_ALL = 0xFF,
 };
 
@@ -464,6 +468,24 @@ void lv_obj_set_height_margin(lv_obj_t * obj, lv_coord_t h);
  */
 void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
 
+/**
+ * Align an object to an other object horizontally.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param x_ofs x coordinate offset after alignment
+ */
+void lv_obj_align_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs);
+
+/**
+ * Align an object to an other object vertically.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param y_ofs y coordinate offset after alignment
+ */
+void lv_obj_align_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs);
+
 /**
  * Align an object to an other object.
  * @param obj pointer to an object to align
@@ -474,6 +496,25 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
  */
 void lv_obj_align_origo(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs, lv_coord_t y_ofs);
 
+
+/**
+ * Align an object's middle point to an other object horizontally.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param x_ofs x coordinate offset after alignment
+ */
+void lv_obj_align_origo_x(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t x_ofs);
+
+/**
+ * Align an object's middle point to an other object vertically.
+ * @param obj pointer to an object to align
+ * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
+ * @param align type of alignment (see 'lv_align_t' enum)
+ * @param y_ofs y coordinate offset after alignment
+ */
+void lv_obj_align_origo_y(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_coord_t y_ofs);
+
 /**
  * Realign the object based on the last `lv_obj_align` parameters.
  * @param obj pointer to an object
@@ -685,6 +726,14 @@ void lv_obj_set_drag_throw(lv_obj_t * obj, bool en);
  */
 void lv_obj_set_drag_parent(lv_obj_t * obj, bool en);
 
+/**
+* Enable to use parent for focus state.
+* When object is focused the parent will get the state instead (visual only)
+* @param obj pointer to an object
+* @param en true: enable the 'focus parent' for the object
+*/
+void lv_obj_set_focus_parent(lv_obj_t * obj, bool en);
+
 /**
 * Enable to use parent for gesture related operations.
 * If trying to gesture the object the parent will be moved instead
@@ -774,6 +823,20 @@ void lv_obj_set_event_cb(lv_obj_t * obj, lv_event_cb_t event_cb);
  */
 lv_res_t lv_event_send(lv_obj_t * obj, lv_event_t event, const void * data);
 
+
+/**
+ * Send LV_EVENT_REFRESH event to an object
+ * @param obj point to an obejct. (Can NOT be NULL)
+ * @return LV_RES_OK: success, LV_RES_INV: to object become invalid (e.g. deleted) due to this event.
+ */
+lv_res_t lv_event_send_refresh(lv_obj_t * obj);
+
+/**
+ * Send LV_EVENT_REFRESH event to an object and all of its children
+ * @param obj pointer to an object or NULL to refresh all objects of all displays
+ */
+void lv_event_send_refresh_recursive(lv_obj_t * obj);
+
 /**
  * Call an event function with an object, event, and data.
  * @param event_xcb an event callback function. If `NULL` `LV_RES_OK` will return without any actions.
@@ -1187,6 +1250,15 @@ bool lv_obj_get_drag_throw(const lv_obj_t * obj);
  */
 bool lv_obj_get_drag_parent(const lv_obj_t * obj);
 
+
+/**
+* Get the focus parent attribute of an object
+* @param obj pointer to an object
+* @return true: focus parent is enabled
+*/
+bool lv_obj_get_focus_parent(const lv_obj_t * obj);
+
+
 /**
  * Get the drag parent attribute of an object
  * @param obj pointer to an object
@@ -1318,6 +1390,13 @@ void * lv_obj_get_group(const lv_obj_t * obj);
  */
 bool lv_obj_is_focused(const lv_obj_t * obj);
 
+/**
+ * Get the really focused object by taking `focus_parent` into account.
+ * @param obj the start object
+ * @return the object to really focus
+ */
+lv_obj_t * lv_obj_get_focused_obj(const lv_obj_t * obj);
+
 /*-------------------
  * OTHER FUNCTIONS
  *------------------*/
@@ -1411,8 +1490,8 @@ bool lv_debug_check_obj_valid(const lv_obj_t * obj);
 
 # ifndef LV_DEBUG_IS_OBJ
 #  define LV_DEBUG_IS_OBJ(obj_p, obj_type) (lv_debug_check_null(obj_p) &&      \
-                                          lv_debug_check_obj_valid(obj_p) && \
-                                          lv_debug_check_obj_type(obj_p, obj_type))
+                                            lv_debug_check_obj_valid(obj_p) && \
+                                            lv_debug_check_obj_type(obj_p, obj_type))
 # endif
 
 

src/lv_core/lv_obj_style_dec.h

@@ -199,6 +199,102 @@ _LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_END_COLOR, scale_end_color, lv_color_t, _col
 
 #undef _LV_OBJ_STYLE_SET_GET_DECLARE
 
+
+static inline void lv_obj_set_style_local_pad_all(lv_obj_t * obj, uint8_t part, lv_state_t state, lv_style_int_t value)
+{
+    lv_obj_set_style_local_pad_top(obj, part, state, value);
+    lv_obj_set_style_local_pad_bottom(obj, part, state, value);
+    lv_obj_set_style_local_pad_left(obj, part, state, value);
+    lv_obj_set_style_local_pad_right(obj, part, state, value);
+}
+
+
+static inline void lv_style_set_pad_all(lv_style_t * style, lv_state_t state, lv_style_int_t value)
+{
+    lv_style_set_pad_top(style, state, value);
+    lv_style_set_pad_bottom(style, state, value);
+    lv_style_set_pad_left(style, state, value);
+    lv_style_set_pad_right(style, state, value);
+}
+
+
+static inline void lv_obj_set_style_local_pad_hor(lv_obj_t * obj, uint8_t part, lv_state_t state, lv_style_int_t value)
+{
+    lv_obj_set_style_local_pad_left(obj, part, state, value);
+    lv_obj_set_style_local_pad_right(obj, part, state, value);
+}
+
+
+static inline void lv_style_set_pad_hor(lv_style_t * style, lv_state_t state, lv_style_int_t value)
+{
+    lv_style_set_pad_left(style, state, value);
+    lv_style_set_pad_right(style, state, value);
+}
+
+
+static inline void lv_obj_set_style_local_pad_ver(lv_obj_t * obj, uint8_t part, lv_state_t state, lv_style_int_t value)
+{
+    lv_obj_set_style_local_pad_top(obj, part, state, value);
+    lv_obj_set_style_local_pad_bottom(obj, part, state, value);
+}
+
+
+static inline void lv_style_set_pad_ver(lv_style_t * style, lv_state_t state, lv_style_int_t value)
+{
+    lv_style_set_pad_top(style, state, value);
+    lv_style_set_pad_bottom(style, state, value);
+}
+
+
+static inline void lv_obj_set_style_local_margin_all(lv_obj_t * obj, uint8_t part, lv_state_t state,
+                                                     lv_style_int_t value)
+{
+    lv_obj_set_style_local_margin_top(obj, part, state, value);
+    lv_obj_set_style_local_margin_bottom(obj, part, state, value);
+    lv_obj_set_style_local_margin_left(obj, part, state, value);
+    lv_obj_set_style_local_margin_right(obj, part, state, value);
+}
+
+
+static inline void lv_style_set_margin_all(lv_style_t * style, lv_state_t state, lv_style_int_t value)
+{
+    lv_style_set_margin_top(style, state, value);
+    lv_style_set_margin_bottom(style, state, value);
+    lv_style_set_margin_left(style, state, value);
+    lv_style_set_margin_right(style, state, value);
+}
+
+
+static inline void lv_obj_set_style_local_margin_hor(lv_obj_t * obj, uint8_t part, lv_state_t state,
+                                                     lv_style_int_t value)
+{
+    lv_obj_set_style_local_margin_left(obj, part, state, value);
+    lv_obj_set_style_local_margin_right(obj, part, state, value);
+}
+
+
+static inline void lv_style_set_margin_hor(lv_style_t * style, lv_state_t state, lv_style_int_t value)
+{
+    lv_style_set_margin_left(style, state, value);
+    lv_style_set_margin_right(style, state, value);
+}
+
+
+static inline void lv_obj_set_style_local_margin_ver(lv_obj_t * obj, uint8_t part, lv_state_t state,
+                                                     lv_style_int_t value)
+{
+    lv_obj_set_style_local_margin_top(obj, part, state, value);
+    lv_obj_set_style_local_margin_bottom(obj, part, state, value);
+}
+
+
+static inline void lv_style_set_margin_ver(lv_style_t * style, lv_state_t state, lv_style_int_t value)
+{
+    lv_style_set_margin_top(style, state, value);
+    lv_style_set_margin_bottom(style, state, value);
+}
+
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

src/lv_core/lv_refr.c

@@ -205,7 +205,8 @@ void _lv_disp_refr_task(lv_task_t * task)
         if(lv_disp_is_true_double_buf(disp_refr)) {
             if(disp_refr->driver.set_px_cb) {
                 LV_LOG_WARN("Can't handle 2 screen sized buffers with set_px_cb. Display is not refreshed.");
-            } else {
+            }
+            else {
                 lv_disp_buf_t * vdb = lv_disp_get_buf(disp_refr);
 
                 /*Flush the content of the VDB*/
@@ -217,11 +218,11 @@ void _lv_disp_refr_task(lv_task_t * task)
                 while(vdb->flushing);
 
                 lv_color_t * copy_buf = NULL;
-    #if LV_USE_GPU_STM32_DMA2D
+#if LV_USE_GPU_STM32_DMA2D
                 LV_UNUSED(copy_buf);
-    #else
+#else
                 copy_buf = _lv_mem_buf_get(disp_refr->driver.hor_res * sizeof(lv_color_t));
-                #endif
+#endif
 
                 uint8_t * buf_act = (uint8_t *)vdb->buf_act;
                 uint8_t * buf_ina = (uint8_t *)vdb->buf_act == vdb->buf1 ? vdb->buf2 : vdb->buf1;
@@ -232,12 +233,12 @@ void _lv_disp_refr_task(lv_task_t * task)
                     if(disp_refr->inv_area_joined[a] == 0) {
                         uint32_t start_offs =
                             (hres * disp_refr->inv_areas[a].y1 + disp_refr->inv_areas[a].x1) * sizeof(lv_color_t);
-    #if LV_USE_GPU_STM32_DMA2D
+#if LV_USE_GPU_STM32_DMA2D
                         lv_gpu_stm32_dma2d_copy((lv_color_t *)(buf_act + start_offs), disp_refr->driver.hor_res,
                                                 (lv_color_t *)(buf_ina + start_offs), disp_refr->driver.hor_res,
                                                 lv_area_get_width(&disp_refr->inv_areas[a]),
                                                 lv_area_get_height(&disp_refr->inv_areas[a]));
-    #else
+#else
 
                         lv_coord_t y;
                         uint32_t line_length = lv_area_get_width(&disp_refr->inv_areas[a]) * sizeof(lv_color_t);
@@ -249,7 +250,7 @@ void _lv_disp_refr_task(lv_task_t * task)
                             _lv_memcpy(buf_act + start_offs, copy_buf, line_length);
                             start_offs += hres * sizeof(lv_color_t);
                         }
-    #endif
+#endif
                     }
                 }
 
@@ -489,7 +490,8 @@ static void lv_refr_area_part(const lv_area_t * area_p)
         }
     }
 
-    lv_obj_t * top_p;
+    lv_obj_t * top_act_scr = NULL;
+    lv_obj_t * top_prev_scr = NULL;
 
     /*Get the new mask from the original area and the act. VDB
      It will be a part of 'area_p'*/
@@ -497,10 +499,55 @@ static void lv_refr_area_part(const lv_area_t * area_p)
     _lv_area_intersect(&start_mask, area_p, &vdb->area);
 
     /*Get the most top object which is not covered by others*/
-    top_p = lv_refr_get_top_obj(&start_mask, lv_disp_get_scr_act(disp_refr));
+    top_act_scr = lv_refr_get_top_obj(&start_mask, lv_disp_get_scr_act(disp_refr));
+    if(disp_refr->prev_scr) {
+        top_prev_scr = lv_refr_get_top_obj(&start_mask, disp_refr->prev_scr);
+    }
 
+    /*Draw a display background if there is no top object*/
+    if(top_act_scr == NULL && top_prev_scr == NULL) {
+        if(disp_refr->bg_img) {
+            lv_draw_img_dsc_t dsc;
+            lv_draw_img_dsc_init(&dsc);
+            dsc.opa = disp_refr->bg_opa;
+            lv_img_header_t header;
+            lv_res_t res;
+            res = lv_img_decoder_get_info(disp_refr->bg_img, &header);
+            if(res == LV_RES_OK) {
+                lv_area_t a;
+                lv_area_set(&a, 0, 0, header.w - 1, header.h - 1);
+                lv_draw_img(&a, &start_mask, disp_refr->bg_img, &dsc);
+            }
+            else {
+                LV_LOG_WARN("Can't draw the background image")
+            }
+        }
+        else {
+            lv_draw_rect_dsc_t dsc;
+            lv_draw_rect_dsc_init(&dsc);
+            dsc.bg_color = disp_refr->bg_color;
+            dsc.bg_opa = disp_refr->bg_opa;
+            lv_draw_rect(&start_mask, &start_mask, &dsc);
+
+        }
+    }
+    /*Refresh the previous screen if any*/
+    if(disp_refr->prev_scr) {
+        /*Get the most top object which is not covered by others*/
+        if(top_prev_scr == NULL) {
+            top_prev_scr = disp_refr->prev_scr;
+        }
+        /*Do the refreshing from the top object*/
+        lv_refr_obj_and_children(top_prev_scr, &start_mask);
+
+    }
+
+
+    if(top_act_scr == NULL) {
+        top_act_scr = disp_refr->act_scr;
+    }
     /*Do the refreshing from the top object*/
-    lv_refr_obj_and_children(top_p, &start_mask);
+    lv_refr_obj_and_children(top_act_scr, &start_mask);
 
     /*Also refresh top and sys layer unconditionally*/
     lv_refr_obj_and_children(lv_disp_get_layer_top(disp_refr), &start_mask);

src/lv_core/lv_style.c

@@ -36,6 +36,12 @@
  **********************/
 LV_ATTRIBUTE_FAST_MEM static inline int32_t get_property_index(const lv_style_t * style, lv_style_property_t prop);
 static lv_style_t * get_alloc_local_style(lv_style_list_t * list);
+static inline void style_resize(lv_style_t * style, size_t sz);
+static inline lv_style_property_t get_style_prop(const lv_style_t * style, size_t idx);
+static inline uint8_t get_style_prop_id(const lv_style_t * style, size_t idx);
+static inline uint8_t get_style_prop_attr(const lv_style_t * style, size_t idx);
+static inline size_t get_prop_size(uint8_t prop_id);
+static inline size_t get_next_prop_index(uint8_t prop_id, size_t id);
 
 /**********************
  *  GLOABAL VARIABLES
@@ -102,16 +108,12 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_property_t prop)
         lv_style_attr_t attr_found;
         lv_style_attr_t attr_goal;
 
-        attr_found.full = *(style->map + id + 1);
-        attr_goal.full = (prop >> 8) & 0xFFU;
+        attr_found = get_style_prop_attr(style, id);
+        attr_goal = (prop >> 8) & 0xFFU;
 
-        if(attr_found.bits.state == attr_goal.bits.state) {
+        if(LV_STYLE_ATTR_GET_STATE(attr_found) == LV_STYLE_ATTR_GET_STATE(attr_goal)) {
             uint32_t map_size = _lv_style_get_mem_size(style);
-            uint8_t prop_size = sizeof(lv_style_property_t);
-            if((prop & 0xF) < LV_STYLE_ID_COLOR) prop_size += sizeof(lv_style_int_t);
-            else if((prop & 0xF) < LV_STYLE_ID_OPA) prop_size += sizeof(lv_color_t);
-            else if((prop & 0xF) < LV_STYLE_ID_PTR) prop_size += sizeof(lv_opa_t);
-            else prop_size += sizeof(const void *);
+            uint8_t prop_size = get_prop_size(prop);
 
             /*Move the props to fill the space of the property to delete*/
             uint32_t i;
@@ -119,7 +121,7 @@ bool lv_style_remove_prop(lv_style_t * style, lv_style_property_t prop)
                 style->map[i] = style->map[i + prop_size];
             }
 
-            style->map = lv_mem_realloc(style->map, map_size - prop_size);
+            style_resize(style, map_size - prop_size);
 
             return true;
         }
@@ -255,7 +257,7 @@ void _lv_style_list_remove_style(lv_style_list_t * list, lv_style_t * style)
         return;
     }
 
-    lv_style_t ** new_classes = lv_mem_realloc(list->style_list, sizeof(lv_style_t *) * (list->style_cnt - 1));
+    lv_style_t ** new_classes = lv_mem_alloc(sizeof(lv_style_t *) * (list->style_cnt - 1));
     LV_ASSERT_MEM(new_classes);
     if(new_classes == NULL) {
         LV_LOG_WARN("lv_style_list_remove_style: couldn't reallocate class list");
@@ -269,6 +271,8 @@ void _lv_style_list_remove_style(lv_style_list_t * list, lv_style_t * style)
 
     }
 
+    lv_mem_free(list->style_list);
+
     list->style_cnt--;
     list->style_list = new_classes;
 }
@@ -335,14 +339,9 @@ uint16_t _lv_style_get_mem_size(const lv_style_t * style)
     if(style->map == NULL) return 0;
 
     size_t i = 0;
-    while(style->map[i] != _LV_STYLE_CLOSEING_PROP) {
-        /*Go to the next property*/
-        if((style->map[i] & 0xF) < LV_STYLE_ID_COLOR) i += sizeof(lv_style_int_t);
-        else if((style->map[i] & 0xF) < LV_STYLE_ID_OPA) i += sizeof(lv_color_t);
-        else if((style->map[i] & 0xF) < LV_STYLE_ID_PTR) i += sizeof(lv_opa_t);
-        else i += sizeof(const void *);
-
-        i += sizeof(lv_style_property_t);
+    uint8_t prop_id;
+    while((prop_id = get_style_prop_id(style, i)) != _LV_STYLE_CLOSEING_PROP) {
+        i = get_next_prop_index(prop_id, i);
     }
 
     return i + sizeof(lv_style_property_t);
@@ -368,10 +367,10 @@ void _lv_style_set_int(lv_style_t * style, lv_style_property_t prop, lv_style_in
         lv_style_attr_t attr_found;
         lv_style_attr_t attr_goal;
 
-        attr_found.full = *(style->map + id + 1);
-        attr_goal.full = (prop >> 8) & 0xFFU;
+        attr_found = get_style_prop_attr(style, id);
+        attr_goal = (prop >> 8) & 0xFFU;
 
-        if(attr_found.bits.state == attr_goal.bits.state) {
+        if(LV_STYLE_ATTR_GET_STATE(attr_found) == LV_STYLE_ATTR_GET_STATE(attr_goal)) {
             _lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &value, sizeof(lv_style_int_t));
             return;
         }
@@ -385,7 +384,7 @@ void _lv_style_set_int(lv_style_t * style, lv_style_property_t prop, lv_style_in
     uint16_t size = _lv_style_get_mem_size(style);
     if(size == 0) size += end_mark_size;
     size += sizeof(lv_style_property_t) + sizeof(lv_style_int_t);
-    style->map = lv_mem_realloc(style->map, size);
+    style_resize(style, size);
     LV_ASSERT_MEM(style->map);
     if(style == NULL) return;
 
@@ -414,10 +413,10 @@ void _lv_style_set_color(lv_style_t * style, lv_style_property_t prop, lv_color_
         lv_style_attr_t attr_found;
         lv_style_attr_t attr_goal;
 
-        attr_found.full = *(style->map + id + 1);
-        attr_goal.full = (prop >> 8) & 0xFFU;
+        attr_found = get_style_prop_attr(style, id);
+        attr_goal = (prop >> 8) & 0xFFU;
 
-        if(attr_found.bits.state == attr_goal.bits.state) {
+        if(LV_STYLE_ATTR_GET_STATE(attr_found) == LV_STYLE_ATTR_GET_STATE(attr_goal)) {
             _lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &color, sizeof(lv_color_t));
             return;
         }
@@ -432,7 +431,7 @@ void _lv_style_set_color(lv_style_t * style, lv_style_property_t prop, lv_color_
     if(size == 0) size += end_mark_size;
 
     size += sizeof(lv_style_property_t) + sizeof(lv_color_t);
-    style->map = lv_mem_realloc(style->map, size);
+    style_resize(style, size);
     LV_ASSERT_MEM(style->map);
     if(style == NULL) return;
 
@@ -461,10 +460,10 @@ void _lv_style_set_opa(lv_style_t * style, lv_style_property_t prop, lv_opa_t op
         lv_style_attr_t attr_found;
         lv_style_attr_t attr_goal;
 
-        attr_found.full = *(style->map + id + 1);
-        attr_goal.full = (prop >> 8) & 0xFFU;
+        attr_found = get_style_prop_attr(style, id);
+        attr_goal = (prop >> 8) & 0xFFU;
 
-        if(attr_found.bits.state == attr_goal.bits.state) {
+        if(LV_STYLE_ATTR_GET_STATE(attr_found) == LV_STYLE_ATTR_GET_STATE(attr_goal)) {
             _lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &opa, sizeof(lv_opa_t));
             return;
         }
@@ -479,7 +478,7 @@ void _lv_style_set_opa(lv_style_t * style, lv_style_property_t prop, lv_opa_t op
     if(size == 0) size += end_mark_size;
 
     size += sizeof(lv_style_property_t) + sizeof(lv_opa_t);
-    style->map = lv_mem_realloc(style->map, size);
+    style_resize(style, size);
     LV_ASSERT_MEM(style->map);
     if(style == NULL) return;
 
@@ -508,10 +507,10 @@ void _lv_style_set_ptr(lv_style_t * style, lv_style_property_t prop, const void
         lv_style_attr_t attr_found;
         lv_style_attr_t attr_goal;
 
-        attr_found.full = *(style->map + id + 1);
-        attr_goal.full = (prop >> 8) & 0xFFU;
+        attr_found = get_style_prop_attr(style, id);
+        attr_goal = (prop >> 8) & 0xFFU;
 
-        if(attr_found.bits.state == attr_goal.bits.state) {
+        if(LV_STYLE_ATTR_GET_STATE(attr_found) == LV_STYLE_ATTR_GET_STATE(attr_goal)) {
             _lv_memcpy_small(style->map + id + sizeof(lv_style_property_t), &p, sizeof(const void *));
             return;
         }
@@ -526,7 +525,7 @@ void _lv_style_set_ptr(lv_style_t * style, lv_style_property_t prop, const void
     if(size == 0) size += end_mark_size;
 
     size += sizeof(lv_style_property_t) + sizeof(const void *);
-    style->map = lv_mem_realloc(style->map, size);
+    style_resize(style, size);
     LV_ASSERT_MEM(style->map);
     if(style == NULL) return;
 
@@ -560,12 +559,12 @@ int16_t _lv_style_get_int(const lv_style_t * style, lv_style_property_t prop, vo
     else {
         _lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_style_int_t));
         lv_style_attr_t attr_act;
-        attr_act.full = style->map[id + 1];
+        attr_act = get_style_prop_attr(style, id);
 
         lv_style_attr_t attr_goal;
-        attr_goal.full = (prop >> 8) & 0xFF;
+        attr_goal = (prop >> 8) & 0xFF;
 
-        return attr_act.bits.state & attr_goal.bits.state;
+        return LV_STYLE_ATTR_GET_STATE(attr_act) & LV_STYLE_ATTR_GET_STATE(attr_goal);
     }
 }
 
@@ -597,12 +596,12 @@ int16_t _lv_style_get_opa(const lv_style_t * style, lv_style_property_t prop, vo
     else {
         _lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_opa_t));
         lv_style_attr_t attr_act;
-        attr_act.full = style->map[id + 1];
+        attr_act = get_style_prop_attr(style, id);
 
         lv_style_attr_t attr_goal;
-        attr_goal.full = (prop >> 8) & 0xFF;
+        attr_goal = (prop >> 8) & 0xFF;
 
-        return attr_act.bits.state & attr_goal.bits.state;
+        return LV_STYLE_ATTR_GET_STATE(attr_act) & LV_STYLE_ATTR_GET_STATE(attr_goal);
     }
 }
 
@@ -631,12 +630,12 @@ int16_t _lv_style_get_color(const lv_style_t * style, lv_style_property_t prop,
     else {
         _lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(lv_color_t));
         lv_style_attr_t attr_act;
-        attr_act.full = style->map[id + 1];
+        attr_act = get_style_prop_attr(style, id);
 
         lv_style_attr_t attr_goal;
-        attr_goal.full = (prop >> 8) & 0xFF;
+        attr_goal = (prop >> 8) & 0xFF;
 
-        return attr_act.bits.state & attr_goal.bits.state;
+        return LV_STYLE_ATTR_GET_STATE(attr_act) & LV_STYLE_ATTR_GET_STATE(attr_goal);
     }
 }
 
@@ -666,12 +665,12 @@ int16_t _lv_style_get_ptr(const lv_style_t * style, lv_style_property_t prop, vo
     else {
         _lv_memcpy_small(res, &style->map[id + sizeof(lv_style_property_t)], sizeof(const void *));
         lv_style_attr_t attr_act;
-        attr_act.full = style->map[id + 1];
+        attr_act = get_style_prop_attr(style, id);
 
         lv_style_attr_t attr_goal;
-        attr_goal.full = (prop >> 8) & 0xFF;
+        attr_goal = (prop >> 8) & 0xFF;
 
-        return attr_act.bits.state & attr_goal.bits.state;
+        return LV_STYLE_ATTR_GET_STATE(attr_act) & LV_STYLE_ATTR_GET_STATE(attr_goal);
     }
 }
 
@@ -819,8 +818,8 @@ lv_res_t _lv_style_list_get_int(lv_style_list_t * list, lv_style_property_t prop
     if(list->style_list == NULL) return LV_RES_INV;
 
     lv_style_attr_t attr;
-    attr.full = prop >> 8;
-    int16_t weight_goal = attr.full;
+    attr = prop >> 8;
+    int16_t weight_goal = attr;
 
     int16_t weight = -1;
 
@@ -871,8 +870,8 @@ lv_res_t _lv_style_list_get_color(lv_style_list_t * list, lv_style_property_t pr
     if(list->style_list == NULL) return LV_RES_INV;
 
     lv_style_attr_t attr;
-    attr.full = prop >> 8;
-    int16_t weight_goal = attr.full;
+    attr = prop >> 8;
+    int16_t weight_goal = attr;
 
     int16_t weight = -1;
 
@@ -921,8 +920,8 @@ lv_res_t _lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop
     if(list->style_list == NULL) return LV_RES_INV;
 
     lv_style_attr_t attr;
-    attr.full = prop >> 8;
-    int16_t weight_goal = attr.full;
+    attr = prop >> 8;
+    int16_t weight_goal = attr;
 
     int16_t weight = -1;
 
@@ -971,8 +970,8 @@ lv_res_t _lv_style_list_get_ptr(lv_style_list_t * list, lv_style_property_t prop
     if(list->style_list == NULL) return LV_RES_INV;
 
     lv_style_attr_t attr;
-    attr.full = prop >> 8;
-    int16_t weight_goal = attr.full;
+    attr = prop >> 8;
+    int16_t weight_goal = attr;
 
     int16_t weight = -1;
 
@@ -1061,40 +1060,36 @@ LV_ATTRIBUTE_FAST_MEM static inline int32_t get_property_index(const lv_style_t
 
     uint8_t id_to_find = prop & 0xFF;
     lv_style_attr_t attr;
-    attr.full = (prop >> 8) & 0xFF;
+    attr = (prop >> 8) & 0xFF;
 
     int16_t weight = -1;
     int16_t id_guess = -1;
 
     size_t i = 0;
-    while(style->map[i] != _LV_STYLE_CLOSEING_PROP) {
-        if(style->map[i] == id_to_find) {
+
+    uint8_t prop_id;
+    while((prop_id = get_style_prop_id(style, i)) != _LV_STYLE_CLOSEING_PROP) {
+        if(prop_id == id_to_find) {
             lv_style_attr_t attr_i;
-            attr_i.full = style->map[i + 1];
+            attr_i = get_style_prop_attr(style, i);
 
             /*If the state perfectly matches return this property*/
-            if(attr_i.bits.state == attr.bits.state) {
+            if(LV_STYLE_ATTR_GET_STATE(attr_i) == LV_STYLE_ATTR_GET_STATE(attr)) {
                 return i;
             }
             /* Be sure the property not specifies other state than the requested.
              * E.g. For HOVER+PRESS, HOVER only is OK, but HOVER+FOCUS not*/
-            else if((attr_i.bits.state & (~attr.bits.state)) == 0) {
+            else if((LV_STYLE_ATTR_GET_STATE(attr_i) & (~LV_STYLE_ATTR_GET_STATE(attr))) == 0) {
                 /* Use this property if it describes better the requested state than the current candidate.
                  * E.g. for HOVER+FOCUS+PRESS prefer HOVER+FOCUS over FOCUS*/
-                if(attr_i.bits.state > weight) {
-                    weight = attr_i.bits.state;
+                if(LV_STYLE_ATTR_GET_STATE(attr_i) > weight) {
+                    weight = LV_STYLE_ATTR_GET_STATE(attr_i);
                     id_guess = i;
                 }
             }
         }
 
-        /*Go to the next property*/
-        if((style->map[i] & 0xF) < LV_STYLE_ID_COLOR) i += sizeof(lv_style_int_t);
-        else if((style->map[i] & 0xF) < LV_STYLE_ID_OPA) i += sizeof(lv_color_t);
-        else if((style->map[i] & 0xF) < LV_STYLE_ID_PTR) i += sizeof(lv_opa_t);
-        else i += sizeof(const void *);
-
-        i += sizeof(lv_style_property_t);
+        i = get_next_prop_index(prop_id, i);
     }
 
     return id_guess;
@@ -1125,3 +1120,79 @@ static lv_style_t * get_alloc_local_style(lv_style_list_t * list)
 
     return local_style;
 }
+
+/**
+ * Resizes a style map. Useful entry point for debugging.
+ * @param style pointer to the style to be resized.
+ * @param size new size
+ */
+static inline void style_resize(lv_style_t * style, size_t sz)
+{
+    style->map = lv_mem_realloc(style->map, sz);
+}
+
+/**
+ * Get style property in index.
+ * @param style pointer to style.
+ * @param idx index of the style in style->map
+ * @return property in style->map + idx
+ */
+static inline lv_style_property_t get_style_prop(const lv_style_t * style, size_t idx)
+{
+    lv_style_property_t prop;
+    uint8_t * prop_p = (uint8_t *)&prop;
+    prop_p[0] = style->map[idx];
+    prop_p[1] = style->map[idx + 1];
+    return prop;
+}
+
+/**
+ * Get style property id in index.
+ * @param style pointer to style.
+ * @param idx index of the style in style->map
+ * @return id of property in style->map + idx
+ */
+static inline uint8_t get_style_prop_id(const lv_style_t * style, size_t idx)
+{
+    return get_style_prop(style, idx) & 0xFF;
+}
+
+/**
+ * Get style property attributes for index.
+ * @param style pointer to style.
+ * @param idx index of the style in style->map
+ * @return attribute of property in style->map + idx
+ */
+static inline uint8_t get_style_prop_attr(const lv_style_t * style, size_t idx)
+{
+    return ((get_style_prop(style, idx) >> 8) & 0xFFU);
+}
+
+
+/**
+ * Get property size.
+ * @param prop_id property id.
+ * @param idx index of the style in style->map
+ * @return attribute of property in style->map + idx
+ */
+static inline size_t get_prop_size(uint8_t prop_id)
+{
+    prop_id &= 0xF;
+    size_t size = sizeof(lv_style_property_t);
+    if(prop_id < LV_STYLE_ID_COLOR) size += sizeof(lv_style_int_t);
+    else if(prop_id < LV_STYLE_ID_OPA) size += sizeof(lv_color_t);
+    else if(prop_id < LV_STYLE_ID_PTR) size += sizeof(lv_opa_t);
+    else size += sizeof(const void *);
+    return size;
+}
+
+/**
+ * Get next property index, given current property and index.
+ * @param prop_id property id.
+ * @param idx index of the style in style->map
+ * @return index of next property in style->map
+ */
+static inline size_t get_next_prop_index(uint8_t prop_id, size_t idx)
+{
+    return idx + get_prop_size(prop_id);
+}

src/lv_core/lv_style.h

@@ -81,13 +81,10 @@ enum {
 
 typedef uint8_t lv_text_decor_t;
 
-typedef union {
-    struct {
-        uint8_t state       : 7; /* To which state the property refers to*/
-        uint8_t inherit     : 1; /*1: The property can be inherited*/
-    } bits;
-    uint8_t full;
-} lv_style_attr_t;
+typedef uint8_t lv_style_attr_t;
+
+#define LV_STYLE_ATTR_GET_INHERIT(f) ((f)&0x80)
+#define LV_STYLE_ATTR_GET_STATE(f) ((f)&0x7F)
 
 #define LV_STYLE_ID_VALUE 0x0   /*max 9 pcs*/
 #define LV_STYLE_ID_COLOR 0x9   /*max 3 pcs*/
@@ -102,7 +99,7 @@ enum {
     LV_STYLE_PROP_INIT(LV_STYLE_TRANSFORM_WIDTH,    0x0, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_TRANSFORM_HEIGHT,   0x0, LV_STYLE_ID_VALUE + 5, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_TRANSFORM_ANGLE,    0x0, LV_STYLE_ID_VALUE + 6, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_TRANSFORM_ZOOM,   0x0, LV_STYLE_ID_VALUE + 7, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_TRANSFORM_ZOOM,     0x0, LV_STYLE_ID_VALUE + 7, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_OPA_SCALE,          0x0, LV_STYLE_ID_OPA + 0,   LV_STYLE_ATTR_INHERIT),
 
     LV_STYLE_PROP_INIT(LV_STYLE_PAD_TOP,            0x1, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
@@ -137,8 +134,8 @@ enum {
     LV_STYLE_PROP_INIT(LV_STYLE_OUTLINE_OPA,         0x4, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_NONE),
 
     LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_WIDTH,       0x5, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_OFS_X,    0x5, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_OFS_Y,    0x5, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_OFS_X,       0x5, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_OFS_Y,       0x5, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_SPREAD,      0x5, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_BLEND_MODE,  0x5, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_COLOR,       0x5, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
@@ -194,12 +191,12 @@ enum {
     LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_PROP_6,  0xB, LV_STYLE_ID_VALUE + 7, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_PATH,    0xB, LV_STYLE_ID_PTR + 0, LV_STYLE_ATTR_NONE),
 
-    LV_STYLE_PROP_INIT(LV_STYLE_SCALE_WIDTH,         0xC, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCALE_WIDTH,            0xC, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SCALE_BORDER_WIDTH,     0xC, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
     LV_STYLE_PROP_INIT(LV_STYLE_SCALE_END_BORDER_WIDTH, 0xC, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_SCALE_END_LINE_WIDTH, 0xC, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_SCALE_GRAD_COLOR,     0xC, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
-    LV_STYLE_PROP_INIT(LV_STYLE_SCALE_END_COLOR,      0xC, LV_STYLE_ID_COLOR + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCALE_END_LINE_WIDTH,   0xC, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCALE_GRAD_COLOR,       0xC, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SCALE_END_COLOR,        0xC, LV_STYLE_ID_COLOR + 1, LV_STYLE_ATTR_NONE),
 };
 
 typedef uint16_t lv_style_property_t;
@@ -573,7 +570,7 @@ bool lv_debug_check_style_list(const lv_style_list_t * list);
  *     lv_style_init(&my_style);
  *     lv_style_copy(&my_style, &style_to_copy);
  */
-#define LV_STYLE_CREATE(name, copy_p) static lv_style_t name; lv_style_init(&name); lv_style_copy(&name, copy);
+#define LV_STYLE_CREATE(name, copy_p) static lv_style_t name; lv_style_init(&name); lv_style_copy(&name, copy_p);
 
 
 

src/lv_draw/lv_draw_blend.c

@@ -36,9 +36,11 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(const lv_area_t * disp_area, lv_co
                                               lv_color_t color, lv_opa_t opa,
                                               const lv_opa_t * mask, lv_draw_mask_res_t mask_res);
 
+#if LV_USE_BLEND_MODES
 static void fill_blended(const lv_area_t * disp_area, lv_color_t * disp_buf,  const lv_area_t * draw_area,
                          lv_color_t color, lv_opa_t opa,
                          const lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_blend_mode_t mode);
+#endif
 
 static void map_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  const lv_area_t * draw_area,
                        const lv_area_t * map_area, const lv_color_t * map_buf, lv_opa_t opa,
@@ -49,17 +51,23 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(const lv_area_t * disp_area, lv_col
                                              const lv_area_t * map_area, const lv_color_t * map_buf, lv_opa_t opa,
                                              const lv_opa_t * mask, lv_draw_mask_res_t mask_res);
 
+#if LV_USE_BLEND_MODES
 static void map_blended(const lv_area_t * disp_area, lv_color_t * disp_buf,  const lv_area_t * draw_area,
                         const lv_area_t * map_area, const lv_color_t * map_buf, lv_opa_t opa,
                         const lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_blend_mode_t mode);
 
 static inline lv_color_t color_blend_true_color_additive(lv_color_t fg, lv_color_t bg, lv_opa_t opa);
 static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_color_t bg, lv_opa_t opa);
+#endif
 
 /**********************
  *  STATIC VARIABLES
  **********************/
 
+#if LV_USE_GPU || LV_USE_GPU_STM32_DMA2D
+    LV_ATTRIBUTE_DMA static lv_color_t blend_buf[LV_HOR_RES_MAX];
+#endif
+
 /**********************
  *      MACROS
  **********************/
@@ -163,9 +171,11 @@ LV_ATTRIBUTE_FAST_MEM void _lv_blend_fill(const lv_area_t * clip_area, const lv_
     else if(mode == LV_BLEND_MODE_NORMAL) {
         fill_normal(disp_area, disp_buf, &draw_area, color, opa, mask, mask_res);
     }
+#if LV_USE_BLEND_MODES
     else {
         fill_blended(disp_area, disp_buf, &draw_area, color, opa, mask, mask_res, mode);
     }
+#endif
 }
 
 /**
@@ -226,9 +236,11 @@ LV_ATTRIBUTE_FAST_MEM void _lv_blend_map(const lv_area_t * clip_area, const lv_a
     else if(mode == LV_BLEND_MODE_NORMAL) {
         map_normal(disp_area, disp_buf, &draw_area, map_area, map_buf, opa, mask, mask_res);
     }
+#if LV_USE_BLEND_MODES
     else {
         map_blended(disp_area, disp_buf, &draw_area, map_area, map_buf, opa, mask, mask_res, mode);
     }
+#endif
 }
 
 
@@ -269,7 +281,7 @@ static void fill_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  con
             for(x = draw_area->x1; x <= draw_area->x2; x++) {
                 if(mask_tmp[x]) {
                     disp->driver.set_px_cb(&disp->driver, (void *)disp_buf, disp_w, x, y, color,
-                            (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
+                                           (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
                 }
             }
             mask_tmp += draw_area_w;
@@ -338,7 +350,6 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(const lv_area_t * disp_area, lv_co
         else {
 #if LV_USE_GPU
             if(disp->driver.gpu_blend_cb && lv_area_get_size(draw_area) > GPU_SIZE_LIMIT) {
-                static lv_color_t blend_buf[LV_HOR_RES_MAX];
                 for(x = 0; x < draw_area_w ; x++) blend_buf[x].full = color.full;
 
                 for(y = draw_area->y1; y <= draw_area->y2; y++) {
@@ -352,7 +363,6 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(const lv_area_t * disp_area, lv_co
 
 #if LV_USE_GPU_STM32_DMA2D
             if(lv_area_get_size(draw_area) >= 240) {
-                static lv_color_t blend_buf[LV_HOR_RES_MAX] = {0};
                 if(blend_buf[0].full != color.full) lv_color_fill(blend_buf, color, LV_HOR_RES_MAX);
 
                 lv_coord_t line_h = LV_HOR_RES_MAX / draw_area_w;
@@ -513,7 +523,7 @@ LV_ATTRIBUTE_FAST_MEM static void fill_normal(const lv_area_t * disp_area, lv_co
     }
 }
 
-
+#if LV_USE_BLEND_MODES
 /**
  * Fill an area with a color but apply blending algorithms
  * @param disp_area the current display area (destination area)
@@ -604,6 +614,7 @@ static void fill_blended(const lv_area_t * disp_area, lv_color_t * disp_buf,  co
         }
     }
 }
+#endif
 
 static void map_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  const lv_area_t * draw_area,
                        const lv_area_t * map_area, const lv_color_t * map_buf, lv_opa_t opa,
@@ -843,7 +854,7 @@ LV_ATTRIBUTE_FAST_MEM static void map_normal(const lv_area_t * disp_area, lv_col
         }
     }
 }
-
+#if LV_USE_BLEND_MODES
 static void map_blended(const lv_area_t * disp_area, lv_color_t * disp_buf,  const lv_area_t * draw_area,
                         const lv_area_t * map_area, const lv_color_t * map_buf, lv_opa_t opa,
                         const lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_blend_mode_t mode)
@@ -994,3 +1005,4 @@ static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_co
 
     return lv_color_mix(fg, bg, opa);
 }
+#endif

src/lv_draw/lv_draw_blend.h

@@ -26,8 +26,10 @@ extern "C" {
  **********************/
 enum {
     LV_BLEND_MODE_NORMAL,
+#if LV_USE_BLEND_MODES
     LV_BLEND_MODE_ADDITIVE,
     LV_BLEND_MODE_SUBTRACTIVE,
+#endif
 };
 
 typedef uint8_t lv_blend_mode_t;

src/lv_draw/lv_draw_img.c

@@ -407,7 +407,6 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
                 return;
             }
 #endif
-            /*Build the image and a mask line-by-line*/
             uint32_t mask_buf_size = lv_area_get_size(&draw_area) > LV_HOR_RES_MAX ? LV_HOR_RES_MAX : lv_area_get_size(&draw_area);
             lv_color_t * map2 = _lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t));
             lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
@@ -420,7 +419,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
                     lv_opa_t px_opa = map_px[LV_IMG_PX_SIZE_ALPHA_BYTE - 1];
                     mask_buf[px_i] = px_opa;
                     if(px_opa) {
-#if LV_COLOR_DEPTH == 8
+#if LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
                         map2[px_i].full =  map_px[0];
 #elif LV_COLOR_DEPTH == 16
                         map2[px_i].full =  map_px[0] + (map_px[1] << 8);
@@ -458,9 +457,9 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
         /*Most complicated case: transform or other mask or chroma keyed*/
         else {
             /*Build the image and a mask line-by-line*/
-             uint32_t mask_buf_size = lv_area_get_size(&draw_area) > LV_HOR_RES_MAX ? LV_HOR_RES_MAX : lv_area_get_size(&draw_area);
-             lv_color_t * map2 = _lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t));
-             lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
+            uint32_t mask_buf_size = lv_area_get_size(&draw_area) > LV_HOR_RES_MAX ? LV_HOR_RES_MAX : lv_area_get_size(&draw_area);
+            lv_color_t * map2 = _lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t));
+            lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
 
 #if LV_USE_IMG_TRANSFORM
             lv_img_transform_dsc_t trans_dsc;

src/lv_draw/lv_draw_label.c

@@ -213,12 +213,12 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
         sel_start = sel_end;
         sel_end = tmp;
     }
-
     lv_draw_line_dsc_t line_dsc;
+    dsc->decor  = LV_TEXT_DECOR_UNDERLINE;
     if((dsc->decor & LV_TEXT_DECOR_UNDERLINE) || (dsc->decor & LV_TEXT_DECOR_STRIKETHROUGH)) {
         lv_draw_line_dsc_init(&line_dsc);
         line_dsc.color = dsc->color;
-        line_dsc.width = (dsc->font->line_height + 5) / 10;    /*+5 for rounding*/
+        line_dsc.width = font->underline_thickness;
         line_dsc.opa = dsc->opa;
         line_dsc.blend_mode = dsc->blend_mode;
     }
@@ -342,7 +342,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
             lv_point_t p1;
             lv_point_t p2;
             p1.x = pos_x_start;
-            p1.y = pos.y + dsc->font->line_height - dsc->font->base_line + line_dsc.width / 2 + 1;
+            p1.y = pos.y + dsc->font->line_height - dsc->font->base_line - font->underline_position;
             p2.x = pos.x;
             p2.y = p1.y;
             lv_draw_line(&p1, &p2, mask, &line_dsc);
@@ -420,7 +420,7 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_letter(const lv_point_t * pos_p, const
     }
 
     /* Don't draw anything if the character is empty. E.g. space */
-    if((g.box_h == 0) && (g.box_w == 0)) return;
+    if((g.box_h == 0) || (g.box_w == 0)) return;
 
     int32_t pos_x = pos_p->x + g.ofs_x;
     int32_t pos_y = pos_p->y + (font_p->line_height - font_p->base_line) - g.box_h - g.ofs_y;
@@ -607,6 +607,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(lv_coord_t pos_x, lv_coord_
 static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_dsc_t * g, const lv_area_t * clip_area,
                               const uint8_t * map_p, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode)
 {
+#if LV_USE_FONT_SUBPX
     const uint8_t * bpp_opa_table;
     uint32_t bitmask_init;
     uint32_t bitmask;
@@ -758,7 +759,7 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
             }
 
             /*Go to the next column*/
-            if(col_bit < (int32_t) (8 - bpp)) {
+            if(col_bit < (int32_t)(8 - bpp)) {
                 col_bit += bpp;
                 bitmask = bitmask >> bpp;
             }
@@ -806,6 +807,9 @@ static void draw_letter_subpx(lv_coord_t pos_x, lv_coord_t pos_y, lv_font_glyph_
 
     _lv_mem_buf_release(mask_buf);
     _lv_mem_buf_release(color_buf);
+#else
+    LV_LOG_WARN("Can't draw sub-pixel rendered letter because LV_USE_FONT_SUBPX == 0 in lv_conf.h");
+#endif
 }
 
 

src/lv_draw/lv_draw_rect.c

@@ -30,8 +30,10 @@
 LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc);
 LV_ATTRIBUTE_FAST_MEM static void draw_border(const lv_area_t * coords, const lv_area_t * clip,
                                               lv_draw_rect_dsc_t * dsc);
-static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc);
-LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i);
+
+#if LV_USE_OUTLINE
+    static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc);
+#endif
 #if LV_USE_SHADOW
 LV_ATTRIBUTE_FAST_MEM static void draw_shadow(const lv_area_t * coords, const lv_area_t * clip,
                                               lv_draw_rect_dsc_t * dsc);
@@ -39,8 +41,17 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coord
                                                          lv_coord_t r);
 LV_ATTRIBUTE_FAST_MEM static void shadow_blur_corner(lv_coord_t size, lv_coord_t sw, uint16_t * sh_ups_buf);
 #endif
-static void draw_pattern(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc);
-static void draw_value(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc);
+
+#if LV_USE_PATTERN
+    static void draw_pattern(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc);
+#endif
+
+#if LV_USE_VALUE_STR
+    static void draw_value_str(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc);
+#endif
+static void draw_full_border(const lv_area_t * area_inner, const lv_area_t * area_outer, const lv_area_t * clip,
+                             lv_coord_t radius, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);
+LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i);
 
 /**********************
  *  STATIC VARIABLES
@@ -95,10 +106,19 @@ void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect
 #endif
 
     draw_bg(coords, clip, dsc);
+
+#if LV_USE_PATTERN
     draw_pattern(coords, clip, dsc);
+#endif
     draw_border(coords, clip, dsc);
-    draw_value(coords, clip, dsc);
+
+#if LV_USE_VALUE_STR
+    draw_value_str(coords, clip, dsc);
+#endif
+
+#if LV_USE_OUTLINE
     draw_outline(coords, clip, dsc);
+#endif
 
     LV_ASSERT_MEM_INTEGRITY();
 }
@@ -370,41 +390,6 @@ LV_ATTRIBUTE_FAST_MEM static void draw_border(const lv_area_t * coords, const lv
     if(dsc->border_width == 0) return;
     if(dsc->border_side == LV_BORDER_SIDE_NONE) return;
 
-    lv_opa_t opa = dsc->border_opa;
-
-    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
-
-    lv_disp_t * disp    = _lv_refr_get_disp_refreshing();
-    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
-
-    /* Get clipped fill area which is the real draw area.
-     * It is always the same or inside `fill_area` */
-    lv_area_t draw_area;
-    bool is_common;
-    is_common = _lv_area_intersect(&draw_area, coords, clip);
-    if(is_common == false) return;
-
-    const lv_area_t * disp_area = &vdb->area;
-
-    /* Now `draw_area` has absolute coordinates.
-     * Make it relative to `disp_area` to simplify draw to `disp_buf`*/
-    draw_area.x1 -= disp_area->x1;
-    draw_area.y1 -= disp_area->y1;
-    draw_area.x2 -= disp_area->x1;
-    draw_area.y2 -= disp_area->y1;
-
-    int32_t draw_area_w = lv_area_get_width(&draw_area);
-
-    /*Create a mask if there is a radius*/
-    lv_opa_t * mask_buf = _lv_mem_buf_get(draw_area_w);
-
-    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
-    bool simple_mode = true;
-    if(other_mask_cnt) simple_mode = false;
-    else if(dsc->border_side != LV_BORDER_SIDE_FULL) simple_mode = false;
-
-    int16_t mask_rout_id = LV_MASK_ID_INV;
-
     int32_t coords_w = lv_area_get_width(coords);
     int32_t coords_h = lv_area_get_height(coords);
 
@@ -413,140 +398,80 @@ LV_ATTRIBUTE_FAST_MEM static void draw_border(const lv_area_t * coords, const lv
     int32_t short_side = LV_MATH_MIN(coords_w, coords_h);
     if(rout > short_side >> 1) rout = short_side >> 1;
 
-    /*Get the outer area*/
-    lv_draw_mask_radius_param_t mask_rout_param;
-    if(rout > 0) {
-        lv_draw_mask_radius_init(&mask_rout_param, coords, rout, false);
-        mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
-    }
-
-    /*Get the inner radius*/
-    int32_t rin = rout - dsc->border_width;
-    if(rin < 0) rin = 0;
-
     /*Get the inner area*/
-    lv_area_t area_small;
-    lv_area_copy(&area_small, coords);
-    area_small.x1 += ((dsc->border_side & LV_BORDER_SIDE_LEFT) ? dsc->border_width : - (dsc->border_width + rout));
-    area_small.x2 -= ((dsc->border_side & LV_BORDER_SIDE_RIGHT) ? dsc->border_width : - (dsc->border_width + rout));
-    area_small.y1 += ((dsc->border_side & LV_BORDER_SIDE_TOP) ? dsc->border_width : - (dsc->border_width + rout));
-    area_small.y2 -= ((dsc->border_side & LV_BORDER_SIDE_BOTTOM) ? dsc->border_width : - (dsc->border_width + rout));
+    lv_area_t area_inner;
+    lv_area_copy(&area_inner, coords);
+    area_inner.x1 += ((dsc->border_side & LV_BORDER_SIDE_LEFT) ? dsc->border_width : - (dsc->border_width + rout));
+    area_inner.x2 -= ((dsc->border_side & LV_BORDER_SIDE_RIGHT) ? dsc->border_width : - (dsc->border_width + rout));
+    area_inner.y1 += ((dsc->border_side & LV_BORDER_SIDE_TOP) ? dsc->border_width : - (dsc->border_width + rout));
+    area_inner.y2 -= ((dsc->border_side & LV_BORDER_SIDE_BOTTOM) ? dsc->border_width : - (dsc->border_width + rout));
 
-    /*Create inner the mask*/
-    lv_draw_mask_radius_param_t mask_rin_param;
-    lv_draw_mask_radius_init(&mask_rin_param, &area_small, rout - dsc->border_width, true);
-    int16_t mask_rin_id = lv_draw_mask_add(&mask_rin_param, NULL);
-
-    int32_t corner_size = LV_MATH_MAX(rout, dsc->border_width - 1);
-
-    int32_t h;
-    lv_draw_mask_res_t mask_res;
-    lv_area_t fill_area;
-
-    lv_color_t color = dsc->border_color;
-    lv_blend_mode_t blend_mode = dsc->border_blend_mode;
-
-    /*Apply some optimization if there is no other mask*/
-    if(simple_mode) {
-        /*Draw the upper corner area*/
-        int32_t upper_corner_end = coords->y1 - disp_area->y1 + corner_size;
-        upper_corner_end = LV_MATH_MIN(upper_corner_end, draw_area.y2);
-        fill_area.x1 = coords->x1;
-        fill_area.x2 = coords->x2;
-        fill_area.y1 = disp_area->y1 + draw_area.y1;
-        fill_area.y2 = fill_area.y1;
-        for(h = draw_area.y1; h <= upper_corner_end; h++) {
-            _lv_memset_ff(mask_buf, draw_area_w);
-            mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
-
-            lv_area_t fill_area2;
-            fill_area2.y1 = fill_area.y1;
-            fill_area2.y2 = fill_area.y2;
-
-            fill_area2.x1 = coords->x1;
-            fill_area2.x2 = coords->x1 + rout - 1;
-
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf, mask_res, opa, blend_mode);
-
-            /*Draw the top horizontal line*/
-            if(fill_area2.y2 < coords->y1 + dsc->border_width) {
-                fill_area2.x1 = coords->x1 + rout;
-                fill_area2.x2 = coords->x2 - rout;
-
-                _lv_blend_fill(clip, &fill_area2, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-            }
-
-            fill_area2.x1 = coords->x2 - rout + 1;
-            fill_area2.x2 = coords->x2;
-
-            int32_t mask_ofs = (coords->x2 - rout + 1) - (vdb->area.x1 + draw_area.x1);
-            if(mask_ofs < 0) mask_ofs = 0;
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf + mask_ofs, mask_res, opa, blend_mode);
-
-            fill_area.y1++;
-            fill_area.y2++;
-        }
-
-        /*Draw the lower corner area */
-        int32_t lower_corner_end = coords->y2 - disp_area->y1 - corner_size;
-        lower_corner_end = LV_MATH_MAX(lower_corner_end, draw_area.y1);
-        if(lower_corner_end <= upper_corner_end) lower_corner_end = upper_corner_end + 1;
-        fill_area.y1 = disp_area->y1 + lower_corner_end;
-        fill_area.y2 = fill_area.y1;
-        for(h = lower_corner_end; h <= draw_area.y2; h++) {
-            _lv_memset_ff(mask_buf, draw_area_w);
-            mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
-
-            lv_area_t fill_area2;
-            fill_area2.x1 = coords->x1;
-            fill_area2.x2 = coords->x1 + rout - 1;
-            fill_area2.y1 = fill_area.y1;
-            fill_area2.y2 = fill_area.y2;
-
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf, mask_res, opa, blend_mode);
-
-            /*Draw the bottom horizontal line*/
-            if(fill_area2.y2 > coords->y2 - dsc->border_width) {
-                fill_area2.x1 = coords->x1 + rout;
-                fill_area2.x2 = coords->x2 - rout;
-
-                _lv_blend_fill(clip, &fill_area2, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-            }
-            fill_area2.x1 = coords->x2 - rout + 1;
-            fill_area2.x2 = coords->x2;
-
-            int32_t mask_ofs = (coords->x2 - rout + 1) - (vdb->area.x1 + draw_area.x1);
-            if(mask_ofs < 0) mask_ofs = 0;
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf + mask_ofs, mask_res, opa, blend_mode);
-
-
-            fill_area.y1++;
-            fill_area.y2++;
-        }
-
-        /*Draw the left vertical border part*/
-        fill_area.y1 = coords->y1 + corner_size + 1;
-        fill_area.y2 = coords->y2 - corner_size - 1;
-
-        fill_area.x1 = coords->x1;
-        fill_area.x2 = coords->x1 + dsc->border_width - 1;
-        _lv_blend_fill(clip, &fill_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-
-        /*Draw the right vertical border*/
-        fill_area.x1 = coords->x2 - dsc->border_width + 1;
-        fill_area.x2 = coords->x2;
-
-        _lv_blend_fill(clip, &fill_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+    if(dsc->border_side == LV_BORDER_SIDE_FULL) {
+        draw_full_border(&area_inner, coords, clip, dsc->radius, dsc->border_color, dsc->border_opa, dsc->border_blend_mode);
     }
-    /*Process line by line if there is other mask too*/
     else {
+        lv_opa_t opa = dsc->border_opa;
+        if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+        lv_disp_t * disp    = _lv_refr_get_disp_refreshing();
+        lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+
+        /* Get clipped fill area which is the real draw area.
+         * It is always the same or inside `fill_area` */
+        lv_area_t draw_area;
+        bool is_common;
+        is_common = _lv_area_intersect(&draw_area, coords, clip);
+        if(is_common == false) return;
+
+        const lv_area_t * disp_area = &vdb->area;
+
+        /* Now `draw_area` has absolute coordinates.
+         * Make it relative to `disp_area` to simplify draw to `disp_buf`*/
+        draw_area.x1 -= disp_area->x1;
+        draw_area.y1 -= disp_area->y1;
+        draw_area.x2 -= disp_area->x1;
+        draw_area.y2 -= disp_area->y1;
+
+        int32_t draw_area_w = lv_area_get_width(&draw_area);
+
+        /*Create a mask if there is a radius*/
+        lv_opa_t * mask_buf = _lv_mem_buf_get(draw_area_w);
+
+        /*Create mask for the outer area*/
+        int16_t mask_rout_id = LV_MASK_ID_INV;
+        lv_draw_mask_radius_param_t mask_rout_param;
+        if(rout > 0) {
+            lv_draw_mask_radius_init(&mask_rout_param, coords, rout, false);
+            mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
+        }
+
+        /*Create mask for the inner mask*/
+        int32_t rin = rout - dsc->border_width;
+        if(rin < 0) rin = 0;
+        lv_draw_mask_radius_param_t mask_rin_param;
+        lv_draw_mask_radius_init(&mask_rin_param, &area_inner, rout - dsc->border_width, true);
+        int16_t mask_rin_id = lv_draw_mask_add(&mask_rin_param, NULL);
+
+        int32_t corner_size = LV_MATH_MAX(rout, dsc->border_width - 1);
+
+        int32_t h;
+        lv_draw_mask_res_t mask_res;
+        lv_area_t fill_area;
+
+        lv_color_t color = dsc->border_color;
+        lv_blend_mode_t blend_mode = dsc->border_blend_mode;
+
         fill_area.x1 = coords->x1;
         fill_area.x2 = coords->x2;
         fill_area.y1 = disp_area->y1 + draw_area.y1;
         fill_area.y2 = fill_area.y1;
 
+        uint32_t buf_ofs = 0;
         if(dsc->border_side == LV_BORDER_SIDE_LEFT) fill_area.x2 = coords->x1 + corner_size;
-        else if(dsc->border_side == LV_BORDER_SIDE_RIGHT) fill_area.x1 = coords->x2 - corner_size;
+        else if(dsc->border_side == LV_BORDER_SIDE_RIGHT) {
+            fill_area.x1 = coords->x2 - corner_size;
+            buf_ofs = fill_area.x1 - coords->x1;
+        }
 
         volatile bool top_only = false;
         volatile bool bottom_only = false;
@@ -565,16 +490,16 @@ LV_ATTRIBUTE_FAST_MEM static void draw_border(const lv_area_t * coords, const lv
                (bottom_only && fill_area.y1 >= coords->y2 - corner_size)) {
                 _lv_memset_ff(mask_buf, draw_area_w);
                 mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
-                _lv_blend_fill(clip, &fill_area, color, mask_buf, mask_res, opa, blend_mode);
+                _lv_blend_fill(clip, &fill_area, color, mask_buf + buf_ofs, mask_res, opa, blend_mode);
             }
             fill_area.y1++;
             fill_area.y2++;
 
         }
+        lv_draw_mask_remove_id(mask_rin_id);
+        lv_draw_mask_remove_id(mask_rout_id);
+        _lv_mem_buf_release(mask_buf);
     }
-    lv_draw_mask_remove_id(mask_rin_id);
-    lv_draw_mask_remove_id(mask_rout_id);
-    _lv_mem_buf_release(mask_buf);
 }
 
 LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i)
@@ -1047,7 +972,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_shadow(const lv_area_t * coords, const lv
             if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) mask_res = LV_DRAW_MASK_RES_CHANGED;
 
             _lv_blend_fill(clip, &fa, dsc->shadow_color, mask_buf,
-                    mask_res, LV_OPA_COVER, dsc->shadow_blend_mode);
+                           mask_res, LV_OPA_COVER, dsc->shadow_blend_mode);
             fa.y1++;
             fa.y2++;
         }
@@ -1111,7 +1036,7 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coord
     _lv_mem_buf_release(mask_line);
 
     if(sw == 1) {
-        uint32_t i;
+        int32_t i;
         lv_opa_t * res_buf = (lv_opa_t *)sh_buf;
         for(i = 0; i < size * size; i++) {
             res_buf[i] = (sh_buf[i] >> SHADOW_UPSACALE_SHIFT);
@@ -1140,7 +1065,7 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coord
 
         shadow_blur_corner(size, sw, sh_buf);
     }
-    uint32_t x;
+    int32_t x;
     lv_opa_t * res_buf = (lv_opa_t *)sh_buf;
     for(x = 0; x < size * size; x++) {
         res_buf[x] = sh_buf[x];
@@ -1222,6 +1147,7 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_blur_corner(lv_coord_t size, lv_coord_t
 
 #endif
 
+#if LV_USE_OUTLINE
 static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->outline_opa <= LV_OPA_MIN) return;
@@ -1231,10 +1157,6 @@ static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, lv_dr
 
     if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
 
-    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
-    bool simple_mode = true;
-    if(other_mask_cnt) simple_mode = false;
-
     /*Get the inner radius*/
     lv_area_t area_inner;
     lv_area_copy(&area_inner, coords);
@@ -1243,16 +1165,6 @@ static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, lv_dr
     area_inner.x2 += dsc->outline_pad;
     area_inner.y2 += dsc->outline_pad;
 
-    int32_t inner_w = lv_area_get_width(&area_inner);
-    int32_t inner_h = lv_area_get_height(&area_inner);
-
-    int32_t rin = dsc->radius;
-    int32_t short_side = LV_MATH_MIN(inner_w, inner_h);
-    if(rin > short_side >> 1) rin = short_side >> 1;
-
-    /*Get the outer area*/
-    int32_t rout = rin + dsc->outline_width;
-
     lv_area_t area_outer;
     lv_area_copy(&area_outer, &area_inner);
 
@@ -1261,165 +1173,13 @@ static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, lv_dr
     area_outer.y1 -= dsc->outline_width;
     area_outer.y2 += dsc->outline_width;
 
-    int32_t coords_out_w = lv_area_get_width(&area_outer);
-    int32_t coords_out_h = lv_area_get_height(&area_outer);
-    short_side = LV_MATH_MIN(coords_out_w, coords_out_h);
-    if(rout > short_side >> 1) rout = short_side >> 1;
-
-    lv_disp_t * disp    = _lv_refr_get_disp_refreshing();
-    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
-
-    /* Get clipped fill area which is the real draw area.
-     * It is always the same or inside `fill_area` */
-    lv_area_t draw_area;
-    bool is_common;
-    is_common = _lv_area_intersect(&draw_area, &area_outer, clip);
-    if(is_common == false) return;
-
-    const lv_area_t * disp_area = &vdb->area;
-
-    /* Now `draw_area` has absolute coordinates.
-     * Make it relative to `disp_area` to simplify draw to `disp_buf`*/
-    draw_area.x1 -= disp_area->x1;
-    draw_area.y1 -= disp_area->y1;
-    draw_area.x2 -= disp_area->x1;
-    draw_area.y2 -= disp_area->y1;
-
-    int32_t draw_area_w = lv_area_get_width(&draw_area);
-
-    /*Create inner the mask*/
-    lv_draw_mask_radius_param_t mask_rin_param;
-    lv_draw_mask_radius_init(&mask_rin_param, &area_inner, rin, true);
-    int16_t mask_rin_id = lv_draw_mask_add(&mask_rin_param, NULL);
-
-    lv_draw_mask_radius_param_t mask_rout_param;
-    lv_draw_mask_radius_init(&mask_rout_param, &area_outer, rout, false);
-    int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
-
-    lv_opa_t * mask_buf = _lv_mem_buf_get(draw_area_w);
-
-    int32_t corner_size = LV_MATH_MAX(rout, dsc->outline_width - 1);
-
-    int32_t h;
-    lv_draw_mask_res_t mask_res;
-    lv_area_t fill_area;
-
-    lv_color_t color = dsc->outline_color;
-    lv_blend_mode_t blend_mode = dsc->outline_blend_mode;
-
-    /*Apply some optimization if there is no other mask*/
-    if(simple_mode) {
-        /*Draw the upper corner area*/
-        int32_t upper_corner_end = area_outer.y1 - disp_area->y1 + corner_size;
-
-        fill_area.x1 = area_outer.x1;
-        fill_area.x2 = area_outer.x2;
-        fill_area.y1 = disp_area->y1 + draw_area.y1;
-        fill_area.y2 = fill_area.y1;
-        for(h = draw_area.y1; h <= upper_corner_end; h++) {
-            _lv_memset_ff(mask_buf, draw_area_w);
-            mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
-
-            lv_area_t fill_area2;
-            fill_area2.y1 = fill_area.y1;
-            fill_area2.y2 = fill_area.y2;
-
-            fill_area2.x1 = area_outer.x1;
-            fill_area2.x2 = area_outer.x1 + rout - 1;
-
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf, mask_res, opa, blend_mode);
-
-            /*Draw the top horizontal line*/
-            if(fill_area2.y2 < area_outer.y1 + dsc->outline_width) {
-                fill_area2.x1 = area_outer.x1 + rout;
-                fill_area2.x2 = area_outer.x2 - rout;
-
-                _lv_blend_fill(clip, &fill_area2, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-            }
-
-            fill_area2.x1 = area_outer.x2 - rout + 1;
-            fill_area2.x2 = area_outer.x2;
-
-            int32_t mask_ofs = (area_outer.x2 - rout + 1) - (vdb->area.x1 + draw_area.x1);
-            if(mask_ofs < 0) mask_ofs = 0;
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf + mask_ofs, mask_res, opa, blend_mode);
-
-            fill_area.y1++;
-            fill_area.y2++;
-        }
-
-        /*Draw the lower corner area */
-        int32_t lower_corner_end = area_outer.y2 - disp_area->y1 - corner_size;
-        if(lower_corner_end <= upper_corner_end) lower_corner_end = upper_corner_end + 1;
-        fill_area.y1 = disp_area->y1 + lower_corner_end;
-        fill_area.y2 = fill_area.y1;
-        for(h = lower_corner_end; h <= draw_area.y2; h++) {
-            _lv_memset_ff(mask_buf, draw_area_w);
-            mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
-
-            lv_area_t fill_area2;
-            fill_area2.x1 = area_outer.x1;
-            fill_area2.x2 = area_outer.x1 + rout - 1;
-            fill_area2.y1 = fill_area.y1;
-            fill_area2.y2 = fill_area.y2;
-
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf, mask_res, opa, blend_mode);
-
-            /*Draw the bottom horizontal line*/
-            if(fill_area2.y2 > area_outer.y2 - dsc->outline_width) {
-                fill_area2.x1 = area_outer.x1 + rout;
-                fill_area2.x2 = area_outer.x2 - rout;
-
-                _lv_blend_fill(clip, &fill_area2, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-            }
-            fill_area2.x1 = area_outer.x2 - rout + 1;
-            fill_area2.x2 = area_outer.x2;
-
-            int32_t mask_ofs = (area_outer.x2 - rout + 1) - (vdb->area.x1 + draw_area.x1);
-            if(mask_ofs < 0) mask_ofs = 0;
-            _lv_blend_fill(clip, &fill_area2, color, mask_buf + mask_ofs, mask_res, opa, blend_mode);
-
-
-            fill_area.y1++;
-            fill_area.y2++;
-        }
-
-        /*Draw the left vertical part*/
-        fill_area.y1 = area_outer.y1 + corner_size + 1;
-        fill_area.y2 = area_outer.y2 - corner_size - 1;
-
-        fill_area.x1 = area_outer.x1;
-        fill_area.x2 = area_outer.x1 + dsc->outline_width - 1;
-        _lv_blend_fill(clip, &fill_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-
-        /*Draw the right vertical border*/
-        fill_area.x1 = area_outer.x2 - dsc->outline_width + 1;
-        fill_area.x2 = area_outer.x2;
-
-        _lv_blend_fill(clip, &fill_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
-    }
-    /*Process line by line if there is other mask too*/
-    else {
-        fill_area.x1 = area_outer.x1;
-        fill_area.x2 = area_outer.x2;
-        fill_area.y1 = disp_area->y1 + draw_area.y1;
-        fill_area.y2 = fill_area.y1;
-
-        for(h = draw_area.y1; h <= draw_area.y2; h++) {
-            _lv_memset_ff(mask_buf, draw_area_w);
-            mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
-
-            _lv_blend_fill(clip, &fill_area, color, mask_buf, mask_res, opa, blend_mode);
-            fill_area.y1++;
-            fill_area.y2++;
-
-        }
-    }
-    lv_draw_mask_remove_id(mask_rin_id);
-    lv_draw_mask_remove_id(mask_rout_id);
-    _lv_mem_buf_release(mask_buf);
+    draw_full_border(&area_inner, &area_outer, clip, dsc->radius, dsc->outline_color, dsc->outline_opa,
+                     dsc->outline_blend_mode);
 }
+#endif
 
+
+#if LV_USE_PATTERN
 static void draw_pattern(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->pattern_image == NULL) return;
@@ -1520,9 +1280,11 @@ static void draw_pattern(const lv_area_t * coords, const lv_area_t * clip, lv_dr
         lv_draw_mask_remove_id(radius_mask_id);
     }
 }
+#endif
 
 
-static void draw_value(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc)
+#if LV_USE_VALUE_STR
+static void draw_value_str(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->value_str == NULL) return;
     if(dsc->value_opa <= LV_OPA_MIN) return;
@@ -1555,4 +1317,179 @@ static void draw_value(const lv_area_t * coords, const lv_area_t * clip, lv_draw
 
     lv_draw_label(&value_area, clip, &label_dsc, dsc->value_str, NULL);
 }
+#endif
+
+static void draw_full_border(const lv_area_t * area_inner, const lv_area_t * area_outer, const lv_area_t * clip,
+                             lv_coord_t radius, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode)
+{
+    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
+    bool simple_mode = true;
+    if(other_mask_cnt) simple_mode = false;
+
+    int32_t inner_w = lv_area_get_width(area_inner);
+    int32_t inner_h = lv_area_get_height(area_inner);
+    lv_coord_t border_width = area_outer->x2 - area_inner->x2;
+    int32_t rin = radius;
+
+    int32_t short_side = LV_MATH_MIN(inner_w, inner_h);
+    if(rin > short_side >> 1) rin = short_side >> 1;
+
+    /*Get the outer area*/
+    int32_t rout = rin + border_width;
+
+    int32_t coords_out_w = lv_area_get_width(area_outer);
+    int32_t coords_out_h = lv_area_get_height(area_outer);
+    short_side = LV_MATH_MIN(coords_out_w, coords_out_h);
+    if(rout > short_side >> 1) rout = short_side >> 1;
+
+    lv_disp_t * disp    = _lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+
+    /* Get clipped fill area which is the real draw area.
+     * It is always the same or inside `fill_area` */
+    lv_area_t draw_area;
+    bool is_common;
+    is_common = _lv_area_intersect(&draw_area, area_outer, clip);
+    if(is_common == false) return;
+
+    const lv_area_t * disp_area = &vdb->area;
+
+    /* Now `draw_area` has absolute coordinates.
+     * Make it relative to `disp_area` to simplify draw to `disp_buf`*/
+    draw_area.x1 -= disp_area->x1;
+    draw_area.y1 -= disp_area->y1;
+    draw_area.x2 -= disp_area->x1;
+    draw_area.y2 -= disp_area->y1;
+
+    int32_t draw_area_w = lv_area_get_width(&draw_area);
+
+    /*Create inner the mask*/
+    lv_draw_mask_radius_param_t mask_rin_param;
+    lv_draw_mask_radius_init(&mask_rin_param, area_inner, rin, true);
+    int16_t mask_rin_id = lv_draw_mask_add(&mask_rin_param, NULL);
+
+    lv_draw_mask_radius_param_t mask_rout_param;
+    lv_draw_mask_radius_init(&mask_rout_param, area_outer, rout, false);
+    int16_t mask_rout_id = lv_draw_mask_add(&mask_rout_param, NULL);
+
+    lv_opa_t * mask_buf = _lv_mem_buf_get(draw_area_w);
+
+    int32_t corner_size = LV_MATH_MAX(rout, border_width - 1);
+
+    int32_t h;
+    lv_draw_mask_res_t mask_res;
+    lv_area_t fill_area;
+
+    /*Apply some optimization if there is no other mask*/
+    if(simple_mode) {
+        /*Draw the upper corner area*/
+        int32_t upper_corner_end = area_outer->y1 - disp_area->y1 + corner_size;
+
+        fill_area.x1 = area_outer->x1;
+        fill_area.x2 = area_outer->x2;
+        fill_area.y1 = disp_area->y1 + draw_area.y1;
+        fill_area.y2 = fill_area.y1;
+        for(h = draw_area.y1; h <= upper_corner_end; h++) {
+            _lv_memset_ff(mask_buf, draw_area_w);
+            mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
+
+            lv_area_t fill_area2;
+            fill_area2.y1 = fill_area.y1;
+            fill_area2.y2 = fill_area.y2;
+
+            fill_area2.x1 = area_outer->x1;
+            fill_area2.x2 = area_outer->x1 + rout - 1;
+
+            _lv_blend_fill(clip, &fill_area2, color, mask_buf, mask_res, opa, blend_mode);
+
+            /*Draw the top horizontal line*/
+            if(fill_area2.y2 < area_outer->y1 + border_width) {
+                fill_area2.x1 = area_outer->x1 + rout;
+                fill_area2.x2 = area_outer->x2 - rout;
+
+                _lv_blend_fill(clip, &fill_area2, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+            }
+
+            fill_area2.x1 = area_outer->x2 - rout + 1;
+            fill_area2.x2 = area_outer->x2;
+
+            int32_t mask_ofs = (area_outer->x2 - rout + 1) - (vdb->area.x1 + draw_area.x1);
+            if(mask_ofs < 0) mask_ofs = 0;
+            _lv_blend_fill(clip, &fill_area2, color, mask_buf + mask_ofs, mask_res, opa, blend_mode);
+
+            fill_area.y1++;
+            fill_area.y2++;
+        }
+
+        /*Draw the lower corner area */
+        int32_t lower_corner_end = area_outer->y2 - disp_area->y1 - corner_size;
+        if(lower_corner_end <= upper_corner_end) lower_corner_end = upper_corner_end + 1;
+        fill_area.y1 = disp_area->y1 + lower_corner_end;
+        fill_area.y2 = fill_area.y1;
+        for(h = lower_corner_end; h <= draw_area.y2; h++) {
+            _lv_memset_ff(mask_buf, draw_area_w);
+            mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
+
+            lv_area_t fill_area2;
+            fill_area2.x1 = area_outer->x1;
+            fill_area2.x2 = area_outer->x1 + rout - 1;
+            fill_area2.y1 = fill_area.y1;
+            fill_area2.y2 = fill_area.y2;
+
+            _lv_blend_fill(clip, &fill_area2, color, mask_buf, mask_res, opa, blend_mode);
+
+            /*Draw the bottom horizontal line*/
+            if(fill_area2.y2 > area_outer->y2 - border_width) {
+                fill_area2.x1 = area_outer->x1 + rout;
+                fill_area2.x2 = area_outer->x2 - rout;
+
+                _lv_blend_fill(clip, &fill_area2, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+            }
+            fill_area2.x1 = area_outer->x2 - rout + 1;
+            fill_area2.x2 = area_outer->x2;
+
+            int32_t mask_ofs = (area_outer->x2 - rout + 1) - (vdb->area.x1 + draw_area.x1);
+            if(mask_ofs < 0) mask_ofs = 0;
+            _lv_blend_fill(clip, &fill_area2, color, mask_buf + mask_ofs, mask_res, opa, blend_mode);
+
+
+            fill_area.y1++;
+            fill_area.y2++;
+        }
+
+        /*Draw the left vertical part*/
+        fill_area.y1 = area_outer->y1 + corner_size + 1;
+        fill_area.y2 = area_outer->y2 - corner_size - 1;
+
+        fill_area.x1 = area_outer->x1;
+        fill_area.x2 = area_outer->x1 + border_width - 1;
+        _lv_blend_fill(clip, &fill_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+
+        /*Draw the right vertical border*/
+        fill_area.x1 = area_outer->x2 - border_width + 1;
+        fill_area.x2 = area_outer->x2;
+
+        _lv_blend_fill(clip, &fill_area, color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa, blend_mode);
+    }
+    /*Process line by line if there is other mask too*/
+    else {
+        fill_area.x1 = area_outer->x1;
+        fill_area.x2 = area_outer->x2;
+        fill_area.y1 = disp_area->y1 + draw_area.y1;
+        fill_area.y2 = fill_area.y1;
+
+        for(h = draw_area.y1; h <= draw_area.y2; h++) {
+            _lv_memset_ff(mask_buf, draw_area_w);
+            mask_res = lv_draw_mask_apply(mask_buf, vdb->area.x1 + draw_area.x1, vdb->area.y1 + h, draw_area_w);
+
+            _lv_blend_fill(clip, &fill_area, color, mask_buf, mask_res, opa, blend_mode);
+            fill_area.y1++;
+            fill_area.y2++;
+
+        }
+    }
+    lv_draw_mask_remove_id(mask_rin_id);
+    lv_draw_mask_remove_id(mask_rout_id);
+    _lv_mem_buf_release(mask_buf);
+}
 

src/lv_draw/lv_img_buf.c

@@ -471,6 +471,15 @@ void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t
                                       lv_point_t * pivot)
 {
 #if LV_USE_IMG_TRANSFORM
+    if(angle == 0 && zoom == LV_IMG_ZOOM_NONE) {
+        res->x1 = 0;
+        res->y1 = 0;
+        res->x2 = w - 1;
+        res->y2 = h - 1;
+        return;
+
+    }
+
     int32_t angle_low = angle / 10;
     int32_t angle_hight = angle_low + 1;
     int32_t angle_rem = angle  - (angle_low * 10);
@@ -528,8 +537,8 @@ void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t
     LV_UNUSED(pivot);
     res->x1 = 0;
     res->y1 = 0;
-    res->x2 = w;
-    res->y2 = h;
+    res->x2 = w - 1;
+    res->y2 = h - 1;
 #endif
 }
 

src/lv_draw/lv_img_buf.h

@@ -102,10 +102,26 @@ typedef uint8_t lv_img_cf_t;
 /**
  * LVGL image header
  */
+/* The first 8 bit is very important to distinguish the different source types.
+ * For more info see `lv_img_get_src_type()` in lv_img.c
+ * On big endian systems the order is reversed so cf and always_zero must be at
+ * the end of the struct.
+ * */
+#if LV_BIG_ENDIAN_SYSTEM
+typedef struct {
+
+    uint32_t h : 11; /*Height of     the image map*/
+    uint32_t w : 11; /*Width of the image map*/
+    uint32_t reserved : 2; /*Reserved to be used later*/
+    uint32_t always_zero : 3; /*It the upper bits of the first byte. Always zero to look like a
+                                 non-printable character*/
+    uint32_t cf : 5;          /* Color format: See `lv_img_color_format_t`*/
+
+
+} lv_img_header_t;
+#else
 typedef struct {
 
-    /* The first 8 bit is very important to distinguish the different source types.
-     * For more info see `lv_img_get_src_type()` in lv_img.c */
     uint32_t cf : 5;          /* Color format: See `lv_img_color_format_t`*/
     uint32_t always_zero : 3; /*It the upper bits of the first byte. Always zero to look like a
                                  non-printable character*/
@@ -115,7 +131,7 @@ typedef struct {
     uint32_t w : 11; /*Width of the image map*/
     uint32_t h : 11; /*Height of     the image map*/
 } lv_img_header_t;
-
+#endif
 
 /** Image header it is compatible with
  * the result from image converter utility*/

src/lv_draw/lv_img_decoder.c

@@ -89,6 +89,9 @@ void _lv_img_decoder_init(void)
 lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
 {
     header->always_zero = 0;
+    header->h = 0;
+    header->w = 0;
+    header->cf = LV_IMG_CF_UNKNOWN;
 
     lv_res_t res = LV_RES_INV;
     lv_img_decoder_t * d;
@@ -150,10 +153,6 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_co
         if(res == LV_RES_OK) break;
     }
 
-    if(res == LV_RES_INV) {
-        _lv_memset_00(dsc, sizeof(lv_img_decoder_dsc_t));
-    }
-
     return res;
 }
 

src/lv_font/lv_font.h

@@ -71,6 +71,10 @@ typedef struct _lv_font_struct {
     lv_coord_t line_height;         /**< The real line height where any text fits*/
     lv_coord_t base_line;           /**< Base line measured from the top of the line_height*/
     uint8_t subpx  : 2;             /**< An element of `lv_font_subpx_t`*/
+
+    int8_t underline_position;      /**< Distance between the top of the underline and base line (< 0 means below the base line)*/
+    int8_t  underline_thickness;     /**< Thickness of the underline*/
+
     void * dsc;                     /**< Store implementation specific or run_time data or caching here*/
 #if LV_USE_USER_DATA
     lv_font_user_data_t user_data;  /**< Custom user data for font. */
@@ -171,6 +175,10 @@ LV_FONT_DECLARE(lv_font_montserrat_30)
 LV_FONT_DECLARE(lv_font_montserrat_32)
 #endif
 
+#if LV_FONT_MONTSERRAT_34
+LV_FONT_DECLARE(lv_font_montserrat_34)
+#endif
+
 #if LV_FONT_MONTSERRAT_36
 LV_FONT_DECLARE(lv_font_montserrat_36)
 #endif

src/lv_font/lv_font_fmt_txt.c

@@ -37,14 +37,13 @@ static int32_t unicode_list_compare(const void * ref, const void * element);
 static int32_t kern_pair_8_compare(const void * ref, const void * element);
 static int32_t kern_pair_16_compare(const void * ref, const void * element);
 
-static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord_t h, uint8_t bpp);
+static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord_t h, uint8_t bpp, bool prefilter);
 static inline void decompress_line(uint8_t * out, lv_coord_t w);
 static inline uint8_t get_bits(const uint8_t * in, uint32_t bit_pos, uint8_t len);
 static inline void bits_write(uint8_t * out, uint32_t bit_pos, uint8_t val, uint8_t len);
 static inline void rle_init(const uint8_t * in,  uint8_t bpp);
 static inline uint8_t rle_next(void);
 
-
 /**********************
  *  STATIC VARIABLES
  **********************/
@@ -89,6 +88,7 @@ const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t unic
     }
     /*Handle compressed bitmap*/
     else {
+#if LV_USE_FONT_COMPRESSED
         uint32_t gsize = gdsc->box_w * gdsc->box_h;
         if(gsize == 0) return NULL;
 
@@ -115,8 +115,13 @@ const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t unic
             if(decompr_buf == NULL) return NULL;
         }
 
-        decompress(&fdsc->glyph_bitmap[gdsc->bitmap_index], decompr_buf, gdsc->box_w, gdsc->box_h, (uint8_t)fdsc->bpp);
+        bool prefilter = fdsc->bitmap_format == LV_FONT_FMT_TXT_COMPRESSED ? true : false;
+        decompress(&fdsc->glyph_bitmap[gdsc->bitmap_index], decompr_buf, gdsc->box_w, gdsc->box_h, (uint8_t)fdsc->bpp,
+                   prefilter);
         return decompr_buf;
+#else /* !LV_USE_FONT_COMPRESSED */
+        return NULL;
+#endif
     }
 
     /*If not returned earlier then the letter is not found in this font*/
@@ -214,7 +219,8 @@ static uint32_t get_glyph_dsc_id(const lv_font_t * font, uint32_t letter)
             glyph_id = fdsc->cmaps[i].glyph_id_start + gid_ofs_8[rcp];
         }
         else if(fdsc->cmaps[i].type == LV_FONT_FMT_TXT_CMAP_SPARSE_TINY) {
-            uint8_t * p = _lv_utils_bsearch(&rcp, fdsc->cmaps[i].unicode_list, fdsc->cmaps[i].list_length,
+            uint16_t key = rcp;
+            uint8_t * p = _lv_utils_bsearch(&key, fdsc->cmaps[i].unicode_list, fdsc->cmaps[i].list_length,
                                             sizeof(fdsc->cmaps[i].unicode_list[0]), unicode_list_compare);
 
             if(p) {
@@ -224,7 +230,8 @@ static uint32_t get_glyph_dsc_id(const lv_font_t * font, uint32_t letter)
             }
         }
         else if(fdsc->cmaps[i].type == LV_FONT_FMT_TXT_CMAP_SPARSE_FULL) {
-            uint8_t * p = _lv_utils_bsearch(&rcp, fdsc->cmaps[i].unicode_list, fdsc->cmaps[i].list_length,
+            uint16_t key = rcp;
+            uint8_t * p = _lv_utils_bsearch(&key, fdsc->cmaps[i].unicode_list, fdsc->cmaps[i].list_length,
                                             sizeof(fdsc->cmaps[i].unicode_list[0]), unicode_list_compare);
 
             if(p) {
@@ -332,8 +339,9 @@ static int32_t kern_pair_16_compare(const void * ref, const void * element)
  * @param out buffer to store the result
  * @param px_num number of pixels in the glyph (width * height)
  * @param bpp bit per pixel (bpp = 3 will be converted to bpp = 4)
+ * @param prefilter true: the lines are XORed
  */
-static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord_t h, uint8_t bpp)
+static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord_t h, uint8_t bpp, bool prefilter)
 {
     uint32_t wrp = 0;
     uint8_t wr_size = bpp;
@@ -342,7 +350,12 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord
     rle_init(in, bpp);
 
     uint8_t * line_buf1 = _lv_mem_buf_get(w);
-    uint8_t * line_buf2 = _lv_mem_buf_get(w);
+
+    uint8_t * line_buf2 = NULL;
+
+    if(prefilter) {
+        line_buf2 = _lv_mem_buf_get(w);
+    }
 
     decompress_line(line_buf1, w);
 
@@ -355,12 +368,22 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord
     }
 
     for(y = 1; y < h; y++) {
-        decompress_line(line_buf2, w);
+        if(prefilter) {
+            decompress_line(line_buf2, w);
 
-        for(x = 0; x < w; x++) {
-            line_buf1[x] = line_buf2[x] ^ line_buf1[x];
-            bits_write(out, wrp, line_buf1[x], bpp);
-            wrp += wr_size;
+            for(x = 0; x < w; x++) {
+                line_buf1[x] = line_buf2[x] ^ line_buf1[x];
+                bits_write(out, wrp, line_buf1[x], bpp);
+                wrp += wr_size;
+            }
+        }
+        else {
+            decompress_line(line_buf1, w);
+
+            for(x = 0; x < w; x++) {
+                bits_write(out, wrp, line_buf1[x], bpp);
+                wrp += wr_size;
+            }
         }
     }
 

src/lv_font/lv_font_fmt_txt.h

@@ -150,6 +150,7 @@ typedef struct {
 typedef enum {
     LV_FONT_FMT_TXT_PLAIN      = 0,
     LV_FONT_FMT_TXT_COMPRESSED = 1,
+    LV_FONT_FMT_TXT_COMPRESSED_NO_PREFILTER = 1,
 } lv_font_fmt_txt_bitmap_format_t;
 
 

src/lv_gpu/lv_gpu_stm32_dma2d.c

@@ -11,19 +11,14 @@
 
 #if LV_USE_GPU_STM32_DMA2D
 
-#if defined(STM32F4)
-    #include "stm32f4xx_hal.h"
-#elif defined(STM32F7)
-    #include "stm32f7xx_hal.h"
-#else
-    #error "Not supported STM32 family to use DMA2D"
-#endif
+#include LV_GPU_DMA2D_CMSIS_INCLUDE
 
 /*********************
  *      DEFINES
  *********************/
 
 #if LV_COLOR_16_SWAP
+    // TODO: F7 has red blue swap bit in control register for all layers and output
     #error "Can't use DMA2D with LV_COLOR_16_SWAP 1"
 #endif
 
@@ -32,11 +27,9 @@
 #endif
 
 #if LV_COLOR_DEPTH == 16
-    #define DMA2D_OUTPUT_FORMAT DMA2D_OUTPUT_RGB565
-    #define DMA2D_INPUT_FORMAT DMA2D_INPUT_RGB565
+    #define LV_DMA2D_COLOR_FORMAT LV_DMA2D_RGB565
 #elif LV_COLOR_DEPTH == 32
-    #define DMA2D_OUTPUT_FORMAT DMA2D_OUTPUT_ARGB8888
-    #define DMA2D_INPUT_FORMAT DMA2D_INPUT_ARGB8888
+    #define LV_DMA2D_COLOR_FORMAT LV_DMA2D_ARGB8888
 #else
     /*Can't use GPU with other formats*/
 #endif
@@ -54,7 +47,6 @@ static void dma2d_wait(void);
 /**********************
  *  STATIC VARIABLES
  **********************/
-static DMA2D_HandleTypeDef hdma2d;
 
 /**********************
  *      MACROS
@@ -64,6 +56,21 @@ static DMA2D_HandleTypeDef hdma2d;
  *   GLOBAL FUNCTIONS
  **********************/
 
+/**
+ * Turn on the peripheral and set output color mode, this only needs to be done once
+ */
+void lv_gpu_stm32_dma2d_init(void)
+{
+    /* Enable DMA2D clock */
+    RCC->AHB1ENR |= RCC_AHB1ENR_DMA2DEN;
+
+    /* Delay after setting peripheral clock */
+    volatile uint32_t temp = RCC->AHB1ENR;
+
+    /* set output colour mode */
+    DMA2D->OPFCCR = LV_DMA2D_COLOR_FORMAT;
+}
+
 /**
  * Fill an area in the buffer with a color
  * @param buf a buffer which should be filled
@@ -77,18 +84,16 @@ void lv_gpu_stm32_dma2d_fill(lv_color_t * buf, lv_coord_t buf_w, lv_color_t colo
 {
     invalidate_cache();
 
-    hdma2d.Instance = DMA2D;
-    hdma2d.Init.Mode = DMA2D_R2M;
-    hdma2d.Init.ColorMode = DMA2D_OUTPUT_FORMAT;
-    hdma2d.Init.OutputOffset = buf_w - fill_w;
-    hdma2d.LayerCfg[1].InputAlpha = DMA2D_NO_MODIF_ALPHA;
-    hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_FORMAT;
-    hdma2d.LayerCfg[1].InputOffset = 0;
+    DMA2D->CR = 0x30000;
+    DMA2D->OMAR = (uint32_t)buf;
+    /* as input color mode is same as output we don't need to convert here do we? */
+    DMA2D->OCOLR = color.full;
+    DMA2D->OOR = buf_w - fill_w;
+    DMA2D->NLR = (fill_w << DMA2D_NLR_PL_Pos) | (fill_h << DMA2D_NLR_NL_Pos);
+
+    /* start transfer */
+    DMA2D->CR |= DMA2D_CR_START_Msk;
 
-    /* DMA2D Initialization */
-    HAL_DMA2D_Init(&hdma2d);
-    HAL_DMA2D_ConfigLayer(&hdma2d, 1);
-    HAL_DMA2D_Start(&hdma2d, (uint32_t)lv_color_to32(color), (uint32_t)buf, fill_w, fill_h);
     dma2d_wait();
 }
 
@@ -106,6 +111,7 @@ void lv_gpu_stm32_dma2d_fill(lv_color_t * buf, lv_coord_t buf_w, lv_color_t colo
 void lv_gpu_stm32_dma2d_fill_mask(lv_color_t * buf, lv_coord_t buf_w, lv_color_t color, const lv_opa_t * mask,
                                   lv_opa_t opa, lv_coord_t fill_w, lv_coord_t fill_h)
 {
+#if 0
     invalidate_cache();
 
     /* Configure the DMA2D Mode, Color Mode and line output offset */
@@ -134,6 +140,7 @@ void lv_gpu_stm32_dma2d_fill_mask(lv_color_t * buf, lv_coord_t buf_w, lv_color_t
     HAL_DMA2D_ConfigLayer(&hdma2d, 1);
     HAL_DMA2D_BlendingStart(&hdma2d, (uint32_t) mask, (uint32_t) buf, (uint32_t)buf, fill_w, fill_h);
     dma2d_wait();
+#endif
 }
 
 /**
@@ -151,22 +158,17 @@ void lv_gpu_stm32_dma2d_copy(lv_color_t * buf, lv_coord_t buf_w, const lv_color_
 {
     invalidate_cache();
 
-    hdma2d.Instance = DMA2D;
-    hdma2d.Init.Mode = DMA2D_M2M;
-    hdma2d.Init.ColorMode = DMA2D_OUTPUT_FORMAT;
-    hdma2d.Init.OutputOffset = buf_w - copy_w;
+    DMA2D->CR = 0;
+    /* copy output colour mode, this register controls both input and output colour format */
+    DMA2D->FGPFCCR = LV_DMA2D_COLOR_FORMAT;
+    DMA2D->FGMAR = (uint32_t)map;
+    DMA2D->FGOR = map_w - copy_w;
+    DMA2D->OMAR = (uint32_t)buf;
+    DMA2D->OOR = buf_w - copy_w;
+    DMA2D->NLR = (copy_w << DMA2D_NLR_PL_Pos) | (copy_h << DMA2D_NLR_NL_Pos);
 
-    /* Foreground layer */
-    hdma2d.LayerCfg[1].AlphaMode = DMA2D_NO_MODIF_ALPHA;
-    hdma2d.LayerCfg[1].InputAlpha = 0xFF;
-    hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_FORMAT;
-    hdma2d.LayerCfg[1].InputOffset = map_w - copy_w;
-
-    /* DMA2D Initialization */
-    HAL_DMA2D_Init(&hdma2d);
-    HAL_DMA2D_ConfigLayer(&hdma2d, 0);
-    HAL_DMA2D_ConfigLayer(&hdma2d, 1);
-    HAL_DMA2D_Start(&hdma2d, (uint32_t)map, (uint32_t)buf, copy_w, copy_h);
+    /* start transfer */
+    DMA2D->CR |= DMA2D_CR_START_Msk;
     dma2d_wait();
 }
 
@@ -185,28 +187,26 @@ void lv_gpu_stm32_dma2d_blend(lv_color_t * buf, lv_coord_t buf_w, const lv_color
                               lv_coord_t map_w, lv_coord_t copy_w, lv_coord_t copy_h)
 {
     invalidate_cache();
+    DMA2D->CR = 0x20000;
 
-    hdma2d.Instance = DMA2D;
-    hdma2d.Init.Mode = DMA2D_M2M_BLEND;
-    hdma2d.Init.ColorMode = DMA2D_OUTPUT_FORMAT;
-    hdma2d.Init.OutputOffset = buf_w - copy_w;
+    DMA2D->BGPFCCR = LV_DMA2D_COLOR_FORMAT;
+    DMA2D->BGMAR = (uint32_t)buf;
+    DMA2D->BGOR = buf_w - copy_w;
 
-    /* Background layer */
-    hdma2d.LayerCfg[0].AlphaMode = DMA2D_NO_MODIF_ALPHA;
-    hdma2d.LayerCfg[0].InputColorMode = DMA2D_INPUT_FORMAT;
-    hdma2d.LayerCfg[0].InputOffset = buf_w - copy_w;
+    DMA2D->FGPFCCR = (uint32_t)LV_DMA2D_COLOR_FORMAT
+                     /* alpha mode 2, replace with foreground * alpha value */
+                     | (2 << DMA2D_FGPFCCR_AM_Pos)
+                     /* alpha value */
+                     | (opa << DMA2D_FGPFCCR_ALPHA_Pos);
+    DMA2D->FGMAR = (uint32_t)map;
+    DMA2D->FGOR = map_w - copy_w;
 
-    /* Foreground layer */
-    hdma2d.LayerCfg[1].AlphaMode = DMA2D_COMBINE_ALPHA;
-    hdma2d.LayerCfg[1].InputAlpha = opa;
-    hdma2d.LayerCfg[1].InputColorMode = DMA2D_INPUT_FORMAT;
-    hdma2d.LayerCfg[1].InputOffset = map_w - copy_w;
+    DMA2D->OMAR = (uint32_t)buf;
+    DMA2D->OOR = buf_w - copy_w;
+    DMA2D->NLR = (copy_w << DMA2D_NLR_PL_Pos) | (copy_h << DMA2D_NLR_NL_Pos);
 
-    /* DMA2D Initialization */
-    HAL_DMA2D_Init(&hdma2d);
-    HAL_DMA2D_ConfigLayer(&hdma2d, 0);
-    HAL_DMA2D_ConfigLayer(&hdma2d, 1);
-    HAL_DMA2D_BlendingStart(&hdma2d, (uint32_t)map, (uint32_t)buf, (uint32_t)buf, copy_w, copy_h);
+    /* start transfer */
+    DMA2D->CR |= DMA2D_CR_START_Msk;
     dma2d_wait();
 }
 
@@ -226,7 +226,7 @@ static void invalidate_cache(void)
 static void dma2d_wait(void)
 {
     lv_disp_t * disp = _lv_refr_get_disp_refreshing();
-    while(HAL_DMA2D_PollForTransfer(&hdma2d, 0) == HAL_TIMEOUT) {
+    while(DMA2D->CR & DMA2D_CR_START_Msk) {
         if(disp->driver.wait_cb) disp->driver.wait_cb(&disp->driver);
     }
 }

src/lv_gpu/lv_gpu_stm32_dma2d.h

@@ -20,6 +20,12 @@ extern "C" {
  *      DEFINES
  *********************/
 
+#define LV_DMA2D_ARGB8888 0
+#define LV_DMA2D_RGB888 1
+#define LV_DMA2D_RGB565 2
+#define LV_DMA2D_ARGB1555 3
+#define LV_DMA2D_ARGB4444 4
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -28,6 +34,11 @@ extern "C" {
  * GLOBAL PROTOTYPES
  **********************/
 
+/**
+ * Turn on the peripheral and set output color mode, this only needs to be done once
+ */
+void lv_gpu_stm32_dma2d_init(void);
+
 /**
  * Fill an area in the buffer with a color
  * @param buf a buffer which should be filled

src/lv_hal/lv_hal_disp.c

@@ -144,6 +144,15 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
     disp->inv_p = 0;
     disp->last_activity_time = 0;
 
+    disp->bg_color = LV_COLOR_WHITE;
+    disp->bg_img = NULL;
+#if LV_COLOR_SCREEN_TRANSP
+    disp->bg_opa = LV_OPA_TRANSP;
+#else
+    disp->bg_opa = LV_OPA_COVER;
+#endif
+
+    disp->prev_scr  = NULL;
     disp->act_scr   = lv_obj_create(NULL, NULL); /*Create a default screen on the display*/
     disp->top_layer = lv_obj_create(NULL, NULL); /*Create top layer on the display*/
     disp->sys_layer = lv_obj_create(NULL, NULL); /*Create sys layer on the display*/

src/lv_hal/lv_hal_disp.h

@@ -52,10 +52,10 @@ typedef struct {
     void * buf_act;
     uint32_t size; /*In pixel count*/
     lv_area_t area;
-    volatile int
-    flushing;      /*1: flushing is in progress. (It can't be a bitfield because when it's cleared from IRQ Read-Modify-Write issue might occur)*/
-    volatile int
-    flushing_last; /*1: It was the last chunk to flush. (It can't be a bitfield because when it's cleared from IRQ Read-Modify-Write issue might occur)*/
+    /*1: flushing is in progress. (It can't be a bit field because when it's cleared from IRQ Read-Modify-Write issue might occur)*/
+    volatile int flushing;
+    /*1: It was the last chunk to flush. (It can't be a bi tfield because when it's cleared from IRQ Read-Modify-Write issue might occur)*/
+    volatile int flushing_last;
     volatile uint32_t last_area         : 1; /*1: the last area is being rendered*/
     volatile uint32_t last_part         : 1; /*1: the last part of the current area is being rendered*/
 } lv_disp_buf_t;
@@ -146,10 +146,18 @@ typedef struct _disp_t {
 
     /** Screens of the display*/
     lv_ll_t scr_ll;
-    struct _lv_obj_t * act_scr; /**< Currently active screen on this display */
+    struct _lv_obj_t * act_scr;   /**< Currently active screen on this display */
+    struct _lv_obj_t * prev_scr;  /**< Previous screen. Used during screen animations */
     struct _lv_obj_t * top_layer; /**< @see lv_disp_get_layer_top */
     struct _lv_obj_t * sys_layer; /**< @see lv_disp_get_layer_sys */
 
+uint8_t del_prev  :
+    1;        /**< 1: Automatically delete the previous screen when the screen load animation is ready */
+
+    lv_color_t bg_color;          /**< Default display color when screens are transparent*/
+    const void * bg_img;       /**< An image source to display as wallpaper*/
+    lv_opa_t bg_opa;              /**<Opacity of the background color or wallpaper */
+
     /** Invalidated (marked to redraw) areas*/
     lv_area_t inv_areas[LV_INV_BUF_SIZE];
     uint8_t inv_area_joined[LV_INV_BUF_SIZE];

src/lv_hal/lv_hal_indev.c

@@ -143,6 +143,11 @@ bool _lv_indev_read(lv_indev_t * indev, lv_indev_data_t * data)
     else if(indev->driver.type == LV_INDEV_TYPE_KEYPAD) {
         data->key = indev->proc.types.keypad.last_key;
     }
+    /*For compatibility assume that used button was enter (encoder push) */
+    else if(indev->driver.type == LV_INDEV_TYPE_ENCODER) {
+        data->key = LV_KEY_ENTER;
+        data->enc_diff = 0;
+    }
 
     if(indev->driver.read_cb) {
         LV_LOG_TRACE("idnev read started");

src/lv_hal/lv_hal_tick.c

@@ -56,12 +56,17 @@ LV_ATTRIBUTE_TICK_INC void lv_tick_inc(uint32_t tick_period)
 uint32_t lv_tick_get(void)
 {
 #if LV_TICK_CUSTOM == 0
+
+    /* If `lv_tick_inc` is called from an interrupt while `sys_time` is read
+     * the result might be corrupted.
+     * This loop detects if `lv_tick_inc` was called while reading `sys_time`.
+     * If `tick_irq_flag` was cleared in `lv_tick_inc` try to read again
+     * until `tick_irq_flag` remains `1`. */
     uint32_t result;
     do {
         tick_irq_flag = 1;
         result        = sys_time;
-    } while(!tick_irq_flag); /*'lv_tick_inc()' clears this flag which can be in an interrupt.
-                                Continue until make a non interrupted cycle */
+    } while(!tick_irq_flag); /*Continue until see a non interrupted cycle */
 
     return result;
 #else

src/lv_misc/lv_color.h

@@ -390,7 +390,7 @@ static inline uint32_t lv_color_to32(lv_color_t color)
 {
 #if LV_COLOR_DEPTH == 1
     if(color.full == 0)
-        return 0;
+        return 0xFF000000;
     else
         return 0xFFFFFFFF;
 #elif LV_COLOR_DEPTH == 8
@@ -456,9 +456,12 @@ LV_ATTRIBUTE_FAST_MEM static inline lv_color_t lv_color_mix(lv_color_t c1, lv_co
     lv_color_t ret;
 #if LV_COLOR_DEPTH != 1
     /*LV_COLOR_DEPTH == 8, 16 or 32*/
-    LV_COLOR_SET_R(ret, LV_MATH_UDIV255((uint16_t) LV_COLOR_GET_R(c1) * mix + LV_COLOR_GET_R(c2) * (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
-    LV_COLOR_SET_G(ret, LV_MATH_UDIV255((uint16_t) LV_COLOR_GET_G(c1) * mix + LV_COLOR_GET_G(c2) * (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
-    LV_COLOR_SET_B(ret, LV_MATH_UDIV255((uint16_t) LV_COLOR_GET_B(c1) * mix + LV_COLOR_GET_B(c2) * (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
+    LV_COLOR_SET_R(ret, LV_MATH_UDIV255((uint16_t) LV_COLOR_GET_R(c1) * mix + LV_COLOR_GET_R(c2) *
+                                        (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
+    LV_COLOR_SET_G(ret, LV_MATH_UDIV255((uint16_t) LV_COLOR_GET_G(c1) * mix + LV_COLOR_GET_G(c2) *
+                                        (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
+    LV_COLOR_SET_B(ret, LV_MATH_UDIV255((uint16_t) LV_COLOR_GET_B(c1) * mix + LV_COLOR_GET_B(c2) *
+                                        (255 - mix) + LV_COLOR_MIX_ROUND_OFS));
     LV_COLOR_SET_A(ret, 0xFF);
 #else
     /*LV_COLOR_DEPTH == 1*/

src/lv_misc/lv_mem.c

@@ -86,6 +86,9 @@ typedef struct {
 
 static uint32_t zero_mem; /*Give the address of this variable if 0 byte should be allocated*/
 
+#if LV_MEM_CUSTOM == 0
+    static uint32_t mem_max_size; /*Tracks the maximum total size of memory ever used from the internal heap*/
+#endif
 
 static uint8_t mem_buf1_32[MEM_BUF_SMALL_SIZE];
 static uint8_t mem_buf2_32[MEM_BUF_SMALL_SIZE];
@@ -118,6 +121,7 @@ void _lv_mem_init(void)
     /*Allocate a large array to store the dynamically allocated data*/
     static LV_MEM_ATTR MEM_UNIT work_mem_int[LV_MEM_SIZE / sizeof(MEM_UNIT)];
     work_mem = (uint8_t *)work_mem_int;
+    mem_max_size = 0;
 #else
     work_mem = (uint8_t *)LV_MEM_ADR;
 #endif
@@ -200,7 +204,19 @@ void * lv_mem_alloc(size_t size)
     if(alloc != NULL) _lv_memset(alloc, 0xaa, size);
 #endif
 
-    if(alloc == NULL) LV_LOG_WARN("Couldn't allocate memory");
+    if(alloc == NULL) {
+        LV_LOG_WARN("Couldn't allocate memory");
+    }
+    else {
+#if LV_MEM_CUSTOM == 0
+        /* just a safety check, should always be true */
+        if((uintptr_t) alloc > (uintptr_t) work_mem) {
+            if((((uintptr_t) alloc - (uintptr_t) work_mem) + size) > mem_max_size) {
+                mem_max_size = ((uintptr_t) alloc - (uintptr_t) work_mem) + size;
+            }
+        }
+#endif
+    }
 
     return alloc;
 }
@@ -424,6 +440,7 @@ void lv_mem_monitor(lv_mem_monitor_t * mon_p)
         e = ent_get_next(e);
     }
     mon_p->total_size = LV_MEM_SIZE;
+    mon_p->max_used = mem_max_size;
     mon_p->used_pct   = 100 - (100U * mon_p->free_size) / mon_p->total_size;
     if(mon_p->free_size > 0) {
         mon_p->frag_pct   = (uint32_t)mon_p->free_biggest_size * 100U / mon_p->free_size;
@@ -569,6 +586,7 @@ void _lv_mem_buf_free_all(void)
     }
 }
 
+#if LV_MEMCPY_MEMSET_STD == 0
 /**
  * Same as `memcpy` but optimized for 4 byte operation.
  * @param dst pointer to the destination buffer
@@ -635,7 +653,6 @@ LV_ATTRIBUTE_FAST_MEM void * _lv_memcpy(void * dst, const void * src, size_t len
 
 /**
  * Same as `memset` but optimized for 4 byte operation.
- * `dst` should be word aligned else normal `memcpy` will be used
  * @param dst pointer to the destination buffer
  * @param v value to set [0..255]
  * @param len number of byte to set
@@ -690,7 +707,6 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset(void * dst, uint8_t v, size_t len)
 
 /**
  * Same as `memset(dst, 0x00, len)` but optimized for 4 byte operation.
- * `dst` should be word aligned else normal `memcpy` will be used
  * @param dst pointer to the destination buffer
  * @param len number of byte to set
  */
@@ -740,7 +756,6 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset_00(void * dst, size_t len)
 
 /**
  * Same as `memset(dst, 0xFF, len)` but optimized for 4 byte operation.
- * `dst` should be word aligned else normal `memcpy` will be used
  * @param dst pointer to the destination buffer
  * @param len number of byte to set
  */
@@ -788,6 +803,7 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset_ff(void * dst, size_t len)
     }
 }
 
+#endif /*LV_MEMCPY_MEMSET_STD*/
 
 /**********************
  *   STATIC FUNCTIONS

src/lv_misc/lv_mem.h

@@ -20,6 +20,10 @@ extern "C" {
 #include "lv_log.h"
 #include "lv_types.h"
 
+#if LV_MEMCPY_MEMSET_STD
+#include <string.h>
+#endif
+
 /*********************
  *      DEFINES
  *********************/
@@ -41,6 +45,7 @@ typedef struct {
     uint32_t free_size; /**< Size of available memory */
     uint32_t free_biggest_size;
     uint32_t used_cnt;
+    uint32_t max_used; /**< Max size of Heap memory used */
     uint8_t used_pct; /**< Percentage used */
     uint8_t frag_pct; /**< Amount of fragmentation */
 } lv_mem_monitor_t;
@@ -136,6 +141,62 @@ void _lv_mem_buf_free_all(void);
 
 //! @cond Doxygen_Suppress
 
+#if LV_MEMCPY_MEMSET_STD
+
+/**
+ * Wrapper for the standard memcpy
+ * @param dst pointer to the destination buffer
+ * @param src pointer to the source buffer
+ * @param len number of byte to copy
+ */
+static inline void * _lv_memcpy(void * dst, const void * src, size_t len)
+{
+    return memcpy(dst, src, len);
+}
+
+/**
+ * Wrapper for the standard memcpy
+ * @param dst pointer to the destination buffer
+ * @param src pointer to the source buffer
+ * @param len number of byte to copy
+ */
+static inline void * _lv_memcpy_small(void * dst, const void * src, size_t len)
+{
+    return memcpy(dst, src, len);
+}
+
+/**
+ * Wrapper for the standard memset
+ * @param dst pointer to the destination buffer
+ * @param v value to set [0..255]
+ * @param len number of byte to set
+ */
+static inline void _lv_memset(void * dst, uint8_t v, size_t len)
+{
+    memset(dst, v, len);
+}
+
+/**
+ * Wrapper for the standard memset with fixed 0x00 value
+ * @param dst pointer to the destination buffer
+ * @param len number of byte to set
+ */
+static inline void _lv_memset_00(void * dst, size_t len)
+{
+    memset(dst, 0x00, len);
+}
+
+/**
+ * Wrapper for the standard memset with fixed 0xFF value
+ * @param dst pointer to the destination buffer
+ * @param len number of byte to set
+ */
+static inline void _lv_memset_ff(void * dst, size_t len)
+{
+    memset(dst, 0xFF, len);
+}
+
+#else
 /**
  * Same as `memcpy` but optimized for 4 byte operation.
  * @param dst pointer to the destination buffer
@@ -167,7 +228,6 @@ LV_ATTRIBUTE_FAST_MEM static inline void * _lv_memcpy_small(void * dst, const vo
 
 /**
  * Same as `memset` but optimized for 4 byte operation.
- * `dst` should be word aligned else normal `memcpy` will be used
  * @param dst pointer to the destination buffer
  * @param v value to set [0..255]
  * @param len number of byte to set
@@ -176,7 +236,6 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset(void * dst, uint8_t v, size_t len);
 
 /**
  * Same as `memset(dst, 0x00, len)` but optimized for 4 byte operation.
- * `dst` should be word aligned else normal `memcpy` will be used
  * @param dst pointer to the destination buffer
  * @param len number of byte to set
  */
@@ -184,7 +243,6 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset_00(void * dst, size_t len);
 
 /**
  * Same as `memset(dst, 0xFF, len)` but optimized for 4 byte operation.
- * `dst` should be word aligned else normal `memcpy` will be used
  * @param dst pointer to the destination buffer
  * @param len number of byte to set
  */
@@ -192,6 +250,9 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset_ff(void * dst, size_t len);
 
 //! @endcond
 
+#endif
+
+
 /**********************
  *      MACROS
  **********************/

src/lv_misc/lv_task.c

@@ -378,6 +378,17 @@ uint8_t lv_task_get_idle(void)
     return idle_last;
 }
 
+/**
+ * Iterate through the tasks
+ * @param task NULL to start iteration or the previous return value to get the next task
+ * @return the next task or NULL if there is no more task
+ */
+lv_task_t * lv_task_get_next(lv_task_t * task)
+{
+    if(task == NULL) return _lv_ll_get_head(&LV_GC_ROOT(_lv_task_ll));
+    else return _lv_ll_get_next(&LV_GC_ROOT(_lv_task_ll), task);
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/

src/lv_misc/lv_task.h

@@ -165,6 +165,13 @@ void lv_task_enable(bool en);
  */
 uint8_t lv_task_get_idle(void);
 
+/**
+ * Iterate through the tasks
+ * @param task NULL to start iteration or the previous return value to get the next task
+ * @return the next task or NULL if there is no more task
+ */
+lv_task_t * lv_task_get_next(lv_task_t * task);
+
 /**********************
  *      MACROS
  **********************/

src/lv_misc/lv_txt.c

@@ -534,6 +534,7 @@ static uint32_t lv_txt_unicode_to_utf8(uint32_t letter_uni)
  */
 static uint32_t lv_txt_utf8_conv_wc(uint32_t c)
 {
+#if LV_BIG_ENDIAN_SYSTEM == 0
     /*Swap the bytes (UTF-8 is big endian, but the MCUs are little endian)*/
     if((c & 0x80) != 0) {
         uint32_t swapped;
@@ -547,7 +548,7 @@ static uint32_t lv_txt_utf8_conv_wc(uint32_t c)
         }
         c = swapped;
     }
-
+#endif
     return c;
 }
 

src/lv_themes/lv_theme.c

@@ -6,8 +6,7 @@
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_theme.h"
-#include "../lv_core/lv_obj.h"
+#include "../../lvgl.h"
 
 /*********************
  *      DEFINES
@@ -20,6 +19,8 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
+static void apply_theme(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name);
+static void clear_styles(lv_obj_t * obj, lv_theme_style_t name);
 
 /**********************
  *  STATIC VARIABLES
@@ -53,6 +54,69 @@ lv_theme_t * lv_theme_get_act(void)
     return act_theme;
 }
 
+/**
+ * Apply the active theme on an object
+ * @param obj pointer to an object
+ * @param name the name of the theme element to apply. E.g. `LV_THEME_BTN`
+ */
+void lv_theme_apply(lv_obj_t * obj, lv_theme_style_t name)
+{
+    /* Remove the existing styles from all part of the object. */
+    clear_styles(obj, name);
+
+    /*Apply the theme including the base theme(s)*/
+
+    apply_theme(act_theme, obj, name);
+}
+
+/**
+ * Copy a theme to an other or initialize a theme
+ * @param theme pointer to a theme to initialize
+ * @param copy pointer to a theme to copy
+ *             or `NULL` to initialize `theme` to empty
+ */
+void lv_theme_copy(lv_theme_t * theme, const lv_theme_t * copy)
+{
+    _lv_memset_00(theme, sizeof(lv_theme_t));
+
+    if(copy) {
+        theme->font_small = copy->font_small;
+        theme->font_normal = copy->font_normal;
+        theme->font_subtitle = copy->font_subtitle;
+        theme->font_title = copy->font_title;
+        theme->color_primary = copy->color_primary;
+        theme->color_secondary = copy->color_secondary;
+        theme->flags = copy->flags;
+        theme->base = copy->base;
+        theme->apply_cb = copy->apply_cb;
+        theme->apply_xcb = copy->apply_xcb;
+    }
+
+}
+
+/**
+ * Set a base theme for a theme.
+ * The styles from the base them will be added before the styles of the current theme.
+ * Arbitrary long chain of themes can be created by setting base themes.
+ * @param new_theme pointer to theme which base should be set
+ * @param base pointer to the base theme
+ */
+void lv_theme_set_base(lv_theme_t * new_theme, lv_theme_t * base)
+{
+    new_theme->base = base;
+}
+
+/**
+ * Set a callback for a theme.
+ * The callback is used to add styles to different objects
+ * @param theme pointer to theme which callback should be set
+ * @param cb pointer to the callback
+ */
+void lv_theme_set_apply_cb(lv_theme_t * theme, lv_theme_apply_cb_t apply_cb)
+{
+    theme->apply_cb = apply_cb;
+}
+
 /**
  * Get the small font of the theme
  * @return pointer to the font
@@ -116,12 +180,299 @@ uint32_t lv_theme_get_flags(void)
     return act_theme->flags;
 }
 
-void lv_theme_apply(lv_obj_t * obj, lv_theme_style_t name)
-{
-    act_theme->apply_xcb(obj, name);
-}
-
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
+
+static void apply_theme(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
+{
+    if(th->base) {
+        apply_theme(th->base, obj, name);
+    }
+
+    /*apply_xcb is deprecated, use apply_cb instead*/
+    if(th->apply_xcb) {
+        th->apply_xcb(obj, name);
+    }
+    else if(th->apply_cb) {
+        th->apply_cb(act_theme, obj, name);
+    }
+}
+
+static void clear_styles(lv_obj_t * obj, lv_theme_style_t name)
+{
+    switch(name) {
+        case LV_THEME_NONE:
+            break;
+
+        case LV_THEME_SCR:
+            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
+            break;
+        case LV_THEME_OBJ:
+            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
+            break;
+#if LV_USE_CONT
+        case LV_THEME_CONT:
+            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_BTN
+        case LV_THEME_BTN:
+            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_BTNMATRIX
+        case LV_THEME_BTNMATRIX:
+            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BG);
+            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BTN);
+            break;
+#endif
+
+#if LV_USE_KEYBOARD
+        case LV_THEME_KEYBOARD:
+            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BG);
+            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BTN);
+            break;
+#endif
+
+#if LV_USE_BAR
+        case LV_THEME_BAR:
+            lv_obj_clean_style_list(obj, LV_BAR_PART_BG);
+            lv_obj_clean_style_list(obj, LV_BAR_PART_INDIC);
+            break;
+#endif
+
+#if LV_USE_SWITCH
+        case LV_THEME_SWITCH:
+            lv_obj_clean_style_list(obj, LV_SWITCH_PART_BG);
+            lv_obj_clean_style_list(obj, LV_SWITCH_PART_INDIC);
+            lv_obj_clean_style_list(obj, LV_SWITCH_PART_KNOB);
+            break;
+#endif
+
+#if LV_USE_CANVAS
+        case LV_THEME_CANVAS:
+            lv_obj_clean_style_list(obj, LV_CANVAS_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_IMG
+        case LV_THEME_IMAGE:
+            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_IMGBTN
+        case LV_THEME_IMGBTN:
+            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_LABEL
+        case LV_THEME_LABEL:
+            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_LINE
+        case LV_THEME_LINE:
+            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_ARC
+        case LV_THEME_ARC:
+            lv_obj_clean_style_list(obj, LV_ARC_PART_BG);
+            lv_obj_clean_style_list(obj, LV_ARC_PART_INDIC);
+            break;
+#endif
+
+#if LV_USE_SPINNER
+        case LV_THEME_SPINNER:
+            lv_obj_clean_style_list(obj, LV_SPINNER_PART_BG);
+            lv_obj_clean_style_list(obj, LV_SPINNER_PART_INDIC);
+            break;
+#endif
+
+#if LV_USE_SLIDER
+        case LV_THEME_SLIDER:
+            lv_obj_clean_style_list(obj, LV_SLIDER_PART_BG);
+            lv_obj_clean_style_list(obj, LV_SLIDER_PART_INDIC);
+            lv_obj_clean_style_list(obj, LV_SLIDER_PART_KNOB);
+            break;
+#endif
+
+#if LV_USE_CHECKBOX
+        case LV_THEME_CHECKBOX:
+            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BG);
+            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BULLET);
+            break;
+#endif
+
+#if LV_USE_MSGBOX
+        case LV_THEME_MSGBOX:
+            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BG);
+            break;
+
+        case LV_THEME_MSGBOX_BTNS:
+            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN_BG);
+            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN);
+            break;
+
+#endif
+#if LV_USE_LED
+        case LV_THEME_LED:
+            lv_obj_clean_style_list(obj, LV_LED_PART_MAIN);
+            break;
+#endif
+#if LV_USE_PAGE
+        case LV_THEME_PAGE:
+            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
+            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLBAR);
+            break;
+#endif
+#if LV_USE_TABVIEW
+        case LV_THEME_TABVIEW:
+            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG);
+            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
+            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BG);
+            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_INDIC);
+            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
+            break;
+
+        case LV_THEME_TABVIEW_PAGE:
+            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
+            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
+            break;
+#endif
+
+#if LV_USE_TILEVIEW
+        case LV_THEME_TILEVIEW:
+            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_BG);
+            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
+            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
+            break;
+#endif
+
+
+#if LV_USE_ROLLER
+        case LV_THEME_ROLLER:
+            lv_obj_clean_style_list(obj, LV_ROLLER_PART_BG);
+            lv_obj_clean_style_list(obj, LV_ROLLER_PART_SELECTED);
+            break;
+#endif
+
+
+#if LV_USE_OBJMASK
+        case LV_THEME_OBJMASK:
+            lv_obj_clean_style_list(obj, LV_OBJMASK_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_LIST
+        case LV_THEME_LIST:
+            lv_obj_clean_style_list(obj, LV_LIST_PART_BG);
+            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLABLE);
+            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLBAR);
+            break;
+
+        case LV_THEME_LIST_BTN:
+            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_DROPDOWN
+        case LV_THEME_DROPDOWN:
+            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_MAIN);
+            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_LIST);
+            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
+            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SELECTED);
+            break;
+#endif
+
+#if LV_USE_CHART
+        case LV_THEME_CHART:
+            lv_obj_clean_style_list(obj, LV_CHART_PART_BG);
+            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES_BG);
+            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES);
+            break;
+#endif
+#if LV_USE_TABLE
+        case LV_THEME_TABLE:
+            lv_obj_clean_style_list(obj, LV_TABLE_PART_BG);
+            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL1);
+            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL2);
+            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL3);
+            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL4);
+            break;
+#endif
+
+#if LV_USE_WIN
+        case LV_THEME_WIN:
+            lv_obj_clean_style_list(obj, LV_WIN_PART_BG);
+            lv_obj_clean_style_list(obj, LV_WIN_PART_SCROLLBAR);
+            lv_obj_clean_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
+            lv_obj_clean_style_list(obj, LV_WIN_PART_HEADER);
+            break;
+
+        case LV_THEME_WIN_BTN:
+            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_TEXTAREA
+        case LV_THEME_TEXTAREA:
+            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_BG);
+            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
+            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_CURSOR);
+            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
+            break;
+#endif
+
+
+#if LV_USE_SPINBOX
+        case LV_THEME_SPINBOX:
+            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_BG);
+            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_CURSOR);
+            break;
+
+        case LV_THEME_SPINBOX_BTN:
+            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
+            break;
+#endif
+
+#if LV_USE_CALENDAR
+        case LV_THEME_CALENDAR:
+            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_BG);
+            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DATE);
+            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_HEADER);
+            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
+            break;
+#endif
+#if LV_USE_CPICKER
+        case LV_THEME_CPICKER:
+            lv_obj_clean_style_list(obj, LV_CPICKER_PART_MAIN);
+            lv_obj_clean_style_list(obj, LV_CPICKER_PART_KNOB);
+            break;
+#endif
+
+#if LV_USE_LINEMETER
+        case LV_THEME_LINEMETER:
+            lv_obj_clean_style_list(obj, LV_LINEMETER_PART_MAIN);
+            break;
+#endif
+#if LV_USE_GAUGE
+        case LV_THEME_GAUGE:
+            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAIN);
+            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAJOR);
+            lv_obj_clean_style_list(obj, LV_GAUGE_PART_NEEDLE);
+            break;
+#endif
+        default:
+            break;
+    }
+
+}

src/lv_themes/lv_theme.h

@@ -114,7 +114,7 @@ typedef enum {
 #endif
 #if LV_USE_SPINBOX
     LV_THEME_SPINBOX,
-    LV_THEME_SPINBOX_BTN,   /*Button extra for spinbox*/
+    LV_THEME_SPINBOX_BTN,   /*Control button for the spinbox*/
 #endif
 #if LV_USE_SPINNER
     LV_THEME_SPINNER,
@@ -141,13 +141,20 @@ typedef enum {
 #endif
 
     _LV_THEME_BUILTIN_LAST,
-    _LV_THEME_CUSTOM_START = _LV_THEME_BUILTIN_LAST,
+    LV_THEME_CUSTOM_START = _LV_THEME_BUILTIN_LAST,
     _LV_THEME_CUSTOM_LAST = 0xFFFF,
 
 } lv_theme_style_t;
 
-typedef struct {
-    void (*apply_xcb)(lv_obj_t *, lv_theme_style_t);
+struct _lv_theme_t;
+
+typedef void (*lv_theme_apply_cb_t)(struct _lv_theme_t *, lv_obj_t *, lv_theme_style_t);
+typedef void (*lv_theme_apply_xcb_t)(lv_obj_t *, lv_theme_style_t); /*Deprecated: use `apply_cb` instead*/
+
+typedef struct _lv_theme_t {
+    lv_theme_apply_cb_t apply_cb;
+    lv_theme_apply_xcb_t apply_xcb; /*Deprecated: use `apply_cb` instead*/
+    struct _lv_theme_t * base;    /**< Apply the current theme's style on top of this theme.*/
     lv_color_t color_primary;
     lv_color_t color_secondary;
     const lv_font_t * font_small;
@@ -155,6 +162,7 @@ typedef struct {
     const lv_font_t * font_subtitle;
     const lv_font_t * font_title;
     uint32_t flags;
+    void * user_data;
 } lv_theme_t;
 
 /**********************
@@ -174,9 +182,37 @@ void lv_theme_set_act(lv_theme_t * th);
  */
 lv_theme_t * lv_theme_get_act(void);
 
-
+/**
+ * Apply the active theme on an object
+ * @param obj pointer to an object
+ * @param name the name of the theme element to apply. E.g. `LV_THEME_BTN`
+ */
 void lv_theme_apply(lv_obj_t * obj, lv_theme_style_t name);
 
+/**
+ * Copy a theme to an other or initialize a theme
+ * @param theme pointer to a theme to initialize
+ * @param copy pointer to a theme to copy
+ *             or `NULL` to initialize `theme` to empty
+ */
+void lv_theme_copy(lv_theme_t * theme, const lv_theme_t * copy);
+
+/**
+ * Set a base theme for a theme.
+ * The styles from the base them will be added before the styles of the current theme.
+ * Arbitrary long chain of themes can be created by setting base themes.
+ * @param new_theme pointer to theme which base should be set
+ * @param base pointer to the base theme
+ */
+void lv_theme_set_base(lv_theme_t * new_theme, lv_theme_t * base);
+
+/**
+ * Set an apply callback for a theme.
+ * The apply callback is used to add styles to different objects
+ * @param theme pointer to theme which callback should be set
+ * @param apply_cb pointer to the callback
+ */
+void lv_theme_set_apply_cb(lv_theme_t * theme, lv_theme_apply_cb_t apply_cb);
 
 /**
  * Get the small font of the theme
@@ -220,7 +256,6 @@ lv_color_t lv_theme_get_color_secondary(void);
  */
 uint32_t lv_theme_get_flags(void);
 
-
 /**********************
  *    MACROS
  **********************/

src/lv_themes/lv_theme_empty.c

@@ -26,12 +26,12 @@
  **********************/
 typedef struct {
     lv_style_t opa_cover;
-}theme_styles_t;
+} theme_styles_t;
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void theme_apply(lv_obj_t * obj, lv_theme_style_t name);
+static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name);
 static void style_init_reset(lv_style_t * style);
 
 /**********************
@@ -89,13 +89,15 @@ lv_theme_t * lv_theme_empty_init(lv_color_t color_primary, lv_color_t color_seco
     style_init_reset(&styles->opa_cover);
     lv_style_set_bg_opa(&styles->opa_cover, LV_STATE_DEFAULT, LV_OPA_COVER);
 
-    theme.apply_xcb = theme_apply;
+    theme.apply_xcb = NULL;
+    theme.apply_cb = theme_apply;
     return &theme;
 }
 
 
-void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
+void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 {
+    LV_UNUSED(th);
     if(name == LV_THEME_SCR) {
         lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
         lv_obj_add_style(obj, LV_OBJ_PART_MAIN, &styles->opa_cover);

src/lv_themes/lv_theme_material.c

@@ -64,8 +64,9 @@
 #define COLOR_BG_SEC_TEXT       (IS_LIGHT ? lv_color_hex(0x31404f) : lv_color_hex(0xa5a8ad))
 #define COLOR_BG_SEC_TEXT_DIS   (IS_LIGHT ? lv_color_hex(0xaaaaaa) : lv_color_hex(0xa5a8ad))
 
-#define TRANSITION_TIME         150
+#define TRANSITION_TIME         ((theme.flags & LV_THEME_MATERIAL_FLAG_NO_TRANSITION) ? 0 : 150)
 #define BORDER_WIDTH            LV_DPX(2)
+#define OUTLINE_WIDTH           ((theme.flags & LV_THEME_MATERIAL_FLAG_NO_FOCUS) ? 0 : LV_DPX(2))
 #define IS_LIGHT (theme.flags & LV_THEME_MATERIAL_FLAG_LIGHT)
 
 #define PAD_DEF (lv_disp_get_size_category(NULL) <= LV_DISP_SIZE_MEDIUM ? LV_DPX(15) : (LV_DPX(30)))
@@ -73,8 +74,7 @@
 /**********************
  *      TYPEDEFS
  **********************/
-typedef struct
-{
+typedef struct {
     lv_style_t scr;
     lv_style_t bg;
     lv_style_t bg_click;
@@ -83,101 +83,101 @@ typedef struct
     lv_style_t pad_inner;
     lv_style_t pad_small;
 
-    #if LV_USE_ARC
-        lv_style_t arc_indic;
-        lv_style_t arc_bg;
-    #endif
+#if LV_USE_ARC
+    lv_style_t arc_indic;
+    lv_style_t arc_bg;
+#endif
 
-    #if LV_USE_BAR
-        lv_style_t bar_bg;
-        lv_style_t bar_indic;
-    #endif
+#if LV_USE_BAR
+    lv_style_t bar_bg;
+    lv_style_t bar_indic;
+#endif
 
-    #if LV_USE_CALENDAR
-        lv_style_t calendar_date_nums, calendar_header, calendar_daynames;
-    #endif
+#if LV_USE_CALENDAR
+    lv_style_t calendar_date_nums, calendar_header, calendar_daynames;
+#endif
 
-    #if LV_USE_CPICKER
-        lv_style_t cpicker_bg, cpicker_indic;
-    #endif
+#if LV_USE_CPICKER
+    lv_style_t cpicker_bg, cpicker_indic;
+#endif
 
-    #if LV_USE_CHART
-        lv_style_t chart_bg, chart_series_bg, chart_series;
-    #endif
+#if LV_USE_CHART
+    lv_style_t chart_bg, chart_series_bg, chart_series;
+#endif
 
-    #if LV_USE_CHECKBOX
-        lv_style_t cb_bg, cb_bullet;
-    #endif
+#if LV_USE_CHECKBOX
+    lv_style_t cb_bg, cb_bullet;
+#endif
 
-    #if LV_USE_DROPDOWN
-        lv_style_t ddlist_page, ddlist_sel;
-    #endif
+#if LV_USE_DROPDOWN
+    lv_style_t ddlist_page, ddlist_sel;
+#endif
 
-    #if LV_USE_GAUGE
-        lv_style_t gauge_main, gauge_strong, gauge_needle;
-    #endif
+#if LV_USE_GAUGE
+    lv_style_t gauge_main, gauge_strong, gauge_needle;
+#endif
 
-    #if LV_USE_KEYBOARD
-        lv_style_t kb_bg;
-    #endif
+#if LV_USE_KEYBOARD
+    lv_style_t kb_bg;
+#endif
 
-    #if LV_USE_LED
-        lv_style_t led;
-    #endif
+#if LV_USE_LED
+    lv_style_t led;
+#endif
 
-    #if LV_USE_LINEMETER
-        lv_style_t lmeter;
-    #endif
+#if LV_USE_LINEMETER
+    lv_style_t lmeter;
+#endif
 
-    #if LV_USE_LIST
-        lv_style_t list_bg, list_btn;
-    #endif
+#if LV_USE_LIST
+    lv_style_t list_bg, list_btn;
+#endif
 
-    #if LV_USE_MSGBOX
-        lv_style_t mbox_bg;
-    #endif
+#if LV_USE_MSGBOX
+    lv_style_t mbox_bg;
+#endif
 
-    #if LV_USE_PAGE
-        lv_style_t sb;
-        #if LV_USE_ANIMATION
-            lv_style_t edge_flash;
-        #endif
-    #endif
+#if LV_USE_PAGE
+    lv_style_t sb;
+#if LV_USE_ANIMATION
+    lv_style_t edge_flash;
+#endif
+#endif
 
-    #if LV_USE_ROLLER
-        lv_style_t roller_bg, roller_sel;
-    #endif
+#if LV_USE_ROLLER
+    lv_style_t roller_bg, roller_sel;
+#endif
 
-    #if LV_USE_SLIDER
-        lv_style_t slider_knob, slider_bg;
-    #endif
+#if LV_USE_SLIDER
+    lv_style_t slider_knob, slider_bg;
+#endif
 
-    #if LV_USE_SPINBOX
-        lv_style_t spinbox_cursor;
-    #endif
+#if LV_USE_SPINBOX
+    lv_style_t spinbox_cursor;
+#endif
 
-    #if LV_USE_SWITCH
-        lv_style_t sw_knob;
-    #endif
+#if LV_USE_SWITCH
+    lv_style_t sw_knob;
+#endif
 
-    #if LV_USE_TABLE
-        lv_style_t table_cell;
-    #endif
+#if LV_USE_TABLE
+    lv_style_t table_cell;
+#endif
 
-    #if LV_USE_TABVIEW || LV_USE_WIN
-        lv_style_t tabview_btns, tabview_btns_bg, tabview_indic, tabview_page_scrl;
-    #endif
+#if LV_USE_TABVIEW || LV_USE_WIN
+    lv_style_t tabview_btns, tabview_btns_bg, tabview_indic, tabview_page_scrl;
+#endif
 
-    #if LV_USE_TEXTAREA
-        lv_style_t ta_cursor, ta_placeholder;
-    #endif
+#if LV_USE_TEXTAREA
+    lv_style_t ta_cursor, ta_placeholder;
+#endif
 
-}theme_styles_t;
+} theme_styles_t;
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void theme_apply(lv_obj_t * obj, lv_theme_style_t name);
+static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name);
 static void style_init_reset(lv_style_t * style);
 
 /**********************
@@ -211,7 +211,8 @@ static void basic_init(void)
     lv_style_set_bg_opa(&styles->bg, LV_STATE_DEFAULT, LV_OPA_COVER);
     lv_style_set_bg_color(&styles->bg, LV_STATE_DEFAULT, COLOR_BG);
     lv_style_set_border_color(&styles->bg, LV_STATE_DEFAULT, COLOR_BG_BORDER);
-    lv_style_set_border_color(&styles->bg, LV_STATE_FOCUSED, theme.color_primary);
+    if((theme.flags & LV_THEME_MATERIAL_FLAG_NO_FOCUS) == 0)lv_style_set_border_color(&styles->bg, LV_STATE_FOCUSED,
+                                                                                          theme.color_primary);
     lv_style_set_border_color(&styles->bg, LV_STATE_EDITED, theme.color_secondary);
     lv_style_set_border_width(&styles->bg, LV_STATE_DEFAULT, BORDER_WIDTH);
     lv_style_set_border_post(&styles->bg, LV_STATE_DEFAULT, true);
@@ -246,7 +247,7 @@ static void basic_init(void)
     lv_style_set_bg_color(&styles->bg_click, LV_STATE_DISABLED, COLOR_BG_DIS);
     lv_style_set_border_width(&styles->bg_click, LV_STATE_CHECKED, 0);
     lv_style_set_border_color(&styles->bg_click, LV_STATE_FOCUSED | LV_STATE_PRESSED, lv_color_darken(theme.color_primary,
-                                                                                              LV_OPA_20));
+                                                                                                      LV_OPA_20));
     lv_style_set_border_color(&styles->bg_click, LV_STATE_PRESSED, COLOR_BG_BORDER_PR);
     lv_style_set_border_color(&styles->bg_click, LV_STATE_CHECKED, COLOR_BG_BORDER_CHK);
     lv_style_set_border_color(&styles->bg_click, LV_STATE_PRESSED | LV_STATE_CHECKED, COLOR_BG_BORDER_CHK_PR);
@@ -299,7 +300,7 @@ static void basic_init(void)
     lv_style_set_pad_top(&styles->btn, LV_STATE_DEFAULT, LV_DPX(15));
     lv_style_set_pad_bottom(&styles->btn, LV_STATE_DEFAULT, LV_DPX(15));
     lv_style_set_pad_inner(&styles->btn, LV_STATE_DEFAULT, LV_DPX(20));
-    lv_style_set_outline_width(&styles->btn, LV_STATE_DEFAULT, 3);
+    lv_style_set_outline_width(&styles->btn, LV_STATE_DEFAULT, OUTLINE_WIDTH);
     lv_style_set_outline_opa(&styles->btn, LV_STATE_DEFAULT, LV_OPA_0);
     lv_style_set_outline_opa(&styles->btn, LV_STATE_FOCUSED, LV_OPA_50);
     lv_style_set_outline_color(&styles->btn, LV_STATE_DEFAULT, theme.color_primary);
@@ -358,7 +359,7 @@ static void bar_init(void)
     lv_style_set_outline_color(&styles->bar_bg, LV_STATE_EDITED, theme.color_secondary);
     lv_style_set_outline_opa(&styles->bar_bg, LV_STATE_DEFAULT, LV_OPA_TRANSP);
     lv_style_set_outline_opa(&styles->bar_bg, LV_STATE_FOCUSED, LV_OPA_50);
-    lv_style_set_outline_width(&styles->bar_bg, LV_STATE_DEFAULT, 3);
+    lv_style_set_outline_width(&styles->bar_bg, LV_STATE_DEFAULT, OUTLINE_WIDTH);
     lv_style_set_transition_time(&styles->bar_bg, LV_STATE_DEFAULT, TRANSITION_TIME);
     lv_style_set_transition_prop_6(&styles->bar_bg, LV_STATE_DEFAULT, LV_STYLE_OUTLINE_OPA);
 
@@ -546,21 +547,24 @@ static void calendar_init(void)
     lv_style_set_text_color(&styles->calendar_header, LV_STATE_PRESSED, IS_LIGHT ? lv_color_hex(0x888888) : LV_COLOR_WHITE);
 
     style_init_reset(&styles->calendar_daynames);
-    lv_style_set_text_color(&styles->calendar_daynames, LV_STATE_DEFAULT, IS_LIGHT ? lv_color_hex(0x31404f) : lv_color_hex3(0xeee));
+    lv_style_set_text_color(&styles->calendar_daynames, LV_STATE_DEFAULT,
+                            IS_LIGHT ? lv_color_hex(0x31404f) : lv_color_hex3(0xeee));
     lv_style_set_pad_left(&styles->calendar_daynames, LV_STATE_DEFAULT, PAD_DEF);
     lv_style_set_pad_right(&styles->calendar_daynames, LV_STATE_DEFAULT, PAD_DEF);
     lv_style_set_pad_bottom(&styles->calendar_daynames, LV_STATE_DEFAULT, PAD_DEF);
 
     style_init_reset(&styles->calendar_date_nums);
     lv_style_set_radius(&styles->calendar_date_nums, LV_STATE_DEFAULT, LV_DPX(4));
-    lv_style_set_text_color(&styles->calendar_date_nums, LV_STATE_CHECKED, IS_LIGHT ? lv_color_hex(0x31404f) : LV_COLOR_WHITE);
+    lv_style_set_text_color(&styles->calendar_date_nums, LV_STATE_CHECKED,
+                            IS_LIGHT ? lv_color_hex(0x31404f) : LV_COLOR_WHITE);
 
     lv_style_set_bg_opa(&styles->calendar_date_nums, LV_STATE_CHECKED, IS_LIGHT ? LV_OPA_20 : LV_OPA_40);
     lv_style_set_bg_opa(&styles->calendar_date_nums, LV_STATE_PRESSED, LV_OPA_20);
     lv_style_set_bg_opa(&styles->calendar_date_nums, LV_STATE_FOCUSED, LV_OPA_COVER);
     lv_style_set_text_color(&styles->calendar_date_nums, LV_STATE_FOCUSED, LV_COLOR_WHITE);
     lv_style_set_bg_color(&styles->calendar_date_nums, LV_STATE_FOCUSED, theme.color_primary);
-    lv_style_set_bg_color(&styles->calendar_date_nums, LV_STATE_DEFAULT, IS_LIGHT ? lv_color_hex(0x666666) : LV_COLOR_WHITE);
+    lv_style_set_bg_color(&styles->calendar_date_nums, LV_STATE_DEFAULT,
+                          IS_LIGHT ? lv_color_hex(0x666666) : LV_COLOR_WHITE);
     lv_style_set_bg_color(&styles->calendar_date_nums, LV_STATE_CHECKED, theme.color_primary);
     lv_style_set_border_width(&styles->calendar_date_nums, LV_STATE_CHECKED, 2);
     lv_style_set_border_side(&styles->calendar_date_nums, LV_STATE_CHECKED, LV_BORDER_SIDE_LEFT);
@@ -606,7 +610,7 @@ static void checkbox_init(void)
     lv_style_set_outline_color(&styles->cb_bg, LV_STATE_DEFAULT, theme.color_primary);
     lv_style_set_outline_opa(&styles->cb_bg, LV_STATE_DEFAULT, LV_OPA_TRANSP);
     lv_style_set_outline_opa(&styles->cb_bg, LV_STATE_FOCUSED, LV_OPA_50);
-    lv_style_set_outline_width(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(3));
+    lv_style_set_outline_width(&styles->cb_bg, LV_STATE_DEFAULT, OUTLINE_WIDTH);
     lv_style_set_outline_pad(&styles->cb_bg, LV_STATE_DEFAULT, LV_DPX(10));
     lv_style_set_transition_time(&styles->cb_bg, LV_STATE_DEFAULT, TRANSITION_TIME);
     lv_style_set_transition_prop_6(&styles->cb_bg, LV_STATE_DEFAULT, LV_STYLE_OUTLINE_OPA);
@@ -684,7 +688,8 @@ static void textarea_init(void)
     lv_style_set_border_side(&styles->ta_cursor, LV_STATE_DEFAULT, LV_BORDER_SIDE_LEFT);
 
     style_init_reset(&styles->ta_placeholder);
-    lv_style_set_text_color(&styles->ta_placeholder, LV_STATE_DEFAULT, IS_LIGHT ? COLOR_BG_TEXT_DIS : lv_color_hex(0xa1adbd));
+    lv_style_set_text_color(&styles->ta_placeholder, LV_STATE_DEFAULT,
+                            IS_LIGHT ? COLOR_BG_TEXT_DIS : lv_color_hex(0xa1adbd));
 #endif
 }
 
@@ -735,7 +740,7 @@ static void list_init(void)
     lv_style_set_border_width(&styles->list_btn, LV_STATE_DEFAULT, 1);
 
     lv_style_set_outline_color(&styles->list_btn, LV_STATE_FOCUSED, theme.color_secondary);
-    lv_style_set_outline_width(&styles->list_btn, LV_STATE_FOCUSED, BORDER_WIDTH);
+    lv_style_set_outline_width(&styles->list_btn, LV_STATE_FOCUSED, OUTLINE_WIDTH);
     lv_style_set_outline_pad(&styles->list_btn, LV_STATE_FOCUSED, -BORDER_WIDTH);
 
     lv_style_set_pad_left(&styles->list_btn, LV_STATE_DEFAULT, PAD_DEF);
@@ -789,6 +794,39 @@ static void roller_init(void)
 static void tabview_init(void)
 {
 #if LV_USE_TABVIEW != 0
+#endif
+}
+
+static void tileview_init(void)
+{
+#if LV_USE_TILEVIEW != 0
+#endif
+}
+
+static void table_init(void)
+{
+#if LV_USE_TABLE != 0
+    style_init_reset(&styles->table_cell);
+    lv_style_set_border_color(&styles->table_cell, LV_STATE_DEFAULT, COLOR_BG_BORDER);
+    lv_style_set_border_width(&styles->table_cell, LV_STATE_DEFAULT, 1);
+    lv_style_set_border_side(&styles->table_cell, LV_STATE_DEFAULT, LV_BORDER_SIDE_TOP | LV_BORDER_SIDE_BOTTOM);
+    lv_style_set_pad_left(&styles->table_cell, LV_STATE_DEFAULT, PAD_DEF);
+    lv_style_set_pad_right(&styles->table_cell, LV_STATE_DEFAULT, PAD_DEF);
+    lv_style_set_pad_top(&styles->table_cell, LV_STATE_DEFAULT, PAD_DEF);
+    lv_style_set_pad_bottom(&styles->table_cell, LV_STATE_DEFAULT, PAD_DEF);
+
+#endif
+}
+
+static void win_init(void)
+{
+#if LV_USE_WIN != 0
+#endif
+}
+
+static void tabview_win_shared_init(void)
+{
+#if LV_USE_TABVIEW || LV_USE_WIN
     style_init_reset(&styles->tabview_btns_bg);
     lv_style_set_bg_opa(&styles->tabview_btns_bg, LV_STATE_DEFAULT, LV_OPA_COVER);
     lv_style_set_bg_color(&styles->tabview_btns_bg, LV_STATE_DEFAULT, COLOR_BG);
@@ -828,34 +866,6 @@ static void tabview_init(void)
 #endif
 }
 
-static void tileview_init(void)
-{
-#if LV_USE_TILEVIEW != 0
-#endif
-}
-
-static void table_init(void)
-{
-#if LV_USE_TABLE != 0
-    style_init_reset(&styles->table_cell);
-    lv_style_set_border_color(&styles->table_cell, LV_STATE_DEFAULT, COLOR_BG_BORDER);
-    lv_style_set_border_width(&styles->table_cell, LV_STATE_DEFAULT, 1);
-    lv_style_set_border_side(&styles->table_cell, LV_STATE_DEFAULT, LV_BORDER_SIDE_TOP | LV_BORDER_SIDE_BOTTOM);
-    lv_style_set_pad_left(&styles->table_cell, LV_STATE_DEFAULT, PAD_DEF);
-    lv_style_set_pad_right(&styles->table_cell, LV_STATE_DEFAULT, PAD_DEF);
-    lv_style_set_pad_top(&styles->table_cell, LV_STATE_DEFAULT, PAD_DEF);
-    lv_style_set_pad_bottom(&styles->table_cell, LV_STATE_DEFAULT, PAD_DEF);
-
-#endif
-}
-
-static void win_init(void)
-{
-#if LV_USE_WIN != 0
-
-#endif
-}
-
 
 /**********************
  *   GLOBAL FUNCTIONS
@@ -924,8 +934,10 @@ lv_theme_t * lv_theme_material_init(lv_color_t color_primary, lv_color_t color_s
     tileview_init();
     table_init();
     win_init();
+    tabview_win_shared_init();
 
-    theme.apply_xcb = theme_apply;
+    theme.apply_xcb = NULL;
+    theme.apply_cb = theme_apply;
 
     inited = true;
 
@@ -935,8 +947,10 @@ lv_theme_t * lv_theme_material_init(lv_color_t color_primary, lv_color_t color_s
 }
 
 
-static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
+static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 {
+    LV_UNUSED(th);
+
     lv_style_list_t * list;
 
     switch(name) {
@@ -944,18 +958,15 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
             break;
 
         case LV_THEME_SCR:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->scr);
             break;
         case LV_THEME_OBJ:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #if LV_USE_CONT
         case LV_THEME_CONT:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
@@ -963,7 +974,6 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -971,12 +981,10 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
@@ -985,12 +993,10 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_KEYBOARD
         case LV_THEME_KEYBOARD:
-            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BG);
             list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
             _lv_style_list_add_style(list, &styles->kb_bg);
 
-            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
@@ -999,11 +1005,9 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            lv_obj_clean_style_list(obj, LV_BAR_PART_BG);
             list = lv_obj_get_style_list(obj, LV_BAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bar_bg);
 
-            lv_obj_clean_style_list(obj, LV_BAR_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bar_indic);
             break;
@@ -1011,15 +1015,12 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
             _lv_style_list_add_style(list, &styles->bar_bg);
 
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bar_indic);
 
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
             _lv_style_list_add_style(list, &styles->sw_knob);
             break;
@@ -1027,42 +1028,35 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CANVAS
         case LV_THEME_CANVAS:
-            lv_obj_clean_style_list(obj, LV_CANVAS_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMG
         case LV_THEME_IMAGE:
-            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMGBTN
         case LV_THEME_IMGBTN:
-            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LABEL
         case LV_THEME_LABEL:
-            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LINE
         case LV_THEME_LINE:
-            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_ARC
         case LV_THEME_ARC:
-            lv_obj_clean_style_list(obj, LV_ARC_PART_BG);
             list = lv_obj_get_style_list(obj, LV_ARC_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->arc_bg);
 
-            lv_obj_clean_style_list(obj, LV_ARC_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
             _lv_style_list_add_style(list, &styles->arc_indic);
             break;
@@ -1070,11 +1064,9 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINNER
         case LV_THEME_SPINNER:
-            lv_obj_clean_style_list(obj, LV_SPINNER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
             _lv_style_list_add_style(list, &styles->arc_bg);
 
-            lv_obj_clean_style_list(obj, LV_SPINNER_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->arc_indic);
             break;
@@ -1082,16 +1074,13 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
             _lv_style_list_add_style(list, &styles->bar_bg);
             _lv_style_list_add_style(list, &styles->slider_bg);
 
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bar_indic);
 
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->slider_knob);
             break;
@@ -1099,11 +1088,9 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->cb_bg);
 
-            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BULLET);
             list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->cb_bullet);
@@ -1112,18 +1099,15 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_MSGBOX
         case LV_THEME_MSGBOX:
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->mbox_bg);
             break;
 
         case LV_THEME_MSGBOX_BTNS:
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
             _lv_style_list_add_style(list, &styles->btn);
             break;
@@ -1131,27 +1115,22 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_LED
         case LV_THEME_LED:
-            lv_obj_clean_style_list(obj, LV_LED_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
             _lv_style_list_add_style(list, &styles->led);
             break;
 #endif
 #if LV_USE_PAGE
         case LV_THEME_PAGE:
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->pad_inner);
 
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
 #if LV_USE_ANIMATION
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_EDGE_FLASH);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_EDGE_FLASH);
             _lv_style_list_add_style(list, &styles->edge_flash);
 #endif
@@ -1159,29 +1138,20 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_TABVIEW
         case LV_THEME_TABVIEW:
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
-
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             _lv_style_list_add_style(list, &styles->tabview_btns_bg);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_INDIC);
             _lv_style_list_add_style(list, &styles->tabview_indic);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             _lv_style_list_add_style(list, &styles->tabview_btns);
             break;
 
         case LV_THEME_TABVIEW_PAGE:
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
-
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->tabview_page_scrl);
 
@@ -1190,16 +1160,13 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TILEVIEW
         case LV_THEME_TILEVIEW:
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
 
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
 #if LV_USE_ANIMATION
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             _lv_style_list_add_style(list, &styles->edge_flash);
 #endif
@@ -1209,12 +1176,10 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_ROLLER
         case LV_THEME_ROLLER:
-            lv_obj_clean_style_list(obj, LV_ROLLER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->roller_bg);
 
-            lv_obj_clean_style_list(obj, LV_ROLLER_PART_SELECTED);
             list = lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->roller_sel);
             break;
@@ -1223,27 +1188,22 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_OBJMASK
         case LV_THEME_OBJMASK:
-            lv_obj_clean_style_list(obj, LV_OBJMASK_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LIST
         case LV_THEME_LIST:
-            lv_obj_clean_style_list(obj, LV_LIST_PART_BG);
             list = lv_obj_get_style_list(obj, LV_LIST_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->list_bg);
 
-            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLABLE);
 
-            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
 
         case LV_THEME_LIST_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->list_btn);
             break;
@@ -1251,22 +1211,18 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_DROPDOWN
         case LV_THEME_DROPDOWN:
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_LIST);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->ddlist_page);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->ddlist_sel);
             break;
@@ -1274,41 +1230,33 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHART
         case LV_THEME_CHART:
-            lv_obj_clean_style_list(obj, LV_CHART_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->chart_bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES_BG);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
             _lv_style_list_add_style(list, &styles->pad_small);
             _lv_style_list_add_style(list, &styles->chart_series_bg);
 
-            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
             _lv_style_list_add_style(list, &styles->chart_series);
             break;
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL1);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
             _lv_style_list_add_style(list, &styles->table_cell);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL2);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
             _lv_style_list_add_style(list, &styles->table_cell);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL3);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
             _lv_style_list_add_style(list, &styles->table_cell);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL4);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
             _lv_style_list_add_style(list, &styles->table_cell);
             break;
@@ -1316,25 +1264,20 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_WIN
         case LV_THEME_WIN:
-            lv_obj_clean_style_list(obj, LV_WIN_PART_BG);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->tabview_page_scrl);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_HEADER);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
             _lv_style_list_add_style(list, &styles->tabview_btns_bg);
             break;
 
         case LV_THEME_WIN_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->tabview_btns);
             break;
@@ -1342,20 +1285,16 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
             _lv_style_list_add_style(list, &styles->ta_placeholder);
 
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->ta_cursor);
 
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
@@ -1365,18 +1304,15 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINBOX
         case LV_THEME_SPINBOX:
-            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_CURSOR);
             list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->spinbox_cursor);
             break;
 
         case LV_THEME_SPINBOX_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->bg_click);
@@ -1385,30 +1321,24 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CALENDAR
         case LV_THEME_CALENDAR:
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DATE);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
             _lv_style_list_add_style(list, &styles->calendar_date_nums);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_HEADER);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
             _lv_style_list_add_style(list, &styles->calendar_header);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             _lv_style_list_add_style(list, &styles->calendar_daynames);
             break;
 #endif
 #if LV_USE_CPICKER
         case LV_THEME_CPICKER:
-            lv_obj_clean_style_list(obj, LV_CPICKER_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->cpicker_bg);
 
-            lv_obj_clean_style_list(obj, LV_CPICKER_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->cpicker_indic);
             break;
@@ -1416,7 +1346,6 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_LINEMETER
         case LV_THEME_LINEMETER:
-            lv_obj_clean_style_list(obj, LV_LINEMETER_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->lmeter);
@@ -1424,16 +1353,13 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_GAUGE
         case LV_THEME_GAUGE:
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->gauge_main);
 
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAJOR);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
             _lv_style_list_add_style(list, &styles->gauge_strong);
 
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_NEEDLE);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
             _lv_style_list_add_style(list, &styles->gauge_needle);
             break;

src/lv_themes/lv_theme_material.h

@@ -24,6 +24,7 @@ typedef enum {
     LV_THEME_MATERIAL_FLAG_DARK =  0x01,
     LV_THEME_MATERIAL_FLAG_LIGHT = 0x02,
     LV_THEME_MATERIAL_FLAG_NO_TRANSITION  = 0x10,
+    LV_THEME_MATERIAL_FLAG_NO_FOCUS  = 0x20,
 } lv_theme_material_flag_t;
 
 /**********************

src/lv_themes/lv_theme_mono.c

@@ -24,21 +24,21 @@
  *      TYPEDEFS
  **********************/
 
-typedef struct
-{
-lv_style_t scr;
-lv_style_t bg;
-lv_style_t clip_corner;
-lv_style_t btn;
-lv_style_t round;
-lv_style_t no_radius;
-lv_style_t fg_color;
-lv_style_t border_none;
-lv_style_t big_line_space;       /*In roller or dropdownlist*/
-lv_style_t pad_none;
-lv_style_t pad_normal;
-lv_style_t pad_small;
-lv_style_t pad_inner;
+typedef struct {
+    lv_style_t scr;
+    lv_style_t bg;
+    lv_style_t clip_corner;
+    lv_style_t btn;
+    lv_style_t round;
+    lv_style_t no_radius;
+    lv_style_t fg_color;
+    lv_style_t border_none;
+    lv_style_t big_line_space;       /*In roller or dropdownlist*/
+    lv_style_t pad_none;
+    lv_style_t pad_normal;
+    lv_style_t pad_small;
+    lv_style_t pad_inner;
+    lv_style_t txt_underline;
 
 #if LV_USE_ARC
     lv_style_t arc_bg, arc_indic;
@@ -79,12 +79,12 @@ lv_style_t pad_inner;
 #if LV_USE_TABVIEW
     lv_style_t tab_bg;
 #endif
-}theme_styles_t;
+} theme_styles_t;
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void theme_apply(lv_obj_t * obj, lv_theme_style_t name);
+static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name);
 static void style_init_reset(lv_style_t * style);
 
 /**********************
@@ -123,6 +123,8 @@ static void basic_init(void)
     lv_style_set_bg_opa(&styles->bg, LV_STATE_DEFAULT, LV_OPA_COVER);
     lv_style_set_bg_color(&styles->bg, LV_STATE_DEFAULT, BG_COLOR);
     lv_style_set_border_width(&styles->bg, LV_STATE_DEFAULT, BORDER_WIDTH);
+    lv_style_set_border_width(&styles->bg, LV_STATE_FOCUSED, BORDER_WIDTH * 2);
+    lv_style_set_border_width(&styles->bg, LV_STATE_FOCUSED | LV_STATE_EDITED, BORDER_WIDTH * 3);
     lv_style_set_border_color(&styles->bg, LV_STATE_DEFAULT, FG_COLOR);
     lv_style_set_line_width(&styles->bg, LV_STATE_DEFAULT, LV_MATH_MAX(LV_DPI / 100, 1));
     lv_style_set_scale_end_line_width(&styles->bg, LV_STATE_DEFAULT, LV_MATH_MAX(LV_DPI / 100, 1));
@@ -140,10 +142,11 @@ static void basic_init(void)
     style_init_reset(&styles->clip_corner);
     lv_style_set_clip_corner(&styles->clip_corner, LV_STATE_DEFAULT, true);
 
-
     style_init_reset(&styles->btn);
     lv_style_set_radius(&styles->btn, LV_STATE_DEFAULT, RADIUS);
     lv_style_set_border_width(&styles->btn, LV_STATE_DEFAULT, BORDER_WIDTH);
+    lv_style_set_border_width(&styles->btn, LV_STATE_FOCUSED, BORDER_WIDTH + 1);
+    lv_style_set_border_width(&styles->btn, LV_STATE_FOCUSED | LV_STATE_EDITED, BORDER_WIDTH + 2);
     lv_style_set_border_color(&styles->btn, LV_STATE_DEFAULT, FG_COLOR);
     lv_style_set_bg_color(&styles->btn, LV_STATE_DEFAULT, BG_COLOR);
     lv_style_set_bg_color(&styles->btn, LV_STATE_PRESSED, FG_COLOR);
@@ -205,6 +208,9 @@ static void basic_init(void)
 
     style_init_reset(&styles->pad_inner);
     lv_style_set_pad_inner(&styles->pad_inner, LV_STATE_DEFAULT, LV_DPI / 15);
+
+    style_init_reset(&styles->txt_underline);
+    lv_style_set_text_decor(&styles->txt_underline, LV_STATE_FOCUSED, LV_TEXT_DECOR_UNDERLINE);
 }
 
 static void arc_init(void)
@@ -553,14 +559,17 @@ lv_theme_t * lv_theme_mono_init(lv_color_t color_primary, lv_color_t color_secon
     table_init();
     win_init();
 
-    theme.apply_xcb = theme_apply;
+    theme.apply_xcb = NULL;
+    theme.apply_cb = theme_apply;
 
     return &theme;
 }
 
 
-static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
+static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 {
+    LV_UNUSED(th);
+
     lv_style_list_t * list;
 
     switch(name) {
@@ -568,18 +577,15 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
             break;
 
         case LV_THEME_SCR:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->scr);
             break;
         case LV_THEME_OBJ:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #if LV_USE_CONT
         case LV_THEME_CONT:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
@@ -587,34 +593,31 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
+            _lv_style_list_add_style(list, &styles->txt_underline);
             break;
 #endif
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
+            _lv_style_list_add_style(list, &styles->txt_underline);
             break;
 #endif
 
 #if LV_USE_KEYBOARD
         case LV_THEME_KEYBOARD:
-            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BG);
             list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -623,13 +626,11 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            lv_obj_clean_style_list(obj, LV_BAR_PART_BG);
             list = lv_obj_get_style_list(obj, LV_BAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->round);
 
-            lv_obj_clean_style_list(obj, LV_BAR_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
@@ -639,18 +640,15 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->round);
 
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
 
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
@@ -660,46 +658,39 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CANVAS
         case LV_THEME_CANVAS:
-            lv_obj_clean_style_list(obj, LV_CANVAS_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_CANVAS_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMG
         case LV_THEME_IMAGE:
-            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMGBTN
         case LV_THEME_IMGBTN:
-            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LABEL
         case LV_THEME_LABEL:
-            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LINE
         case LV_THEME_LINE:
-            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_ARC
         case LV_THEME_ARC:
-            lv_obj_clean_style_list(obj, LV_ARC_PART_BG);
             list = lv_obj_get_style_list(obj, LV_ARC_PART_BG);
             _lv_style_list_add_style(list, &styles->arc_bg);
 
-            lv_obj_clean_style_list(obj, LV_ARC_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
             _lv_style_list_add_style(list, &styles->arc_indic);
             break;
@@ -707,12 +698,10 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINNER
         case LV_THEME_SPINNER:
-            lv_obj_clean_style_list(obj, LV_SPINNER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tick_line);
 
-            lv_obj_clean_style_list(obj, LV_SPINNER_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
@@ -722,59 +711,53 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
 
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
 
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
             _lv_style_list_add_style(list, &styles->pad_small);
+            _lv_style_list_add_style(list, &styles->fg_color);
             break;
 #endif
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BULLET);
             list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
+            _lv_style_list_add_style(list, &styles->pad_small);
             break;
 #endif
 
 #if LV_USE_MSGBOX
         case LV_THEME_MSGBOX:
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_MSGBOX_BTNS:
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             _lv_style_list_add_style(list, &styles->pad_inner);
 
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
+            _lv_style_list_add_style(list, &styles->txt_underline);
             break;
 
 #endif
 #if LV_USE_LED
         case LV_THEME_LED:
-            lv_obj_clean_style_list(obj, LV_LED_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
@@ -782,45 +765,32 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_PAGE
         case LV_THEME_PAGE:
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->pad_inner);
 
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
 #endif
 #if LV_USE_TABVIEW
         case LV_THEME_TABVIEW:
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->scr);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
-
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             _lv_style_list_add_style(list, &styles->tab_bg);
             _lv_style_list_add_style(list, &styles->pad_small);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_INDIC);
-            list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_INDIC);
-
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
+            _lv_style_list_add_style(list, &styles->txt_underline);
             break;
 
         case LV_THEME_TABVIEW_PAGE:
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
-
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->pad_normal);
 
@@ -829,15 +799,12 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TILEVIEW
         case LV_THEME_TILEVIEW:
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             _lv_style_list_add_style(list, &styles->bg);
             break;
@@ -846,12 +813,10 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_ROLLER
         case LV_THEME_ROLLER:
-            lv_obj_clean_style_list(obj, LV_ROLLER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->big_line_space);
 
-            lv_obj_clean_style_list(obj, LV_ROLLER_PART_SELECTED);
             list = lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
@@ -862,53 +827,44 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_OBJMASK
         case LV_THEME_OBJMASK:
-            lv_obj_clean_style_list(obj, LV_OBJMASK_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LIST
         case LV_THEME_LIST:
-            lv_obj_clean_style_list(obj, LV_LIST_PART_BG);
             list = lv_obj_get_style_list(obj, LV_LIST_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->clip_corner);
 
-            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLABLE);
-
-            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
 
         case LV_THEME_LIST_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->list_btn);
+            _lv_style_list_add_style(list, &styles->txt_underline);
 
             break;
 #endif
 
 #if LV_USE_DROPDOWN
         case LV_THEME_DROPDOWN:
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_LIST);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->big_line_space);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
@@ -918,42 +874,34 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHART
         case LV_THEME_CHART:
-            lv_obj_clean_style_list(obj, LV_CHART_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES_BG);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->border_none);
 
-            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
             _lv_style_list_add_style(list, &styles->chart_series);
             break;
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL1);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->no_radius);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL2);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->no_radius);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL3);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->no_radius);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL4);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->no_radius);
@@ -962,25 +910,20 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_WIN
         case LV_THEME_WIN:
-            lv_obj_clean_style_list(obj, LV_WIN_PART_BG);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_HEADER);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_WIN_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -989,17 +932,12 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
-
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->ta_cursor);
 
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->sb);
             break;
@@ -1008,33 +946,30 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINBOX
         case LV_THEME_SPINBOX:
-            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_CURSOR);
             list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->fg_color);
             _lv_style_list_add_style(list, &styles->pad_none);
             _lv_style_list_add_style(list, &styles->no_radius);
+            _lv_style_list_add_style(list, &styles->txt_underline);
             break;
 
         case LV_THEME_SPINBOX_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
+            _lv_style_list_add_style(list, &styles->txt_underline);
             break;
 #endif
 
 #if LV_USE_CALENDAR
         case LV_THEME_CALENDAR:
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DATE);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -1042,12 +977,10 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
             _lv_style_list_add_style(list, &styles->border_none);
             _lv_style_list_add_style(list, &styles->calendar_date);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_HEADER);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
             _lv_style_list_add_style(list, &styles->pad_normal);
             _lv_style_list_add_style(list, &styles->border_none);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->pad_small);
@@ -1055,11 +988,9 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_CPICKER
         case LV_THEME_CPICKER:
-            lv_obj_clean_style_list(obj, LV_CPICKER_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CPICKER_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
@@ -1068,7 +999,6 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_LINEMETER
         case LV_THEME_LINEMETER:
-            lv_obj_clean_style_list(obj, LV_LINEMETER_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
@@ -1077,16 +1007,13 @@ static void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_GAUGE
         case LV_THEME_GAUGE:
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
 
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAJOR);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
             _lv_style_list_add_style(list, &styles->gauge_major);
 
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_NEEDLE);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
             _lv_style_list_add_style(list, &styles->gauge_needle);
             break;

src/lv_themes/lv_theme_template.c

@@ -37,7 +37,7 @@ typedef struct {
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void theme_apply(lv_obj_t * obj, lv_theme_style_t name);
+static void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name);
 
 /**********************
  *  STATIC VARIABLES
@@ -80,7 +80,8 @@ static void basic_init(void)
     style_init_reset(&styles->btn);
     lv_style_set_bg_color(&styles->btn, LV_STATE_PRESSED, lv_color_hex3(0xccc));
     lv_style_set_bg_color(&styles->btn, LV_STATE_CHECKED, theme.color_primary);
-    lv_style_set_bg_color(&styles->btn, LV_STATE_CHECKED | LV_STATE_PRESSED, lv_color_darken(theme.color_primary, LV_OPA_30));
+    lv_style_set_bg_color(&styles->btn, LV_STATE_CHECKED | LV_STATE_PRESSED, lv_color_darken(theme.color_primary,
+                                                                                             LV_OPA_30));
     lv_style_set_bg_color(&styles->btn, LV_STATE_DISABLED, LV_COLOR_SILVER);
     lv_style_set_text_color(&styles->btn, LV_STATE_DISABLED, LV_COLOR_GRAY);
     lv_style_set_image_recolor(&styles->btn, LV_STATE_DISABLED, LV_COLOR_GRAY);
@@ -401,14 +402,17 @@ lv_theme_t * lv_theme_template_init(lv_color_t color_primary, lv_color_t color_s
     table_init();
     win_init();
 
-    theme.apply_xcb = theme_apply;
+    theme.apply_xcb = NULL;
+    theme.apply_cb = theme_apply;
 
     return &theme;
 }
 
 
-void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
+void theme_apply(lv_theme_t * th, lv_obj_t * obj, lv_theme_style_t name)
 {
+    LV_UNUSED(th);
+
     lv_style_list_t * list;
 
     switch(name) {
@@ -416,19 +420,16 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
             break;
 
         case LV_THEME_SCR:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
             break;
         case LV_THEME_OBJ:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJ_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #if LV_USE_CONT
         case LV_THEME_CONT:
-            lv_obj_clean_style_list(obj, LV_OBJ_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_CONT_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             break;
@@ -436,7 +437,6 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTN
         case LV_THEME_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -445,11 +445,9 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BTNMATRIX
         case LV_THEME_BTNMATRIX:
-            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_BTNMATRIX_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_BTNMATRIX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -458,11 +456,9 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_KEYBOARD
         case LV_THEME_KEYBOARD:
-            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BG);
             list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_KEYBOARD_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_KEYBOARD_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -471,12 +467,10 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_BAR
         case LV_THEME_BAR:
-            lv_obj_clean_style_list(obj, LV_BAR_PART_BG);
             list = lv_obj_get_style_list(obj, LV_BAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
 
-            lv_obj_clean_style_list(obj, LV_BAR_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_BAR_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
@@ -485,18 +479,15 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SWITCH
         case LV_THEME_SWITCH:
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
             _lv_style_list_add_style(list, &styles->round);
 
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
 
-            lv_obj_clean_style_list(obj, LV_SWITCH_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_SWITCH_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
@@ -506,48 +497,41 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CANVAS
         case LV_THEME_CANVAS:
-            lv_obj_clean_style_list(obj, LV_CANVAS_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_CANVAS_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMG
         case LV_THEME_IMAGE:
-            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_IMGBTN
         case LV_THEME_IMGBTN:
-            lv_obj_clean_style_list(obj, LV_IMG_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_IMG_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LABEL
         case LV_THEME_LABEL:
-            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LINE
         case LV_THEME_LINE:
-            lv_obj_clean_style_list(obj, LV_LABEL_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LABEL_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_ARC
         case LV_THEME_ARC:
-            lv_obj_clean_style_list(obj, LV_ARC_PART_BG);
             list = lv_obj_get_style_list(obj, LV_ARC_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tick_line);
             _lv_style_list_add_style(list, &styles->round);
 
-            lv_obj_clean_style_list(obj, LV_ARC_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_ARC_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
@@ -557,12 +541,10 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINNER
         case LV_THEME_SPINNER:
-            lv_obj_clean_style_list(obj, LV_SPINNER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SPINNER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tick_line);
 
-            lv_obj_clean_style_list(obj, LV_SPINNER_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SPINNER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
@@ -572,16 +554,13 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SLIDER
         case LV_THEME_SLIDER:
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
 
-            lv_obj_clean_style_list(obj, LV_SLIDER_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_SLIDER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
@@ -590,10 +569,8 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHECKBOX
         case LV_THEME_CHECKBOX:
-            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BG);
 
-            lv_obj_clean_style_list(obj, LV_CHECKBOX_PART_BULLET);
             list = lv_obj_get_style_list(obj, LV_CHECKBOX_PART_BULLET);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -602,17 +579,14 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_MSGBOX
         case LV_THEME_MSGBOX:
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_MSGBOX_BTNS:
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_MSGBOX_PART_BTN);
             list = lv_obj_get_style_list(obj, LV_MSGBOX_PART_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -621,7 +595,6 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_LED
         case LV_THEME_LED:
-            lv_obj_clean_style_list(obj, LV_LED_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LED_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
@@ -630,53 +603,43 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_PAGE
         case LV_THEME_PAGE:
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->gray);
 
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 #endif
 #if LV_USE_TABVIEW
         case LV_THEME_TABVIEW:
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_BG_SCRLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_INDIC);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_INDIC);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
 
-            lv_obj_clean_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             list = lv_obj_get_style_list(obj, LV_TABVIEW_PART_TAB_BTN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             break;
 
         case LV_THEME_TABVIEW_PAGE:
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_BG);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->gray);
 
-            lv_obj_clean_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_PAGE_PART_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
 
@@ -685,15 +648,12 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TILEVIEW
         case LV_THEME_TILEVIEW:
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             list = lv_obj_get_style_list(obj, LV_TILEVIEW_PART_EDGE_FLASH);
             _lv_style_list_add_style(list, &styles->bg);
             break;
@@ -702,11 +662,9 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_ROLLER
         case LV_THEME_ROLLER:
-            lv_obj_clean_style_list(obj, LV_ROLLER_PART_BG);
             list = lv_obj_get_style_list(obj, LV_ROLLER_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_ROLLER_PART_SELECTED);
             list = lv_obj_get_style_list(obj, LV_ROLLER_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
@@ -716,27 +674,22 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_OBJMASK
         case LV_THEME_OBJMASK:
-            lv_obj_clean_style_list(obj, LV_OBJMASK_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_OBJMASK_PART_MAIN);
             break;
 #endif
 
 #if LV_USE_LIST
         case LV_THEME_LIST:
-            lv_obj_clean_style_list(obj, LV_LIST_PART_BG);
             list = lv_obj_get_style_list(obj, LV_LIST_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLABLE);
 
-            lv_obj_clean_style_list(obj, LV_LIST_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_LIST_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_LIST_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -745,20 +698,16 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_DROPDOWN
         case LV_THEME_DROPDOWN:
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_LIST);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_LIST);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             list = lv_obj_get_style_list(obj, LV_DROPDOWN_PART_SELECTED);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->color);
@@ -767,15 +716,12 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CHART
         case LV_THEME_CHART:
-            lv_obj_clean_style_list(obj, LV_CHART_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES_BG);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CHART_PART_SERIES);
             list = lv_obj_get_style_list(obj, LV_CHART_PART_SERIES);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
@@ -783,23 +729,18 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_TABLE
         case LV_THEME_TABLE:
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL1);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL1);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL2);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL2);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL3);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL3);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TABLE_PART_CELL4);
             list = lv_obj_get_style_list(obj, LV_TABLE_PART_CELL4);
             _lv_style_list_add_style(list, &styles->bg);
             break;
@@ -807,25 +748,20 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_WIN
         case LV_THEME_WIN:
-            lv_obj_clean_style_list(obj, LV_WIN_PART_BG);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_CONTENT_SCROLLABLE);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_WIN_PART_HEADER);
             list = lv_obj_get_style_list(obj, LV_WIN_PART_HEADER);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_WIN_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -834,20 +770,16 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_TEXTAREA
         case LV_THEME_TEXTAREA:
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_BG);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_PLACEHOLDER);
             _lv_style_list_add_style(list, &styles->gray);
 
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
 
-            lv_obj_clean_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             list = lv_obj_get_style_list(obj, LV_TEXTAREA_PART_SCROLLBAR);
             _lv_style_list_add_style(list, &styles->bg);
             break;
@@ -856,17 +788,14 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_SPINBOX
         case LV_THEME_SPINBOX:
-            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_BG);
             list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_SPINBOX_PART_CURSOR);
             list = lv_obj_get_style_list(obj, LV_SPINBOX_PART_CURSOR);
             _lv_style_list_add_style(list, &styles->bg);
             break;
 
         case LV_THEME_SPINBOX_BTN:
-            lv_obj_clean_style_list(obj, LV_BTN_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_BTN_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
@@ -875,21 +804,17 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_CALENDAR
         case LV_THEME_CALENDAR:
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_BG);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_BG);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DATE);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DATE);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->btn);
             _lv_style_list_add_style(list, &styles->tight);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_HEADER);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_HEADER);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             list = lv_obj_get_style_list(obj, LV_CALENDAR_PART_DAY_NAMES);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->tight);
@@ -897,11 +822,9 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_CPICKER
         case LV_THEME_CPICKER:
-            lv_obj_clean_style_list(obj, LV_CPICKER_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_CPICKER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
 
-            lv_obj_clean_style_list(obj, LV_CPICKER_PART_KNOB);
             list = lv_obj_get_style_list(obj, LV_CPICKER_PART_KNOB);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
@@ -910,7 +833,6 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 
 #if LV_USE_LINEMETER
         case LV_THEME_LINEMETER:
-            lv_obj_clean_style_list(obj, LV_LINEMETER_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_LINEMETER_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
@@ -918,16 +840,13 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
 #endif
 #if LV_USE_GAUGE
         case LV_THEME_GAUGE:
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAIN);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAIN);
             _lv_style_list_add_style(list, &styles->bg);
             _lv_style_list_add_style(list, &styles->round);
 
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_MAJOR);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_MAJOR);
             _lv_style_list_add_style(list, &styles->tick_line);
 
-            lv_obj_clean_style_list(obj, LV_GAUGE_PART_NEEDLE);
             list = lv_obj_get_style_list(obj, LV_GAUGE_PART_NEEDLE);
             _lv_style_list_add_style(list, &styles->bg);
             break;
@@ -936,10 +855,7 @@ void theme_apply(lv_obj_t * obj, lv_theme_style_t name)
             break;
     }
 
-
     lv_obj_refresh_style(obj, LV_STYLE_PROP_ALL);
-
-
 }
 
 /**********************

src/lv_widgets/lv_btn.c

@@ -202,7 +202,8 @@ lv_btn_state_t lv_btn_get_state(const lv_obj_t * btn)
     if(obj_state & LV_STATE_CHECKED) {
         if(obj_state & LV_STATE_PRESSED) return LV_BTN_STATE_CHECKED_PRESSED;
         else return LV_BTN_STATE_CHECKED_RELEASED;
-    } else {
+    }
+    else {
         if(obj_state & LV_STATE_PRESSED) return LV_BTN_STATE_PRESSED;
         else return LV_BTN_STATE_RELEASED;
     }
@@ -288,6 +289,7 @@ static lv_res_t lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
         }
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         char c = *((char *)param);
         if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
             if(lv_btn_get_checkable(btn)) {
@@ -308,6 +310,7 @@ static lv_res_t lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
                 if(res != LV_RES_OK) return res;
             }
         }
+#endif
     }
 
     return res;

src/lv_widgets/lv_btnmatrix.c

@@ -422,6 +422,23 @@ void lv_btnmatrix_set_one_check(lv_obj_t * btnm, bool one_chk)
     make_one_button_toggled(btnm, 0);
 }
 
+/**
+ * Set the align of the map text (left, right or center)
+ * @param btnm pointer to a btnmatrix object
+ * @param align LV_LABEL_ALIGN_LEFT, LV_LABEL_ALIGN_RIGHT or LV_LABEL_ALIGN_CENTER
+ */
+void lv_btnmatrix_set_align(lv_obj_t * btnm, lv_label_align_t align)
+{
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
+    lv_btnmatrix_ext_t * ext = lv_obj_get_ext_attr(btnm);
+    if(ext->align == align) return;
+
+    ext->align = align;
+
+    lv_obj_invalidate(btnm);
+}
+
 /*=====================
  * Getter functions
  *====================*/
@@ -563,6 +580,32 @@ bool lv_btnmatrix_get_one_check(const lv_obj_t * btnm)
     return ext->one_check;
 }
 
+/**
+ * Get the align attribute
+ * @param btnm pointer to a btnmatrix object
+ * @return LV_LABEL_ALIGN_LEFT, LV_LABEL_ALIGN_RIGHT or LV_LABEL_ALIGN_CENTER
+ */
+lv_label_align_t lv_btnmatrix_get_align(const lv_obj_t * btnm)
+{
+    LV_ASSERT_OBJ(btnm, LV_OBJX_NAME);
+
+    lv_btnmatrix_ext_t * ext = lv_obj_get_ext_attr(btnm);
+
+    lv_label_align_t align = ext->align;
+
+    if(align == LV_LABEL_ALIGN_AUTO) {
+#if LV_USE_BIDI
+        lv_bidi_dir_t base_dir = lv_obj_get_base_dir(btnm);
+        if(base_dir == LV_BIDI_DIR_RTL) align = LV_LABEL_ALIGN_RIGHT;
+        else align = LV_LABEL_ALIGN_LEFT;
+#else
+        align = LV_LABEL_ALIGN_LEFT;
+#endif
+    }
+
+    return align;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -598,7 +641,10 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
         uint16_t btn_i = 0;
         uint16_t txt_i = 0;
         lv_txt_flag_t txt_flag = LV_TXT_FLAG_NONE;
-        if(ext->recolor) txt_flag = LV_TXT_FLAG_RECOLOR;
+        if(ext->recolor) txt_flag |= LV_TXT_FLAG_RECOLOR;
+        lv_label_align_t align = lv_btnmatrix_get_align(btnm);
+        if(align == LV_LABEL_ALIGN_CENTER) txt_flag |= LV_TXT_FLAG_CENTER;
+        if(align == LV_LABEL_ALIGN_RIGHT) txt_flag |= LV_TXT_FLAG_RIGHT;
 
         lv_draw_rect_dsc_t draw_rect_rel_dsc;
         lv_draw_label_dsc_t draw_label_rel_dsc;
@@ -612,7 +658,6 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
         lv_draw_rect_dsc_t draw_rect_tmp_dsc;
         lv_draw_label_dsc_t draw_label_tmp_dsc;
 
-        /*The state changes without re-caching the styles, disable the use of cache*/
         lv_state_t state_ori = btnm->state;
         btnm->state = LV_STATE_DEFAULT;
         lv_draw_rect_dsc_init(&draw_rect_rel_dsc);
@@ -649,9 +694,20 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
             /*Choose the style*/
             lv_draw_rect_dsc_t * draw_rect_dsc_act;
             lv_draw_label_dsc_t * draw_label_dsc_act;
-            bool tgl_state = button_get_tgl_state(ext->ctrl_bits[btn_i]);
+            lv_state_t btn_state = LV_STATE_DEFAULT;
+            if(button_get_tgl_state(ext->ctrl_bits[btn_i])) btn_state |= LV_STATE_CHECKED;
+            if(button_is_inactive(ext->ctrl_bits[btn_i])) btn_state |= LV_STATE_DISABLED;
+            if(btn_i == ext->btn_id_pr) btn_state |= LV_STATE_PRESSED;
+            if(btn_i == ext->btn_id_focused) {
+                btn_state |= LV_STATE_FOCUSED;
+                if(state_ori & LV_STATE_EDITED) btn_state |= LV_STATE_EDITED;
+            }
 
-            if(tgl_state) {
+            if(btn_state == LV_STATE_DEFAULT) {
+                draw_rect_dsc_act = &draw_rect_rel_dsc;
+                draw_label_dsc_act = &draw_label_rel_dsc;
+            }
+            else if(btn_state == LV_STATE_CHECKED) {
                 if(!chk_inited) {
                     btnm->state = LV_STATE_CHECKED;
                     lv_draw_rect_dsc_init(&draw_rect_chk_dsc);
@@ -662,9 +718,10 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
                     btnm->state = state_ori;
                     chk_inited = true;
                 }
+                draw_rect_dsc_act = &draw_rect_chk_dsc;
+                draw_label_dsc_act = &draw_label_chk_dsc;
             }
-
-            if(button_is_inactive(ext->ctrl_bits[btn_i])) {
+            else if(btn_state == LV_STATE_CHECKED) {
                 if(!disabled_inited) {
                     btnm->state = LV_STATE_DISABLED;
                     lv_draw_rect_dsc_init(&draw_rect_ina_dsc);
@@ -678,21 +735,9 @@ static lv_design_res_t lv_btnmatrix_design(lv_obj_t * btnm, const lv_area_t * cl
                 draw_rect_dsc_act = &draw_rect_ina_dsc;
                 draw_label_dsc_act = &draw_label_ina_dsc;
             }
-            /*Simple released or checked buttons button*/
-            else if(btn_i != ext->btn_id_pr && btn_i != ext->btn_id_focused) {
-                draw_rect_dsc_act = tgl_state ? &draw_rect_chk_dsc : &draw_rect_rel_dsc;
-                draw_label_dsc_act = tgl_state ? &draw_label_chk_dsc : &draw_label_rel_dsc;
-            }
-            /*Focused and/or pressed + checked or released button*/
+            /*In other cases get the styles directly without caching them*/
             else {
-                btnm->state = LV_STATE_DEFAULT;
-                if(tgl_state) btnm->state = LV_STATE_CHECKED;
-                if(ext->btn_id_pr == btn_i) btnm->state |= LV_STATE_PRESSED;
-                if(ext->btn_id_focused == btn_i) {
-                    btnm->state |= LV_STATE_FOCUSED;
-                    if(state_ori & LV_STATE_EDITED) btnm->state |= LV_STATE_EDITED;
-                }
-
+                btnm->state = btn_state;
                 lv_draw_rect_dsc_init(&draw_rect_tmp_dsc);
                 lv_draw_label_dsc_init(&draw_label_tmp_dsc);
                 lv_obj_init_draw_rect_dsc(btnm, LV_BTNMATRIX_PART_BTN, &draw_rect_tmp_dsc);
@@ -946,6 +991,7 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
         ext->btn_id_act = LV_BTNMATRIX_BTN_NONE;
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         char c = *((char *)param);
         if(c == LV_KEY_RIGHT) {
             if(ext->btn_id_focused == LV_BTNMATRIX_BTN_NONE)
@@ -1013,10 +1059,13 @@ static lv_res_t lv_btnmatrix_signal(lv_obj_t * btnm, lv_signal_t sign, void * pa
             ext->btn_id_act = ext->btn_id_focused;
             lv_obj_invalidate(btnm);
         }
+#endif
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
+#if LV_USE_GROUP
         bool * editable = (bool *)param;
         *editable       = true;
+#endif
     }
     return res;
 }

src/lv_widgets/lv_btnmatrix.h

@@ -59,6 +59,7 @@ typedef struct {
     uint16_t btn_id_act;    /*Index of the active button (being pressed/released etc) or LV_BTNMATRIX_BTN_NONE */
     uint8_t recolor : 1;    /*Enable button recoloring*/
     uint8_t one_check : 1;  /*Single button toggled at once*/
+    uint8_t align : 2;      /*Align type from 'lv_label_align_t'*/
 } lv_btnmatrix_ext_t;
 
 enum {
@@ -170,6 +171,13 @@ void lv_btnmatrix_set_btn_width(lv_obj_t * btnm, uint16_t btn_id, uint8_t width)
  */
 void lv_btnmatrix_set_one_check(lv_obj_t * btnm, bool one_chk);
 
+/**
+ * Set the align of the map text (left, right or center)
+ * @param btnm pointer to a btnmatrix object
+ * @param align LV_LABEL_ALIGN_LEFT, LV_LABEL_ALIGN_RIGHT or LV_LABEL_ALIGN_CENTER
+ */
+void lv_btnmatrix_set_align(lv_obj_t * btnm, lv_label_align_t align);
+
 /*=====================
  * Getter functions
  *====================*/
@@ -236,6 +244,14 @@ bool lv_btnmatrix_get_btn_ctrl(lv_obj_t * btnm, uint16_t btn_id, lv_btnmatrix_ct
  * @return whether "one toggle" mode is enabled
  */
 bool lv_btnmatrix_get_one_check(const lv_obj_t * btnm);
+
+/**
+ * Get the align attribute
+ * @param  btnm pointer to a btnmatrix object
+ * @return LV_LABEL_ALIGN_LEFT, LV_LABEL_ALIGN_RIGHT or LV_LABEL_ALIGN_CENTER
+ */
+lv_label_align_t lv_btnmatrix_get_align(const lv_obj_t * btnm);
+
 /**********************
  *      MACROS
  **********************/

src/lv_widgets/lv_calendar.c

@@ -57,7 +57,11 @@ static uint8_t is_leap_year(uint32_t year);
  **********************/
 static lv_signal_cb_t ancestor_signal;
 static lv_design_cb_t ancestor_design;
+#if LV_CALENDAR_WEEK_STARTS_MONDAY != 0
+static const char * day_name[7]    = {"Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"};
+#else
 static const char * day_name[7]    = {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"};
+#endif
 static const char * month_name[12] = {"January", "February", "March",     "April",   "May",      "June",
                                       "July",    "August",   "September", "October", "November", "December"
                                      };
@@ -515,6 +519,7 @@ static lv_res_t lv_calendar_signal(lv_obj_t * calendar, lv_signal_t sign, void *
         lv_obj_invalidate(calendar);
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         uint8_t c               = *((uint8_t *)param);
         lv_calendar_ext_t * ext = lv_obj_get_ext_attr(calendar);
         if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
@@ -537,6 +542,7 @@ static lv_res_t lv_calendar_signal(lv_obj_t * calendar, lv_signal_t sign, void *
             }
             lv_obj_invalidate(calendar);
         }
+#endif
     }
 
     return res;
@@ -1057,14 +1063,18 @@ static uint8_t is_leap_year(uint32_t year)
  * @param year a year
  * @param month a  month
  * @param day a day
- * @return [0..6] which means [Sun..Sat]
+ * @return [0..6] which means [Sun..Sat] or [Mon..Sun] depending on LV_CALENDAR_WEEK_STARTS_MONDAY
  */
 static uint8_t get_day_of_week(uint32_t year, uint32_t month, uint32_t day)
 {
     uint32_t a = month < 3 ? 1 : 0;
     uint32_t b = year - a;
 
+#if LV_CALENDAR_WEEK_STARTS_MONDAY
+    uint32_t day_of_week = (day + (31 * (month - 2 + 12 * a) / 12) + b + (b / 4) - (b / 100) + (b / 400) - 1) % 7;
+#else
     uint32_t day_of_week = (day + (31 * (month - 2 + 12 * a) / 12) + b + (b / 4) - (b / 100) + (b / 400)) % 7;
+#endif
 
     return day_of_week;
 }

src/lv_widgets/lv_canvas.h

@@ -60,7 +60,7 @@ lv_obj_t * lv_canvas_create(lv_obj_t * par, const lv_obj_t * copy);
 /**
  * Set a buffer for the canvas.
  * @param buf a buffer where the content of the canvas will be.
- * The required size is (lv_img_color_format_get_px_size(cf) * w * h) / 8)
+ * The required size is (lv_img_color_format_get_px_size(cf) * w) / 8 * h)
  * It can be allocated with `lv_mem_alloc()` or
  * it can be statically allocated array (e.g. static lv_color_t buf[100*50]) or
  * it can be an address in RAM or external SRAM

src/lv_widgets/lv_chart.c

@@ -27,8 +27,6 @@
 #define LV_CHART_PNUM_DEF 10
 #define LV_CHART_AXIS_MAJOR_TICK_LEN_COE 1 / 15
 #define LV_CHART_AXIS_MINOR_TICK_LEN_COE 2 / 3
-#define LV_CHART_AXIS_PRIMARY_Y 1
-#define LV_CHART_AXIS_SECONDARY_Y 0
 #define LV_CHART_LABEL_ITERATOR_FORWARD 1
 #define LV_CHART_LABEL_ITERATOR_REVERSE 0
 
@@ -101,8 +99,12 @@ lv_obj_t * lv_chart_create(lv_obj_t * par, const lv_obj_t * copy)
 
     _lv_ll_init(&ext->series_ll, sizeof(lv_chart_series_t));
 
-    ext->ymin                  = LV_CHART_YMIN_DEF;
-    ext->ymax                  = LV_CHART_YMAX_DEF;
+    uint8_t i;
+    for(i = 0; i < _LV_CHART_AXIS_LAST; i++) {
+        ext->ymin[i]                  = LV_CHART_YMIN_DEF;
+        ext->ymax[i]                  = LV_CHART_YMAX_DEF;
+    }
+
     ext->hdiv_cnt              = LV_CHART_HDIV_DEF;
     ext->vdiv_cnt              = LV_CHART_VDIV_DEF;
     ext->point_cnt             = LV_CHART_PNUM_DEF;
@@ -118,7 +120,6 @@ lv_obj_t * lv_chart_create(lv_obj_t * par, const lv_obj_t * copy)
     ext->secondary_y_axis.major_tick_len = LV_CHART_TICK_LENGTH_AUTO;
     ext->secondary_y_axis.minor_tick_len = LV_CHART_TICK_LENGTH_AUTO;
 
-
     lv_style_list_init(&ext->style_series_bg);
     lv_style_list_init(&ext->style_series);
 
@@ -133,7 +134,6 @@ lv_obj_t * lv_chart_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_obj_set_size(chart, LV_DPI * 3, LV_DPI * 2);
 
         lv_theme_apply(chart, LV_THEME_CHART);
-
     }
     else {
         lv_chart_ext_t * ext_copy = lv_obj_get_ext_attr(copy);
@@ -142,11 +142,11 @@ lv_obj_t * lv_chart_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_style_list_copy(&ext->style_series_bg, &ext_copy->style_series_bg);
 
         ext->type       = ext_copy->type;
-        ext->ymin       = ext_copy->ymin;
-        ext->ymax       = ext_copy->ymax;
         ext->hdiv_cnt   = ext_copy->hdiv_cnt;
         ext->vdiv_cnt   = ext_copy->vdiv_cnt;
         ext->point_cnt  = ext_copy->point_cnt;
+        _lv_memcpy_small(ext->ymin, ext_copy->ymin, sizeof(ext->ymin));
+        _lv_memcpy_small(ext->ymax, ext_copy->ymax, sizeof(ext->ymax));
         _lv_memcpy(&ext->x_axis, &ext_copy->x_axis, sizeof(lv_chart_axis_cfg_t));
         _lv_memcpy(&ext->y_axis, &ext_copy->y_axis, sizeof(lv_chart_axis_cfg_t));
         _lv_memcpy(&ext->secondary_y_axis, &ext_copy->secondary_y_axis, sizeof(lv_chart_axis_cfg_t));
@@ -191,6 +191,8 @@ lv_chart_series_t * lv_chart_add_series(lv_obj_t * chart, lv_color_t color)
     }
 
     ser->start_point = 0;
+    ser->ext_buf_assigned = false;
+    ser->y_axis = LV_CHART_AXIS_PRIMARY_Y;
 
     uint16_t i;
     lv_coord_t * p_tmp = ser->points;
@@ -248,20 +250,26 @@ void lv_chart_set_div_line_count(lv_obj_t * chart, uint8_t hdiv, uint8_t vdiv)
 }
 
 /**
- * Set the minimal and maximal y values
+ * Set the minimal and maximal y values on an axis
  * @param chart pointer to a graph background object
+ * @param axis `LV_CHART_AXIS_PRIMARY_Y` or `LV_CHART_AXIS_SECONDARY_Y`
  * @param ymin y minimum value
  * @param ymax y maximum value
  */
-void lv_chart_set_range(lv_obj_t * chart, lv_coord_t ymin, lv_coord_t ymax)
+void lv_chart_set_y_range(lv_obj_t * chart, lv_chart_axis_t axis, lv_coord_t ymin, lv_coord_t ymax)
 {
     LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
 
-    lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
-    if(ext->ymin == ymin && ext->ymax == ymax) return;
+    if(axis >= _LV_CHART_AXIS_LAST) {
+        LV_LOG_WARN("Invalid axis: %d", axis);
+        return;
+    }
 
-    ext->ymin = ymin;
-    ext->ymax = ymax;
+    lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
+    if(ext->ymin[axis] == ymin && ext->ymax[axis] == ymax) return;
+
+    ext->ymin[axis] = ymin;
+    ext->ymax[axis] = ymax;
 
     lv_chart_refresh(chart);
 }
@@ -303,43 +311,44 @@ void lv_chart_set_point_count(lv_obj_t * chart, uint16_t point_cnt)
     if(point_cnt < 1) point_cnt = 1;
 
     _LV_LL_READ_BACK(ext->series_ll, ser) {
-        if(ser->start_point != 0) {
-            lv_coord_t * new_points = lv_mem_alloc(sizeof(lv_coord_t) * point_cnt);
-            LV_ASSERT_MEM(new_points);
-            if(new_points == NULL) return;
+        if(!ser->ext_buf_assigned) {
+            if(ser->start_point != 0) {
+                lv_coord_t * new_points = lv_mem_alloc(sizeof(lv_coord_t) * point_cnt);
+                LV_ASSERT_MEM(new_points);
+                if(new_points == NULL) return;
 
-            if(point_cnt >= point_cnt_old) {
-                for(i = 0; i < point_cnt_old; i++) {
-                    new_points[i] =
-                        ser->points[(i + ser->start_point) % point_cnt_old]; /*Copy old contents to new array*/
+                if(point_cnt >= point_cnt_old) {
+                    for(i = 0; i < point_cnt_old; i++) {
+                        new_points[i] =
+                            ser->points[(i + ser->start_point) % point_cnt_old]; /*Copy old contents to new array*/
+                    }
+                    for(i = point_cnt_old; i < point_cnt; i++) {
+                        new_points[i] = def; /*Fill up the rest with default value*/
+                    }
                 }
-                for(i = point_cnt_old; i < point_cnt; i++) {
-                    new_points[i] = def; /*Fill up the rest with default value*/
+                else {
+                    for(i = 0; i < point_cnt; i++) {
+                        new_points[i] =
+                            ser->points[(i + ser->start_point) % point_cnt_old]; /*Copy old contents to new array*/
+                    }
                 }
+
+                /*Switch over pointer from old to new*/
+                lv_mem_free(ser->points);
+                ser->points = new_points;
             }
             else {
-                for(i = 0; i < point_cnt; i++) {
-                    new_points[i] =
-                        ser->points[(i + ser->start_point) % point_cnt_old]; /*Copy old contents to new array*/
-                }
-            }
-
-            /*Switch over pointer from old to new*/
-            lv_mem_free(ser->points);
-            ser->points = new_points;
-        }
-        else {
-            ser->points = lv_mem_realloc(ser->points, sizeof(lv_coord_t) * point_cnt);
-            LV_ASSERT_MEM(ser->points);
-            if(ser->points == NULL) return;
-            /*Initialize the new points*/
-            if(point_cnt > point_cnt_old) {
-                for(i = point_cnt_old - 1; i < point_cnt; i++) {
-                    ser->points[i] = def;
+                ser->points = lv_mem_realloc(ser->points, sizeof(lv_coord_t) * point_cnt);
+                LV_ASSERT_MEM(ser->points);
+                if(ser->points == NULL) return;
+                /*Initialize the new points*/
+                if(point_cnt > point_cnt_old) {
+                    for(i = point_cnt_old - 1; i < point_cnt; i++) {
+                        ser->points[i] = def;
+                    }
                 }
             }
         }
-
         ser->start_point = 0;
     }
 
@@ -540,6 +549,86 @@ void lv_chart_set_secondary_y_tick_texts(lv_obj_t * chart, const char * list_of_
     ext->secondary_y_axis.options        = options;
 }
 
+/**
+ * Set the index of the x-axis start point in the data array
+ * @param chart             pointer to a chart object
+ * @param ser               pointer to a data series on 'chart'
+ * @param id                the index of the x point in the data array
+ */
+void lv_chart_set_x_start_point(lv_obj_t * chart, lv_chart_series_t * ser, uint16_t id)
+{
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(ser);
+
+    if(chart == NULL || ser == NULL) return;
+    lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
+    if(ext == NULL) return;
+    if(id >= ext->point_cnt) return;
+    ser->start_point = id;
+}
+
+/**
+ * Set an external array of data points to use for the chart
+ * NOTE: It is the users responsibility to make sure the point_cnt matches the external array size.
+ * @param chart             pointer to a chart object
+ * @param ser               pointer to a data series on 'chart'
+ * @param array             external array of points for chart
+ * @param point_cnt         number of external points in the array
+ */
+void lv_chart_set_ext_array(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t array[], uint16_t point_cnt)
+{
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(ser);
+
+    if(chart == NULL || ser == NULL) return;
+    lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
+    if(!ser->ext_buf_assigned && ser->points) lv_mem_free(ser->points);
+    ser->ext_buf_assigned = true;
+    ser->points = array;
+    ext->point_cnt = point_cnt;
+}
+
+/**
+ * Set an individual point y value in the chart series directly based on index
+ * @param chart             pointer to a chart object
+ * @param ser               pointer to a data series on 'chart'
+ * @param value             value to assign to array point
+ * @param id                the index of the x point in the array
+ */
+void lv_chart_set_point_id(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t value, uint16_t id)
+{
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(ser);
+
+    if(chart == NULL || ser == NULL) return;
+    lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
+    if(ext == NULL) return;
+    if(id >= ext->point_cnt) return;
+    ser->points[id] = value;
+}
+
+/**
+ * Set the Y axis of a series
+ * @param chart pointer to a chart object
+ * @param ser pointer to series
+ * @param axis `LV_CHART_AXIS_PRIMARY_Y` or `LV_CHART_AXIS_SECONDARY_Y`
+ */
+void lv_chart_set_series_axis(lv_obj_t * chart, lv_chart_series_t * ser, lv_chart_axis_t axis)
+{
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(ser);
+
+    if(axis >= _LV_CHART_AXIS_LAST) {
+        LV_LOG_WARN("Invalid axis: %d", axis);
+        return;
+    }
+
+    if(ser->y_axis == axis) return;
+
+    ser->y_axis = axis;
+    lv_chart_refresh(chart);
+}
+
 /*=====================
  * Getter functions
  *====================*/
@@ -570,6 +659,49 @@ uint16_t lv_chart_get_point_count(const lv_obj_t * chart)
     return ext->point_cnt;
 }
 
+/**
+ * Get the current index of the x-axis start point in the data array
+ * @param ser               pointer to a data series on 'chart'
+ * @return                  the index of the current x start point in the data array
+ */
+uint16_t lv_chart_get_x_start_point(lv_chart_series_t * ser)
+{
+    LV_ASSERT_NULL(ser);
+
+    return(ser->start_point);
+}
+
+/**
+ * Get an individual point y value in the chart series directly based on index
+ * @param chart             pointer to a chart object
+ * @param ser               pointer to a data series on 'chart'
+ * @param id                the index of the x point in the array
+ * @return                  value of array point at index id
+ */
+lv_coord_t lv_chart_get_point_id(lv_obj_t * chart, lv_chart_series_t * ser, uint16_t id)
+{
+    LV_ASSERT_OBJ(chart, LV_OBJX_NAME);
+    LV_ASSERT_NULL(ser);
+
+    lv_chart_ext_t * ext = lv_obj_get_ext_attr(chart);
+    if(id >= ext->point_cnt) id = 0;
+    return(ser->points[id]);
+
+}
+
+/**
+ * Get the Y axis of a series
+ * @param chart pointer to a chart object
+ * @param ser pointer to series
+ * @return `LV_CHART_AXIS_PRIMARY_Y` or `LV_CHART_AXIS_SECONDARY_Y`
+ */
+lv_chart_axis_t lv_chart_get_series_axis(lv_obj_t * chart, lv_chart_series_t * ser)
+{
+    LV_ASSERT_NULL(ser);
+    LV_UNUSED(chart);
+
+    return ser->y_axis;
+}
 /*=====================
  * Other functions
  *====================*/
@@ -651,8 +783,12 @@ static lv_res_t lv_chart_signal(lv_obj_t * chart, lv_signal_t sign, void * param
 
     if(sign == LV_SIGNAL_CLEANUP) {
         lv_chart_series_t * ser;
-        _LV_LL_READ(ext->series_ll, ser) {
-            lv_mem_free(ser->points);
+        while(ext->series_ll.head != NULL) {
+            ser = _lv_ll_get_head(&ext->series_ll);
+
+            if(!ser->ext_buf_assigned) lv_mem_free(ser->points);
+
+            _lv_ll_remove(&ext->series_ll, ser);
             lv_mem_free(ser);
         }
         _lv_ll_clear(&ext->series_ll);
@@ -837,8 +973,8 @@ static void draw_series_line(lv_obj_t * chart, const lv_area_t * series_area, co
 
         lv_coord_t p_act = start_point;
         lv_coord_t p_prev = start_point;
-        int32_t y_tmp = (int32_t)((int32_t)ser->points[p_prev] - ext->ymin) * h;
-        y_tmp  = y_tmp / (ext->ymax - ext->ymin);
+        int32_t y_tmp = (int32_t)((int32_t)ser->points[p_prev] - ext->ymin[ser->y_axis]) * h;
+        y_tmp  = y_tmp / (ext->ymax[ser->y_axis] - ext->ymin[ser->y_axis]);
         p2.y   = h - y_tmp + y_ofs;
 
         for(i = 0; i < ext->point_cnt; i++) {
@@ -849,8 +985,8 @@ static void draw_series_line(lv_obj_t * chart, const lv_area_t * series_area, co
 
             p_act = (start_point + i) % ext->point_cnt;
 
-            y_tmp = (int32_t)((int32_t)ser->points[p_act] - ext->ymin) * h;
-            y_tmp = y_tmp / (ext->ymax - ext->ymin);
+            y_tmp = (int32_t)((int32_t)ser->points[p_act] - ext->ymin[ser->y_axis]) * h;
+            y_tmp = y_tmp / (ext->ymax[ser->y_axis] - ext->ymin[ser->y_axis]);
             p2.y  = h - y_tmp + y_ofs;
 
             /*Don't draw the first point. A second point is also required to draw the line*/
@@ -973,8 +1109,8 @@ static void draw_series_column(lv_obj_t * chart, const lv_area_t * series_area,
             col_dsc.bg_color = ser->color;
 
             lv_coord_t p_act = (start_point + i) % ext->point_cnt;
-            y_tmp            = (int32_t)((int32_t)ser->points[p_act] - ext->ymin) * h;
-            y_tmp            = y_tmp / (ext->ymax - ext->ymin);
+            y_tmp            = (int32_t)((int32_t)ser->points[p_act] - ext->ymin[ser->y_axis]) * h;
+            y_tmp            = y_tmp / (ext->ymax[ser->y_axis] - ext->ymin[ser->y_axis]);
             col_a.y1         = h - y_tmp + series_area->y1;
 
             if(ser->points[p_act] != LV_CHART_POINT_DEF) {
@@ -1371,6 +1507,9 @@ static void invalidate_lines(lv_obj_t * chart, uint16_t i)
 
     lv_area_t coords;
     lv_area_copy(&coords, &series_area);
+    coords.y1 -= line_width + point_radius;
+    coords.y2 += line_width + point_radius;
+
     if(i < ext->point_cnt - 1) {
         coords.x1 = ((w * i) / (ext->point_cnt - 1)) + x_ofs - line_width - point_radius;
         coords.x2 = ((w * (i + 1)) / (ext->point_cnt - 1)) + x_ofs + line_width + point_radius;

src/lv_widgets/lv_chart.h

@@ -42,6 +42,7 @@ enum {
     LV_CHART_TYPE_NONE     = 0x00, /**< Don't draw the series*/
     LV_CHART_TYPE_LINE     = 0x01, /**< Connect the points with lines*/
     LV_CHART_TYPE_COLUMN   = 0x02, /**< Draw columns*/
+    LV_CHART_TYPE_SCATTER  = 0x03, /**< X/Y chart, points and/or lines*/
 };
 typedef uint8_t lv_chart_type_t;
 
@@ -52,17 +53,27 @@ enum {
 };
 typedef uint8_t lv_chart_update_mode_t;
 
+
+enum {
+    LV_CHART_AXIS_PRIMARY_Y,
+    LV_CHART_AXIS_SECONDARY_Y,
+    _LV_CHART_AXIS_LAST,
+};
+typedef uint8_t lv_chart_axis_t;
+
 typedef struct {
     lv_coord_t * points;
     lv_color_t color;
     uint16_t start_point;
+    uint8_t ext_buf_assigned : 1;
+    lv_chart_axis_t y_axis  : 1;
 } lv_chart_series_t;
 
 /** Data of axis */
 enum {
     LV_CHART_AXIS_SKIP_LAST_TICK = 0x00,            /**< don't draw the last tick */
     LV_CHART_AXIS_DRAW_LAST_TICK = 0x01,            /**< draw the last tick */
-    LV_CHART_AXIS_INVERSE_LABELS_ORDER = 0x02       /**< draw tick labels in an inversed order*/
+    LV_CHART_AXIS_INVERSE_LABELS_ORDER = 0x02       /**< draw tick labels in an inverted order*/
 };
 typedef uint8_t lv_chart_axis_options_t;
 
@@ -79,8 +90,8 @@ typedef struct {
     /*No inherited ext*/ /*Ext. of ancestor*/
     /*New data for this type */
     lv_ll_t series_ll;    /*Linked list for the data line pointers (stores lv_chart_series_t)*/
-    lv_coord_t ymin;      /*y min value (used to scale the data)*/
-    lv_coord_t ymax;      /*y max value (used to scale the data)*/
+    lv_coord_t ymin[_LV_CHART_AXIS_LAST];      /*y min values for both axis (used to scale the data)*/
+    lv_coord_t ymax[_LV_CHART_AXIS_LAST];      /*y max values for both axis  (used to scale the data)*/
     uint8_t hdiv_cnt;     /*Number of horizontal division lines*/
     uint8_t vdiv_cnt;     /*Number of vertical division lines*/
     uint16_t point_cnt;   /*Point number in a data line*/
@@ -136,6 +147,7 @@ void lv_chart_clear_serie(lv_obj_t * chart, lv_chart_series_t * serie);
  * Setter functions
  *====================*/
 
+
 /**
  * Set the number of horizontal and vertical division lines
  * @param chart pointer to a graph background object
@@ -145,12 +157,13 @@ void lv_chart_clear_serie(lv_obj_t * chart, lv_chart_series_t * serie);
 void lv_chart_set_div_line_count(lv_obj_t * chart, uint8_t hdiv, uint8_t vdiv);
 
 /**
- * Set the minimal and maximal y values
+ * Set the minimal and maximal y values on an axis
  * @param chart pointer to a graph background object
+ * @param axis `LV_CHART_AXIS_PRIMARY_Y` or `LV_CHART_AXIS_SECONDARY_Y`
  * @param ymin y minimum value
  * @param ymax y maximum value
  */
-void lv_chart_set_range(lv_obj_t * chart, lv_coord_t ymin, lv_coord_t ymax);
+void lv_chart_set_y_range(lv_obj_t * chart, lv_chart_axis_t axis, lv_coord_t ymin, lv_coord_t ymax);
 
 /**
  * Set a new type for a chart
@@ -260,6 +273,40 @@ void lv_chart_set_secondary_y_tick_texts(lv_obj_t * chart, const char * list_of_
 void lv_chart_set_y_tick_texts(lv_obj_t * chart, const char * list_of_values, uint8_t num_tick_marks,
                                lv_chart_axis_options_t options);
 
+/**
+ * Set the index of the x-axis start point in the data array
+ * @param chart             pointer to a chart object
+ * @param ser               pointer to a data series on 'chart'
+ * @param id                the index of the x point in the data array
+ */
+void lv_chart_set_x_start_point(lv_obj_t * chart, lv_chart_series_t * ser, uint16_t id);
+
+/**
+ * Set an external array of data points to use for the chart
+ * NOTE: It is the users responsibility to make sure the point_cnt matches the external array size.
+ * @param chart             pointer to a chart object
+ * @param ser               pointer to a data series on 'chart'
+ * @param array             external array of points for chart
+ */
+void lv_chart_set_ext_array(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t array[], uint16_t point_cnt);
+
+/**
+ * Set an individual point value in the chart series directly based on index
+ * @param chart             pointer to a chart object
+ * @param ser               pointer to a data series on 'chart'
+ * @param value             value to assign to array point
+ * @param id                the index of the x point in the array
+ */
+void lv_chart_set_point_id(lv_obj_t * chart, lv_chart_series_t * ser, lv_coord_t value, uint16_t id);
+
+/**
+ * Set the Y axis of a series
+ * @param chart pointer to a chart object
+ * @param ser pointer to series
+ * @param axis `LV_CHART_AXIS_PRIMARY_Y` or `LV_CHART_AXIS_SECONDARY_Y`
+ */
+void lv_chart_set_series_axis(lv_obj_t * chart, lv_chart_series_t * ser, lv_chart_axis_t axis);
+
 /*=====================
  * Getter functions
  *====================*/
@@ -278,6 +325,30 @@ lv_chart_type_t lv_chart_get_type(const lv_obj_t * chart);
  */
 uint16_t lv_chart_get_point_count(const lv_obj_t * chart);
 
+/**
+ * get the current index of the x-axis start point in the data array
+ * @param ser               pointer to a data series on 'chart'
+ * @return                  the index of the current x start point in the data array
+ */
+uint16_t lv_chart_get_x_start_point(lv_chart_series_t * ser);
+
+/**
+ * Get an individual point value in the chart series directly based on index
+ * @param chart             pointer to a chart object
+ * @param ser               pointer to a data series on 'chart'
+ * @param id                the index of the x point in the array
+ * @return                  value of array point at index id
+ */
+lv_coord_t lv_chart_get_point_id(lv_obj_t * chart, lv_chart_series_t * ser, uint16_t id);
+
+/**
+ * Get the Y axis of a series
+ * @param chart pointer to a chart object
+ * @param ser pointer to series
+ * @return `LV_CHART_AXIS_PRIMARY_Y` or `LV_CHART_AXIS_SECONDARY_Y`
+ */
+lv_chart_axis_t lv_chart_get_series_axis(lv_obj_t * chart, lv_chart_series_t * ser);
+
 /*=====================
  * Other functions
  *====================*/

src/lv_widgets/lv_checkbox.c

@@ -193,11 +193,13 @@ static lv_res_t lv_checkbox_signal(lv_obj_t * cb, lv_signal_t sign, void * param
         lv_obj_set_state(ext->bullet, lv_obj_get_state(cb, LV_CHECKBOX_PART_BG));
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         char c = *((char *)param);
         if(c == LV_KEY_RIGHT || c == LV_KEY_DOWN || c == LV_KEY_LEFT || c == LV_KEY_UP) {
             /*Follow the backgrounds state with the bullet*/
             lv_obj_set_state(ext->bullet, lv_obj_get_state(cb, LV_CHECKBOX_PART_BG));
         }
+#endif
     }
 
     return res;

src/lv_widgets/lv_checkbox.h

@@ -106,6 +106,15 @@ static inline void lv_checkbox_set_disabled(lv_obj_t * cb)
     lv_btn_set_state(cb, LV_BTN_STATE_DISABLED);
 }
 
+/**
+ * Set the state of a check box
+ * @param cb pointer to a check box object
+ * @param state the new state of the check box (from lv_btn_state_t enum)
+ */
+static inline void lv_checkbox_set_state(lv_obj_t * cb, lv_btn_state_t state)
+{
+    lv_btn_set_state(cb, state);
+}
 /*=====================
  * Getter functions
  *====================*/
@@ -137,6 +146,15 @@ static inline bool lv_checkbox_is_inactive(const lv_obj_t * cb)
     return lv_btn_get_state(cb) == LV_BTN_STATE_DISABLED ? true : false;
 }
 
+/**
+ * Get the current state of a check box
+ * @param cb pointer to a check box object
+ * @return the state of the check box (from lv_btn_state_t enum)
+ */
+static inline lv_btn_state_t lv_checkbox_get_state(const lv_obj_t * cb)
+{
+    return lv_btn_get_state(cb);
+}
 
 /**********************
  *      MACROS

src/lv_widgets/lv_cont.c

@@ -628,7 +628,7 @@ static void lv_cont_layout_grid(lv_obj_t * cont)
     _LV_LL_READ_BACK(cont->child_ll, child) {
         if(lv_obj_get_hidden(child) != false || lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
         lv_coord_t obj_w = lv_obj_get_width(child);
-        if(act_x + inner + obj_w > w_fit) {
+        if(act_x + obj_w > w_fit + left) {
             act_x = left;
             act_y += y_ofs;
         }

src/lv_widgets/lv_cpicker.c

@@ -48,6 +48,13 @@
 
 #define TRI_OFFSET 2
 
+/* The OUTER_MASK_WIDTH define is required to assist with the placing of a mask over the outer ring of the widget as when the
+ * multicoloured radial lines are calculated for the outer ring of the widget their lengths are jittering because of the
+ * integer based arithmetic. From tests the maximum delta was found to be 2 so the current value is set to 3 to achieve
+ * appropriate masking.
+ */
+#define OUTER_MASK_WIDTH 3
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -483,6 +490,17 @@ static void draw_disc_grad(lv_obj_t * cpicker, const lv_area_t * mask)
     uint16_t i;
     lv_coord_t cir_w = lv_obj_get_style_scale_width(cpicker, LV_CPICKER_PART_MAIN);
 
+    /* Mask outer ring of widget to tidy up ragged edges of lines while drawing outer ring */
+    lv_area_t mask_area_out;
+    lv_area_copy(&mask_area_out, &cpicker->coords);
+    mask_area_out.x1 += OUTER_MASK_WIDTH;
+    mask_area_out.x2 -= OUTER_MASK_WIDTH;
+    mask_area_out.y1 += OUTER_MASK_WIDTH;
+    mask_area_out.y2 -= OUTER_MASK_WIDTH;
+    lv_draw_mask_radius_param_t mask_out_param;
+    lv_draw_mask_radius_init(&mask_out_param, &mask_area_out, LV_RADIUS_CIRCLE, false);
+    int16_t mask_out_id = lv_draw_mask_add(&mask_out_param, 0);
+
     /* The inner line ends will be masked out.
      * So make lines a little bit longer because the masking makes a more even result */
     lv_coord_t cir_w_extra = cir_w + line_dsc.width;
@@ -498,7 +516,8 @@ static void draw_disc_grad(lv_obj_t * cpicker, const lv_area_t * mask)
 
         lv_draw_line(&p[0], &p[1], mask, &line_dsc);
     }
-
+    /* Now remove mask to continue with inner part */
+    lv_draw_mask_remove_id(mask_out_id);
 
     /*Mask out the inner area*/
     lv_draw_rect_dsc_t bg_dsc;
@@ -701,6 +720,7 @@ static lv_res_t lv_cpicker_signal(lv_obj_t * cpicker, lv_signal_t sign, void * p
         lv_obj_invalidate(cpicker);
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         uint32_t c = *((uint32_t *)param); /*uint32_t because can be UTF-8*/
 
         if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
@@ -745,6 +765,7 @@ static lv_res_t lv_cpicker_signal(lv_obj_t * cpicker, lv_signal_t sign, void * p
                 if(res != LV_RES_OK) return res;
             }
         }
+#endif
     }
     else if(sign == LV_SIGNAL_PRESSED) {
         ext->last_change_time = lv_tick_get();

src/lv_widgets/lv_dropdown.c

@@ -968,6 +968,7 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
         if(ext->page) lv_obj_refresh_style(ext->page, LV_STYLE_PROP_ALL);
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         char c = *((char *)param);
         if(c == LV_KEY_RIGHT || c == LV_KEY_DOWN) {
             if(ext->page == NULL) {
@@ -992,10 +993,13 @@ static lv_res_t lv_dropdown_signal(lv_obj_t * ddlist, lv_signal_t sign, void * p
             ext->sel_opt_id = ext->sel_opt_id_orig;
             lv_dropdown_close(ddlist);
         }
+#endif
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
+#if LV_USE_GROUP
         bool * editable = (bool *)param;
         *editable       = true;
+#endif
     }
 
     return res;

src/lv_widgets/lv_gauge.c

@@ -589,15 +589,6 @@ static void lv_gauge_draw_needle(lv_obj_t * gauge, const lv_area_t * clip_area)
     lv_draw_line_dsc_init(&line_dsc);
     lv_obj_init_draw_line_dsc(gauge, LV_GAUGE_PART_NEEDLE, &line_dsc);
 
-    lv_draw_img_dsc_t img_dsc;
-    if(ext->needle_img == NULL) {
-        lv_draw_img_dsc_init(&img_dsc);
-        lv_obj_init_draw_img_dsc(gauge, LV_GAUGE_PART_MAIN, &img_dsc);
-        img_dsc.recolor_opa = LV_OPA_COVER;
-        img_dsc.pivot.x = ext->needle_img_pivot.x;
-        img_dsc.pivot.y = ext->needle_img_pivot.y;
-    }
-
     p_mid.x = x_ofs;
     p_mid.y = y_ofs;
     for(i = 0; i < ext->needle_count; i++) {
@@ -625,10 +616,18 @@ static void lv_gauge_draw_needle(lv_obj_t * gauge, const lv_area_t * clip_area)
             a.y1 = gauge->coords.y1 + lv_area_get_height(&gauge->coords) / 2  - ext->needle_img_pivot.y;
             a.x2 = a.x1 + info.w - 1;
             a.y2 = a.y1 + info.h - 1;
+            lv_draw_img_dsc_t img_dsc;
+            lv_draw_img_dsc_init(&img_dsc);
+            lv_obj_init_draw_img_dsc(gauge, LV_GAUGE_PART_MAIN, &img_dsc);
+            img_dsc.recolor_opa = LV_OPA_COVER;
+            img_dsc.pivot.x = ext->needle_img_pivot.x;
+            img_dsc.pivot.y = ext->needle_img_pivot.y;
 
             if(ext->needle_colors != NULL)
                 img_dsc.recolor = ext->needle_colors[i];
 
+            needle_angle = (needle_angle * 10);
+            if(needle_angle > 3600) needle_angle -= 3600;
             img_dsc.angle = needle_angle;
             lv_draw_img(&a, clip_area, ext->needle_img, &img_dsc);
         }

src/lv_widgets/lv_img.c

@@ -340,10 +340,9 @@ void lv_img_set_angle(lv_obj_t * img, int16_t angle)
     transf_zoom = (transf_zoom * ext->zoom) >> 8;
 
     lv_style_int_t transf_angle = lv_obj_get_style_transform_angle(img, LV_IMG_PART_MAIN);
-    transf_angle += ext->angle;
 
     lv_area_t a;
-    _lv_img_buf_get_transformed_area(&a, ext->w, ext->h, transf_angle, transf_zoom, &ext->pivot);
+    _lv_img_buf_get_transformed_area(&a, ext->w, ext->h, transf_angle + ext->angle, transf_zoom, &ext->pivot);
     a.x1 += img->coords.x1;
     a.y1 += img->coords.y1;
     a.x2 += img->coords.x1;
@@ -353,7 +352,7 @@ void lv_img_set_angle(lv_obj_t * img, int16_t angle)
     ext->angle = angle;
     lv_obj_refresh_ext_draw_pad(img);
 
-    _lv_img_buf_get_transformed_area(&a, ext->w, ext->h, transf_angle, transf_zoom, &ext->pivot);
+    _lv_img_buf_get_transformed_area(&a, ext->w, ext->h, transf_angle + ext->angle, transf_zoom, &ext->pivot);
     a.x1 += img->coords.x1;
     a.y1 += img->coords.y1;
     a.x2 += img->coords.x1;
@@ -379,13 +378,12 @@ void lv_img_set_zoom(lv_obj_t * img, uint16_t zoom)
     if(zoom == 0) zoom = 1;
 
     lv_style_int_t transf_zoom = lv_obj_get_style_transform_zoom(img, LV_IMG_PART_MAIN);
-    transf_zoom = (transf_zoom * ext->zoom) >> 8;
 
     lv_style_int_t transf_angle = lv_obj_get_style_transform_angle(img, LV_IMG_PART_MAIN);
     transf_angle += ext->angle;
 
     lv_area_t a;
-    _lv_img_buf_get_transformed_area(&a, ext->w, ext->h, transf_angle, transf_zoom, &ext->pivot);
+    _lv_img_buf_get_transformed_area(&a, ext->w, ext->h, transf_angle, (transf_zoom * ext->zoom) >> 8, &ext->pivot);
     a.x1 += img->coords.x1;
     a.y1 += img->coords.y1;
     a.x2 += img->coords.x1;
@@ -395,7 +393,7 @@ void lv_img_set_zoom(lv_obj_t * img, uint16_t zoom)
     ext->zoom = zoom;
     lv_obj_refresh_ext_draw_pad(img);
 
-    _lv_img_buf_get_transformed_area(&a, ext->w, ext->h, transf_angle, transf_zoom, &ext->pivot);
+    _lv_img_buf_get_transformed_area(&a, ext->w, ext->h, transf_angle, (transf_zoom * ext->zoom) >> 8, &ext->pivot);
     a.x1 += img->coords.x1;
     a.y1 += img->coords.y1;
     a.x2 += img->coords.x1;
@@ -587,7 +585,8 @@ static lv_design_res_t lv_img_design(lv_obj_t * img, const lv_area_t * clip_area
 
         if(zoom_final != LV_IMG_ZOOM_NONE) {
             if(_lv_area_is_in(clip_area, &img->coords, 0) == false) return LV_DESIGN_RES_NOT_COVER;
-        } else {
+        }
+        else {
             lv_area_t a;
             _lv_img_buf_get_transformed_area(&a, lv_obj_get_width(img), lv_obj_get_height(img), 0, zoom_final, &ext->pivot);
             a.x1 += img->coords.x1;
@@ -794,21 +793,24 @@ static lv_res_t lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
     }
     else if(sign == LV_SIGNAL_HIT_TEST) {
         lv_hit_test_info_t * info = param;
-        if(ext->zoom != 256 && ext->angle == 0) {
-            lv_coord_t origin_width = lv_area_get_width(&img->coords);
-            lv_coord_t origin_height = lv_area_get_height(&img->coords);
-            lv_coord_t scaled_width = (origin_width * ext->zoom + 255) / 256;
-            lv_coord_t scaled_height = (origin_height * ext->zoom + 255) / 256;
+        lv_style_int_t zoom = lv_obj_get_style_transform_zoom(img, LV_IMG_PART_MAIN);
+        zoom = (zoom * ext->zoom) >> 8;
 
-            lv_coord_t width_offset = (origin_width - scaled_width) / 2;
-            lv_coord_t height_offset = (origin_height - scaled_height) / 2;
+        lv_style_int_t angle = lv_obj_get_style_transform_angle(img, LV_IMG_PART_MAIN);
+        angle += ext->angle;
+
+        /* If the object is exactly image sized (not cropped, not mosaic) and transformed
+         * perform hit test on it's transformed area */
+        if(ext->w == lv_obj_get_width(img) && ext->h == lv_obj_get_height(img) &&
+           (zoom != LV_IMG_ZOOM_NONE || angle != 0 || ext->pivot.x != ext->w / 2 || ext->pivot.y != ext->h / 2)) {
 
             lv_area_t coords;
-            lv_area_copy(&coords, &img->coords);
-            coords.x1 += width_offset;
-            coords.x2 -= width_offset;
-            coords.y1 += height_offset;
-            coords.y2 -= height_offset;
+            _lv_img_buf_get_transformed_area(&coords, ext->w, ext->h, angle, zoom, &ext->pivot);
+            coords.x1 += img->coords.x1;
+            coords.y1 += img->coords.y1;
+            coords.x2 += img->coords.x1;
+            coords.y2 += img->coords.y1;
+
             info->result = _lv_area_is_point_on(&coords, info->point, 0);
         }
         else

src/lv_widgets/lv_label.c

@@ -572,10 +572,21 @@ void lv_label_get_letter_pos(const lv_obj_t * label, uint32_t char_id, lv_point_
     LV_ASSERT_NULL(pos);
 
     const char * txt         = lv_label_get_text(label);
+    lv_label_align_t align = lv_label_get_align(label);
 
     if(txt[0] == '\0') {
-        pos->x = 0;
         pos->y = 0;
+        switch(align) {
+            case LV_LABEL_ALIGN_LEFT:
+                pos->x = 0;
+                break;
+            case LV_LABEL_ALIGN_RIGHT:
+                pos->x = lv_obj_get_width(label);
+                break;
+            case LV_LABEL_ALIGN_CENTER:
+                pos->x = lv_obj_get_width(label) / 2;
+                break;
+        }
         return;
     }
 
@@ -597,7 +608,6 @@ void lv_label_get_letter_pos(const lv_obj_t * label, uint32_t char_id, lv_point_
     if(ext->expand != 0) flag |= LV_TXT_FLAG_EXPAND;
     if(ext->long_mode == LV_LABEL_LONG_EXPAND) flag |= LV_TXT_FLAG_FIT;
 
-    lv_label_align_t align = lv_label_get_align(label);
     if(align == LV_LABEL_ALIGN_CENTER) flag |= LV_TXT_FLAG_CENTER;
     if(align == LV_LABEL_ALIGN_RIGHT) flag |= LV_TXT_FLAG_RIGHT;
 
@@ -785,7 +795,8 @@ uint32_t lv_label_get_letter_on(const lv_obj_t * label, lv_point_t * pos)
     uint32_t cid = _lv_txt_encoded_get_char_id(bidi_txt, i);
     if(txt[line_start + cid] == '\0') {
         logical_pos = i;
-    } else {
+    }
+    else {
         bool is_rtl;
         logical_pos = _lv_bidi_get_logical_pos(&txt[line_start], NULL,
                                                txt_len, lv_obj_get_base_dir(label), cid, &is_rtl);

src/lv_widgets/lv_linemeter.c

@@ -126,9 +126,9 @@ void lv_linemeter_set_value(lv_obj_t * lmeter, int32_t value)
     ext->cur_value = ext->cur_value < ext->min_value ? ext->min_value : ext->cur_value;
 
     int16_t level_old =
-        (int32_t)((int32_t)(old_value - ext->min_value) * ext->line_cnt) / (ext->max_value - ext->min_value);
+        (int32_t)((int32_t)(old_value - ext->min_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value);
     int16_t level_new =
-        (int32_t)((int32_t)(ext->cur_value - ext->min_value) * ext->line_cnt) / (ext->max_value - ext->min_value);
+        (int32_t)((int32_t)(ext->cur_value - ext->min_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value);
 
     if(level_new == level_old) {
         return;
@@ -393,7 +393,7 @@ void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uin
     lv_coord_t y_ofs  = lmeter->coords.y1 + r_out + top;
     int16_t angle_ofs = ext->angle_ofs + 90 + (360 - ext->scale_angle) / 2;
     int16_t level =
-        (int32_t)((int32_t)(ext->cur_value - ext->min_value) * ext->line_cnt) / (ext->max_value - ext->min_value);
+        (int32_t)((int32_t)(ext->cur_value - ext->min_value) * (ext->line_cnt - 1)) / (ext->max_value - ext->min_value);
     uint8_t i;
 
     lv_color_t main_color = lv_obj_get_style_line_color(lmeter, part);
@@ -519,7 +519,8 @@ void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uin
         p1.x = x_out_extra;
         p1.y = y_out_extra;
 
-        if(i >= level) {
+        /* Set the color of the lines */
+        if(i > level) {
             line_dsc.color = end_color;
             line_dsc.width = end_line_width;
         }
@@ -538,12 +539,12 @@ void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uin
     lv_draw_mask_remove_id(mask_out_id);
 #endif
 
-    if(part == LV_LINEMETER_PART_MAIN) {
+    if(part == LV_LINEMETER_PART_MAIN && level + 1 < ext->line_cnt - 1) {
         lv_style_int_t border_width = lv_obj_get_style_scale_border_width(lmeter, part);
         lv_style_int_t end_border_width = lv_obj_get_style_scale_end_border_width(lmeter, part);
 
         if(border_width || end_border_width) {
-            int16_t end_angle = (level * ext->scale_angle) / (ext->line_cnt - 1) + angle_ofs - 1;
+            int16_t end_angle = ((level + 1) * ext->scale_angle) / (ext->line_cnt - 1) + angle_ofs;
             lv_draw_line_dsc_t arc_dsc;
             lv_draw_line_dsc_init(&arc_dsc);
             lv_obj_init_draw_line_dsc(lmeter, part, &arc_dsc);
@@ -559,8 +560,6 @@ void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uin
                 arc_dsc.color = end_color;
                 lv_draw_arc(x_ofs, y_ofs, r_out, end_angle, (angle_ofs + ext->scale_angle) % 360, clip_area, &arc_dsc);
             }
-
-
         }
     }
 
@@ -570,7 +569,6 @@ void lv_linemeter_draw_scale(lv_obj_t * lmeter, const lv_area_t * clip_area, uin
 /**********************
  *   STATIC FUNCTIONS
  **********************/
-#include <stdlib.h>
 
 /**
  * Handle the drawing related tasks of the line meters

src/lv_widgets/lv_list.c

@@ -462,7 +462,6 @@ lv_obj_t * lv_list_get_next_btn(const lv_obj_t * list, lv_obj_t * prev_btn)
  */
 int32_t lv_list_get_btn_index(const lv_obj_t * list, const lv_obj_t * btn)
 {
-    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
     LV_ASSERT_OBJ(btn, "lv_btn");
 
     int index = 0;
@@ -470,6 +469,8 @@ int32_t lv_list_get_btn_index(const lv_obj_t * list, const lv_obj_t * btn)
         /* no list provided, assuming btn is part of a list */
         list = lv_obj_get_parent(lv_obj_get_parent(btn));
     }
+    LV_ASSERT_OBJ(list, LV_OBJX_NAME);
+
     lv_obj_t * e = lv_list_get_next_btn(list, NULL);
     while(e != NULL) {
         if(e == btn) {
@@ -494,7 +495,7 @@ uint16_t lv_list_get_size(const lv_obj_t * list)
     lv_obj_t * btn = lv_list_get_next_btn(list, NULL);
     while(btn) {
         size++;
-        btn = lv_list_get_next_btn(list, NULL);
+        btn = lv_list_get_next_btn(list, btn);
     }
     return size;
 }
@@ -712,6 +713,11 @@ static lv_res_t lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
             if(ext->last_sel_btn) lv_list_focus_btn(list, ext->last_sel_btn);
             else lv_list_focus_btn(list, lv_list_get_next_btn(list, NULL));
         }
+        if(indev_type == LV_INDEV_TYPE_ENCODER && lv_group_get_editing(g) == false) {
+            lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
+            if(ext->act_sel_btn) lv_obj_clear_state(ext->act_sel_btn, LV_STATE_PRESSED);
+            if(ext->last_sel_btn) lv_obj_clear_state(ext->last_sel_btn, LV_STATE_PRESSED);
+        }
 #endif
     }
     else if(sign == LV_SIGNAL_DEFOCUS) {
@@ -724,8 +730,10 @@ static lv_res_t lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
 #endif
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
+#if LV_USE_GROUP
         bool * editable = (bool *)param;
         *editable       = true;
+#endif
     }
     else if(sign == LV_SIGNAL_CONTROL) {
 
@@ -759,6 +767,11 @@ static lv_res_t lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
                 if(btn) lv_list_focus_btn(list, btn);
             }
         }
+        else if(c == LV_KEY_ESC) {
+            lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
+            /* Handle ESC/Cancel event */
+            res = lv_event_send(ext->act_sel_btn, LV_EVENT_CANCEL, NULL);
+        }
 #endif
     }
     return res;
@@ -811,8 +824,10 @@ static lv_res_t lv_list_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * para
     else if(sign == LV_SIGNAL_CLEANUP) {
 #if LV_USE_GROUP
         lv_obj_t * list = lv_obj_get_parent(lv_obj_get_parent(btn));
+        lv_list_ext_t * ext = lv_obj_get_ext_attr(list);
         lv_obj_t * sel  = lv_list_get_btn_selected(list);
         if(sel == btn) lv_list_focus_btn(list, lv_list_get_next_btn(list, btn));
+        if(ext->last_sel_btn == btn) ext->last_sel_btn = NULL;
 #endif
     }
 

src/lv_widgets/lv_msgbox.c

@@ -412,6 +412,7 @@ static lv_res_t lv_msgbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param
 {
     lv_res_t res;
 
+#if LV_USE_GROUP
     /*Translate LV_KEY_UP/DOWN to LV_KEY_LEFT/RIGHT */
     char c_trans = 0;
     if(sign == LV_SIGNAL_CONTROL) {
@@ -421,6 +422,7 @@ static lv_res_t lv_msgbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param
 
         param = &c_trans;
     }
+#endif
 
     if(sign == LV_SIGNAL_GET_STYLE) {
         lv_get_style_info_t * info = param;
@@ -460,8 +462,11 @@ static lv_res_t lv_msgbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param
             if(btn_id != LV_BTNMATRIX_BTN_NONE) lv_event_send(mbox, LV_EVENT_VALUE_CHANGED, &btn_id);
         }
     }
-    else if(sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS || sign == LV_SIGNAL_CONTROL ||
-            sign == LV_SIGNAL_GET_EDITABLE) {
+    else if(
+#if LV_USE_GROUP
+        sign == LV_SIGNAL_CONTROL || sign == LV_SIGNAL_GET_EDITABLE ||
+#endif
+        sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS) {
         if(ext->btnm) {
             ext->btnm->signal_cb(ext->btnm, sign, param);
         }

src/lv_widgets/lv_objmask.c

@@ -171,6 +171,7 @@ void lv_objmask_remove_mask(lv_obj_t * objmask, lv_objmask_mask_t * mask)
     else {
         lv_mem_free(mask->param);
         _lv_ll_remove(&ext->mask_ll, mask);
+        lv_mem_free(mask);
     }
 
     lv_obj_invalidate(objmask);

src/lv_widgets/lv_page.c

@@ -402,7 +402,7 @@ lv_coord_t lv_page_get_width_grid(lv_obj_t * page, uint8_t div, uint8_t span)
 }
 
 /**
- * Divide the height of the object and get the width of a given number of columns.
+ * Divide the height of the object and get the height of a given number of rows.
  * Take into account the paddings of the background and scrollable too.
  * @param obj pointer to an object
  * @param div indicates how many rows are assumed.
@@ -485,6 +485,9 @@ void lv_page_focus(lv_obj_t * page, const lv_obj_t * obj, lv_anim_enable_t anim_
     lv_anim_del(ext->scrl, (lv_anim_exec_xcb_t)lv_obj_set_y);
 #endif
 
+    /*if using focus mode, change target to parent*/
+    obj = lv_obj_get_focused_obj(obj);
+
 
     /*If obj is higher then the page focus where the "error" is smaller*/
     lv_coord_t obj_y      = obj->coords.y1 - ext->scrl->coords.y1;
@@ -492,14 +495,14 @@ void lv_page_focus(lv_obj_t * page, const lv_obj_t * obj, lv_anim_enable_t anim_
     lv_coord_t scrlable_y = lv_obj_get_y(ext->scrl);
     lv_coord_t page_h     = lv_obj_get_height(page);
 
-    lv_coord_t top_err = -(scrlable_y + obj_y);
-    lv_coord_t bot_err = scrlable_y + obj_y + obj_h - page_h;
-
     lv_style_int_t bg_top = lv_obj_get_style_pad_top(page, LV_PAGE_PART_BG);
     lv_style_int_t bg_bottom = lv_obj_get_style_pad_bottom(page, LV_PAGE_PART_BG);
     lv_style_int_t scrl_top = lv_obj_get_style_pad_top(ext->scrl, LV_CONT_PART_MAIN);
     lv_style_int_t scrl_bottom = lv_obj_get_style_pad_bottom(ext->scrl, LV_CONT_PART_MAIN);
 
+    lv_coord_t top_err = -((scrlable_y + obj_y) - bg_top);
+    lv_coord_t bot_err = scrlable_y + obj_y + obj_h - (page_h - bg_bottom);
+
     /*Out of the page on the top*/
     if((obj_h <= page_h && top_err > 0) || (obj_h > page_h && top_err < bot_err)) {
         /*Calculate a new position and let some space above*/
@@ -521,14 +524,14 @@ void lv_page_focus(lv_obj_t * page, const lv_obj_t * obj, lv_anim_enable_t anim_
     lv_coord_t scrlable_x = lv_obj_get_x(ext->scrl);
     lv_coord_t page_w     = lv_obj_get_width(page);
 
-    lv_coord_t left_err  = -(scrlable_x + obj_x);
-    lv_coord_t right_err = scrlable_x + obj_x + obj_w - page_w;
-
     lv_style_int_t bg_left = lv_obj_get_style_pad_left(page, LV_PAGE_PART_BG);
     lv_style_int_t bg_right = lv_obj_get_style_pad_right(page, LV_PAGE_PART_BG);
     lv_style_int_t scrl_left = lv_obj_get_style_pad_top(ext->scrl, LV_CONT_PART_MAIN);
     lv_style_int_t scrl_right = lv_obj_get_style_pad_bottom(ext->scrl, LV_CONT_PART_MAIN);
 
+    lv_coord_t left_err  = -((scrlable_x + obj_x) - bg_left);
+    lv_coord_t right_err = scrlable_x + obj_x + obj_w - (page_w - bg_right);
+
     /*Out of the page on the left*/
     if((obj_w <= page_w && left_err > 0) || (obj_w > page_w && left_err < right_err)) {
         /*Calculate a new position and let some space on the side*/
@@ -856,6 +859,7 @@ static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
         refr_ext_draw_pad(page);
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         uint32_t c = *((uint32_t *)param);
 
         if(c == LV_KEY_DOWN) {
@@ -880,10 +884,13 @@ static lv_res_t lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
             else
                 lv_page_scroll_hor(page, lv_obj_get_width(page) / 4);
         }
+#endif
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
+#if LV_USE_GROUP
         bool * editable = (bool *)param;
         *editable       = true;
+#endif
     }
 
     return res;
@@ -1051,10 +1058,16 @@ static lv_res_t lv_page_scrollable_signal(lv_obj_t * scrl, lv_signal_t sign, voi
         }
     }
     else if(sign == LV_SIGNAL_DEFOCUS) {
-        res = lv_signal_send(page, LV_SIGNAL_DEFOCUS, NULL);
-        if(res != LV_RES_OK) return res;
-        res = lv_event_send(page, LV_EVENT_DEFOCUSED, NULL);
-        if(res != LV_RES_OK) return res;
+        bool in_group = false;
+#if LV_USE_GROUP
+        in_group =  lv_obj_get_group(page) ? true : false;
+#endif
+        if(in_group == false) {
+            res = lv_signal_send(page, LV_SIGNAL_DEFOCUS, NULL);
+            if(res != LV_RES_OK) return res;
+            res = lv_event_send(page, LV_EVENT_DEFOCUSED, NULL);
+            if(res != LV_RES_OK) return res;
+        }
     }
     else if(sign == LV_SIGNAL_CLEANUP) {
         page_ext->scrl = NULL;

src/lv_widgets/lv_page.h

@@ -171,7 +171,7 @@ void lv_page_set_edge_flash(lv_obj_t * page, bool en);
  * @param bottom bottom fit policy from `lv_fit_t`
  */
 static inline void lv_page_set_scrollable_fit4(lv_obj_t * page, lv_fit_t left, lv_fit_t right, lv_fit_t top,
-                                              lv_fit_t bottom)
+                                               lv_fit_t bottom)
 {
     lv_cont_set_fit4(lv_page_get_scrollable(page), left, right, top, bottom);
 }

src/lv_widgets/lv_roller.c

@@ -33,6 +33,7 @@
  *  STATIC PROTOTYPES
  **********************/
 static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * clip_area, lv_design_mode_t mode);
+static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_res_t lv_roller_scrl_signal(lv_obj_t * roller_scrl, lv_signal_t sign, void * param);
 static lv_style_list_t * lv_roller_get_style(lv_obj_t * roller, uint8_t part);
 static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * param);
@@ -51,6 +52,7 @@ static void draw_bg(lv_obj_t * roller, const lv_area_t * clip_area);
  *  STATIC VARIABLES
  **********************/
 static lv_signal_cb_t ancestor_signal;
+static lv_design_cb_t ancestor_label_design;
 static lv_signal_cb_t ancestor_scrl_signal;
 
 /**********************
@@ -103,7 +105,8 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
 
         lv_obj_t * label = lv_label_create(roller, NULL);
         lv_label_set_align(label, LV_LABEL_ALIGN_CENTER);
-
+        if(ancestor_label_design == NULL) ancestor_label_design = lv_obj_get_design_cb(label);
+        lv_obj_set_design_cb(label, lv_roller_label_design);
         lv_obj_t * scrl = lv_page_get_scrollable(roller);
         lv_obj_set_drag(scrl, true);
         lv_page_set_scrollable_fit2(roller, LV_FIT_PARENT, LV_FIT_NONE); /*Height is specified directly*/
@@ -120,11 +123,19 @@ lv_obj_t * lv_roller_create(lv_obj_t * par, const lv_obj_t * copy)
     }
     /*Copy an existing roller*/
     else {
+        lv_label_create(roller, get_label(copy));
+
         lv_roller_ext_t * copy_ext = lv_obj_get_ext_attr(copy);
-        lv_roller_set_options(roller, lv_roller_get_options(copy), copy_ext->mode);
+        ext->mode = copy_ext->mode;
+        ext->option_cnt = copy_ext->option_cnt;
+        ext->sel_opt_id = copy_ext->sel_opt_id;
+        ext->sel_opt_id_ori = copy_ext->sel_opt_id;
         ext->auto_fit = copy_ext->auto_fit;
         lv_obj_t * scrl = lv_page_get_scrollable(roller);
         lv_obj_set_signal_cb(scrl, lv_roller_scrl_signal);
+
+        lv_style_list_copy(&ext->style_sel, &copy_ext->style_sel);
+        lv_obj_refresh_style(roller, LV_STYLE_PROP_ALL);
     }
 
     LV_LOG_INFO("roller created");
@@ -180,17 +191,15 @@ void lv_roller_set_options(lv_obj_t * roller, const char * options, lv_roller_mo
         lv_label_set_text(label, opt_extra);
         _lv_mem_buf_release(opt_extra);
 
-        ext->sel_opt_id     = ((LV_ROLLER_INF_PAGES / 2) + 1) * ext->option_cnt;
+        ext->sel_opt_id     = ((LV_ROLLER_INF_PAGES / 2) + 0) * ext->option_cnt;
 
         ext->option_cnt = ext->option_cnt * LV_ROLLER_INF_PAGES;
     }
 
     ext->sel_opt_id_ori = ext->sel_opt_id;
 
-
-    //    refr_width(roller);
-    //    refr_height(roller);
-    refr_position(roller, LV_ANIM_OFF);
+    refr_height(roller);
+    refr_width(roller);
 }
 
 /**
@@ -408,7 +417,6 @@ const char * lv_roller_get_options(const lv_obj_t * roller)
  */
 static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * clip_area, lv_design_mode_t mode)
 {
-    /*Return false if the object is not covers the mask_p area*/
     if(mode == LV_DESIGN_COVER_CHK) {
         return LV_DESIGN_RES_NOT_COVER;
     }
@@ -441,13 +449,13 @@ static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * cli
         lv_draw_label_dsc_init(&label_dsc);
         lv_obj_init_draw_label_dsc(roller, LV_ROLLER_PART_SELECTED, &label_dsc);
 
-        lv_coord_t font_h        = lv_font_get_line_height(label_dsc.font);
+        lv_coord_t bg_font_h        = lv_font_get_line_height(lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG));
 
-        /*Redraw the text on the selected area with a different color*/
+        /*Redraw the text on the selected area*/
         lv_area_t rect_area;
-        rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - font_h / 2 - label_dsc.line_space / 2;
-        if((font_h & 0x1) && (label_dsc.line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
-        rect_area.y2 = rect_area.y1 + font_h + label_dsc.line_space - 1;
+        rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - bg_font_h / 2 - label_dsc.line_space / 2;
+        if((bg_font_h & 0x1) && (label_dsc.line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
+        rect_area.y2 = rect_area.y1 + bg_font_h + label_dsc.line_space - 1;
         rect_area.x1 = roller->coords.x1;
         rect_area.x2 = roller->coords.x2;
         lv_area_t mask_sel;
@@ -464,7 +472,94 @@ static lv_design_res_t lv_roller_design(lv_obj_t * roller, const lv_area_t * cli
                 label_dsc.flag |= LV_TXT_FLAG_RIGHT;
             }
 
-            lv_draw_label(&label->coords, &mask_sel, &label_dsc, lv_label_get_text(label), NULL);
+            /*Get the size of the "selected text"*/
+            lv_point_t res_p;
+            _lv_txt_get_size(&res_p, lv_label_get_text(label), label_dsc.font, label_dsc.letter_space, label_dsc.line_space,
+                             lv_obj_get_width(roller), LV_TXT_FLAG_EXPAND);
+
+            /*Move the selected label proportionally with the background label*/
+            lv_coord_t roller_h = lv_obj_get_height(roller);
+            int32_t label_y_prop = label->coords.y1 - (roller_h / 2 +
+                                                       roller->coords.y1); /*label offset from the middle line of the roller*/
+            label_y_prop = (label_y_prop << 14) / lv_obj_get_height(
+                               label); /*Proportional position from the middle line (upscaled)*/
+
+            /*Apply a correction with different line heights*/
+            const lv_font_t * normal_label_font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
+            lv_coord_t corr = (label_dsc.font->line_height - normal_label_font->line_height) / 2;
+
+            /*Apply the proportional position to the selected text*/
+            res_p.y -= corr;
+            int32_t label_sel_y = roller_h / 2 + roller->coords.y1;
+            label_sel_y += (label_y_prop * res_p.y) >> 14;
+            label_sel_y -= corr;
+
+            /*Draw the selected text*/
+            lv_area_t label_sel_area;
+            label_sel_area.x1 = label->coords.x1;
+            label_sel_area.y1 = label_sel_y;
+            label_sel_area.x2 = label->coords.x2;
+            label_sel_area.y2 = label_sel_area.y1 + res_p.y;
+
+            label_dsc.flag |= LV_TXT_FLAG_EXPAND;
+            lv_draw_label(&label_sel_area, &mask_sel, &label_dsc, lv_label_get_text(label), NULL);
+        }
+    }
+
+    return LV_DESIGN_RES_OK;
+}
+
+
+/**
+ * Handle the drawing related tasks of the roller's label
+ * @param roller pointer to an object
+ * @param clip_area the object will be drawn only in this area
+ * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
+ *                                  (return 'true' if yes)
+ *             LV_DESIGN_DRAW: draw the object (always return 'true')
+ *             LV_DESIGN_DRAW_POST: drawing after all children are drawn
+ * @param return an element of `lv_design_res_t`
+ */
+static lv_design_res_t lv_roller_label_design(lv_obj_t * label, const lv_area_t * clip_area, lv_design_mode_t mode)
+{
+    if(mode == LV_DESIGN_COVER_CHK) {
+        return ancestor_label_design(label, clip_area, mode);
+    }
+    /*Draw the object*/
+    else if(mode == LV_DESIGN_DRAW_MAIN) {
+        /* Split the drawing of the label into  an upper (above the selected area)
+         * and a lower (below the selected area)*/
+        lv_obj_t * roller = lv_obj_get_parent(lv_obj_get_parent(label));
+        const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
+        lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);
+        lv_coord_t font_h        = lv_font_get_line_height(font);
+
+        lv_area_t rect_area;
+        rect_area.y1 = roller->coords.y1 + lv_obj_get_height(roller) / 2 - font_h / 2 - line_space / 2;
+        if((font_h & 0x1) && (line_space & 0x1)) rect_area.y1--; /*Compensate the two rounding error*/
+        rect_area.y2 = rect_area.y1 + font_h + line_space - 1;
+        lv_area_t roller_coords;
+        lv_obj_get_coords(roller, &roller_coords);
+        lv_obj_get_inner_coords(roller, &roller_coords);
+
+        rect_area.x1 = roller_coords.x1;
+        rect_area.x2 = roller_coords.x2;
+
+        lv_area_t clip2;
+        clip2.x1 = label->coords.x1;
+        clip2.y1 = label->coords.y1;
+        clip2.x2 = label->coords.x2;
+        clip2.y2 = rect_area.y1;
+        if(_lv_area_intersect(&clip2, clip_area, &clip2)) {
+            ancestor_label_design(label, &clip2, mode);
+        }
+
+        clip2.x1 = label->coords.x1;
+        clip2.y1 = rect_area.y2;
+        clip2.x2 = label->coords.x2;
+        clip2.y2 = label->coords.y2;
+        if(_lv_area_intersect(&clip2, clip_area, &clip2)) {
+            ancestor_label_design(label, &clip2, mode);
         }
     }
 
@@ -490,13 +585,16 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
 
     /* Include the ancient signal function */
     if(sign != LV_SIGNAL_CONTROL) { /*Don't let the page to scroll on keys*/
+#if LV_USE_GROUP
         res = ancestor_signal(roller, sign, param);
         if(res != LV_RES_OK) return res;
+#endif
     }
 
     if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
     lv_roller_ext_t * ext = lv_obj_get_ext_attr(roller);
+    LV_UNUSED(ext);
 
     if(sign == LV_SIGNAL_STYLE_CHG) {
         lv_obj_t * label = get_label(roller);
@@ -556,6 +654,7 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
 #endif
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         char c = *((char *)param);
         if(c == LV_KEY_RIGHT || c == LV_KEY_DOWN) {
             if(ext->sel_opt_id + 1 < ext->option_cnt) {
@@ -572,6 +671,7 @@ static lv_res_t lv_roller_signal(lv_obj_t * roller, lv_signal_t sign, void * par
                 ext->sel_opt_id_ori = ori_id;
             }
         }
+#endif
     }
     else if(sign == LV_SIGNAL_CLEANUP) {
         lv_obj_clean_style_list(roller, LV_ROLLER_PART_SELECTED);
@@ -751,7 +851,7 @@ static void refr_position(lv_obj_t * roller, lv_anim_enable_t anim_en)
     lv_coord_t h                   = lv_obj_get_height(roller);
     uint16_t anim_time             = lv_roller_get_anim_time(roller);
 
-    /* Normally the animation's `end_cb` sets correct position of the roller is infinite.
+    /* Normally the animation's `end_cb` sets correct position of the roller if infinite.
      * But without animations do it manually*/
     if(anim_en == LV_ANIM_OFF || anim_time == 0) {
         inf_normalize(roller_scrl);
@@ -898,11 +998,12 @@ static void inf_normalize(void * scrl)
 
     if(ext->mode == LV_ROLLER_MODE_INIFINITE) {
         uint16_t real_id_cnt = ext->option_cnt / LV_ROLLER_INF_PAGES;
-
         ext->sel_opt_id = ext->sel_opt_id % real_id_cnt;
-
         ext->sel_opt_id += (LV_ROLLER_INF_PAGES / 2) * real_id_cnt; /*Select the middle page*/
 
+        ext->sel_opt_id_ori = ext->sel_opt_id % real_id_cnt;
+        ext->sel_opt_id_ori += (LV_ROLLER_INF_PAGES / 2) * real_id_cnt; /*Select the middle page*/
+
         /*Move to the new id*/
         const lv_font_t * font = lv_obj_get_style_text_font(roller, LV_ROLLER_PART_BG);
         lv_style_int_t line_space = lv_obj_get_style_text_line_space(roller, LV_ROLLER_PART_BG);

src/lv_widgets/lv_slider.c

@@ -260,15 +260,30 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
     if(res != LV_RES_OK) return res;
     if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
+    lv_slider_type_t type = lv_slider_get_type(slider);
     lv_slider_ext_t * ext = lv_obj_get_ext_attr(slider);
+
+    /* Advanced hit testing: react only on dragging the knob(s) */
+    if(sign == LV_SIGNAL_HIT_TEST) {
+        lv_hit_test_info_t * info = param;
+
+        /* Ordinary slider: was the knob area hit? */
+        info->result = _lv_area_is_point_on(&ext->right_knob_area, info->point, 0);
+
+        /* There's still a change we have a hit, if we have another knob */
+        if((info->result == false) && (type == LV_SLIDER_TYPE_RANGE)) {
+            info->result = _lv_area_is_point_on(&ext->left_knob_area, info->point, 0);
+        }
+    }
+
     lv_point_t p;
 
     if(sign == LV_SIGNAL_PRESSED) {
         ext->dragging = true;
-        if(lv_slider_get_type(slider) == LV_SLIDER_TYPE_NORMAL) {
+        if(type == LV_SLIDER_TYPE_NORMAL || type == LV_SLIDER_TYPE_SYMMETRICAL) {
             ext->value_to_set = &ext->bar.cur_value;
         }
-        else if(lv_slider_get_type(slider) == LV_SLIDER_TYPE_RANGE) {
+        else if(type == LV_SLIDER_TYPE_RANGE) {
             lv_indev_get_point(param, &p);
             bool hor = lv_obj_get_width(slider) >= lv_obj_get_height(slider);
             lv_bidi_dir_t base_dir = lv_obj_get_base_dir(slider);
@@ -407,6 +422,7 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
 
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         char c = *((char *)param);
 
         if(c == LV_KEY_RIGHT || c == LV_KEY_UP) {
@@ -419,13 +435,16 @@ static lv_res_t lv_slider_signal(lv_obj_t * slider, lv_signal_t sign, void * par
             res = lv_event_send(slider, LV_EVENT_VALUE_CHANGED, NULL);
             if(res != LV_RES_OK) return res;
         }
+#endif
     }
     else if(sign == LV_SIGNAL_CLEANUP) {
         lv_obj_clean_style_list(slider, LV_SLIDER_PART_KNOB);
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
+#if LV_USE_GROUP
         bool * editable = (bool *)param;
         *editable       = true;
+#endif
     }
 
     return res;

src/lv_widgets/lv_spinbox.c

@@ -390,8 +390,10 @@ static lv_res_t lv_spinbox_signal(lv_obj_t * spinbox, lv_signal_t sign, void * p
 
     /* Include the ancient signal function */
     if(sign != LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         res = ancestor_signal(spinbox, sign, param);
         if(res != LV_RES_OK) return res;
+#endif
     }
     if(sign == LV_SIGNAL_GET_TYPE) return lv_obj_handle_get_type_signal(param, LV_OBJX_NAME);
 
@@ -464,6 +466,7 @@ static lv_res_t lv_spinbox_signal(lv_obj_t * spinbox, lv_signal_t sign, void * p
         }
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         lv_indev_type_t indev_type = lv_indev_get_type(lv_indev_get_act());
 
         uint32_t c = *((uint32_t *)param); /*uint32_t because can be UTF-8*/
@@ -488,6 +491,7 @@ static lv_res_t lv_spinbox_signal(lv_obj_t * spinbox, lv_signal_t sign, void * p
         else {
             lv_textarea_add_char(spinbox, c);
         }
+#endif
     }
 
     return res;

src/lv_widgets/lv_switch.c

@@ -296,12 +296,14 @@ static lv_res_t lv_switch_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
 
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         char c = *((char *)param);
         if(c == LV_KEY_RIGHT || c == LV_KEY_UP) lv_switch_on(sw, LV_ANIM_ON);
         else if(c == LV_KEY_LEFT || c == LV_KEY_DOWN) lv_switch_off(sw, LV_ANIM_ON);
 
         res   = lv_event_send(sw, LV_EVENT_VALUE_CHANGED, NULL);
         if(res != LV_RES_OK) return res;
+#endif
     }
     else if(sign == LV_SIGNAL_REFR_EXT_DRAW_PAD) {
         lv_style_int_t knob_left = lv_obj_get_style_pad_left(sw,   LV_SWITCH_PART_KNOB);
@@ -320,8 +322,10 @@ static lv_res_t lv_switch_signal(lv_obj_t * sw, lv_signal_t sign, void * param)
         sw->ext_draw_pad = LV_MATH_MAX(sw->ext_draw_pad, knob_size);
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
+#if LV_USE_GROUP
         bool * editable = (bool *)param;
         *editable       = false; /*The ancestor slider is editable the switch is not*/
+#endif
     }
 
     return res;

src/lv_widgets/lv_tabview.c

@@ -230,20 +230,6 @@ lv_obj_t * lv_tabview_add_tab(lv_obj_t * tabview, const char * name)
 
     ext->tab_cnt++;
 
-    switch(ext->btns_pos) {
-        case LV_TABVIEW_TAB_POS_TOP:
-        case LV_TABVIEW_TAB_POS_BOTTOM:
-            ext->tab_name_ptr = lv_mem_realloc((void *)ext->tab_name_ptr, sizeof(char *) * (ext->tab_cnt + 1));
-            break;
-        case LV_TABVIEW_TAB_POS_LEFT:
-        case LV_TABVIEW_TAB_POS_RIGHT:
-            ext->tab_name_ptr = lv_mem_realloc((void *)ext->tab_name_ptr, sizeof(char *) * (ext->tab_cnt * 2));
-            break;
-    }
-
-    LV_ASSERT_MEM(ext->tab_name_ptr);
-    if(ext->tab_name_ptr == NULL) return NULL;
-
     /* FIXME: It is not possible yet to switch tab button position from/to top/bottom from/to left/right at runtime.
      * Method: clean extra \n when switch from LV_TABVIEW_BTNS_POS_LEFT or LV_TABVIEW_BTNS_POS_RIGHT
      * to LV_TABVIEW_BTNS_POS_TOP or LV_TABVIEW_BTNS_POS_BOTTOM.
@@ -448,6 +434,35 @@ void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, lv_anim_enable_t an
     lv_btnmatrix_set_btn_ctrl(ext->btns, ext->tab_cur, LV_BTNMATRIX_CTRL_CHECK_STATE);
 }
 
+/**
+ * Set the name of a tab.
+ * @param tabview pointer to Tab view object
+ * @param id index of the tab the name should be set
+ * @param name new tab name
+ */
+void lv_tabview_set_tab_name(lv_obj_t * tabview, uint16_t id, char * name)
+{
+    LV_ASSERT_OBJ(tabview, LV_OBJX_NAME);
+
+    /* get tabview's ext pointer which contains the tab name pointer list */
+    lv_tabview_ext_t * ext = lv_obj_get_ext_attr(tabview);
+
+    /* check for valid tab index */
+    if(ext->tab_cnt > id) {
+        /* reallocate memory for new tab name (use reallocate due to mostly the size didn't change much) */
+        char * str = lv_mem_realloc((void *)ext->tab_name_ptr[id], strlen(name) + 1);
+        LV_ASSERT_MEM(str);
+
+        /* store new tab name at allocated memory */
+        strcpy(str, name);
+        /* update pointer  */
+        ext->tab_name_ptr[id] = str;
+
+        /* force redrawing of the tab headers */
+        lv_obj_invalidate(ext->btns);
+    }
+}
+
 /**
  * Set the animation time of tab view when a new tab is loaded
  * @param tabview pointer to Tab view object
@@ -645,12 +660,17 @@ static lv_res_t lv_tabview_signal(lv_obj_t * tabview, lv_signal_t sign, void * p
 #endif
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
+#if LV_USE_GROUP
         bool * editable = (bool *)param;
         *editable       = true;
+#endif
     }
 
-    if(sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS || sign == LV_SIGNAL_CONTROL || sign == LV_SIGNAL_PRESSED  ||
-       sign == LV_SIGNAL_RELEASED) {
+    if(sign == LV_SIGNAL_FOCUS || sign == LV_SIGNAL_DEFOCUS ||
+#if LV_USE_GROUP
+       sign == LV_SIGNAL_CONTROL ||
+#endif
+       sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_RELEASED) {
 
         /* The button matrix is not in a group (the tab view is in it) but it should handle the
          * group signals. So propagate the related signals to the button matrix manually*/

src/lv_widgets/lv_tabview.h

@@ -119,6 +119,14 @@ void lv_tabview_clean_tab(lv_obj_t * tab);
  */
 void lv_tabview_set_tab_act(lv_obj_t * tabview, uint16_t id, lv_anim_enable_t anim);
 
+/**
+ * Set the name of a tab.
+ * @param tabview pointer to Tab view object
+ * @param id index of the tab the name should be set
+ * @param name new tab name
+ */
+void lv_tabview_set_tab_name(lv_obj_t * tabview, uint16_t id, char * name);
+
 /**
  * Set the animation time of tab view when a new tab is loaded
  * @param tabview pointer to Tab view object

src/lv_widgets/lv_textarea.c

@@ -60,6 +60,7 @@ static void pwd_char_hider(lv_obj_t * ta);
 static bool char_is_accepted(lv_obj_t * ta, uint32_t c);
 static void refr_cursor_area(lv_obj_t * ta);
 static void update_cursor_position_on_click(lv_obj_t * ta, lv_signal_t sign, lv_indev_t * click_source);
+static lv_res_t insert_handler(lv_obj_t * ta, const char * txt);
 
 /**********************
  *  STATIC VARIABLES
@@ -148,7 +149,7 @@ lv_obj_t * lv_textarea_create(lv_obj_t * par, const lv_obj_t * copy)
         lv_label_set_text(ext->label, "Text area");
         lv_obj_set_click(ext->label, false);
         lv_obj_set_size(ta, LV_TEXTAREA_DEF_WIDTH, LV_TEXTAREA_DEF_HEIGHT);
-        lv_textarea_set_sscrollbar_mode(ta, LV_SCROLLBAR_MODE_DRAG);
+        lv_textarea_set_scrollbar_mode(ta, LV_SCROLLBAR_MODE_DRAG);
 
         lv_obj_reset_style_list(ta, LV_PAGE_PART_SCROLLABLE);
         lv_theme_apply(ta, LV_THEME_TEXTAREA);
@@ -221,7 +222,7 @@ lv_obj_t * lv_textarea_create(lv_obj_t * par, const lv_obj_t * copy)
 
 /**
  * Insert a character to the current cursor position.
- * To add a wide char, e.g. 'Á' use `lv_txt_encoded_conv_wc('Á')`
+ * To add a wide char, e.g. 'Á' use `_lv_txt_encoded_conv_wc('Á')`
  * @param ta pointer to a text area object
  * @param c a character (e.g. 'a')
  */
@@ -231,21 +232,20 @@ void lv_textarea_add_char(lv_obj_t * ta, uint32_t c)
 
     lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
 
-    uint32_t letter_buf[2];
-    letter_buf[0] = c;
-    letter_buf[1] = '\0';
+    const char * letter_buf;
 
-    ta_insert_replace = NULL;
-    lv_event_send(ta, LV_EVENT_INSERT, letter_buf);
-    if(ta_insert_replace) {
-        if(ta_insert_replace[0] == '\0') return; /*Drop this text*/
+    uint32_t u32_buf[2];
+    u32_buf[0] = c;
+    u32_buf[1] = 0;
 
-        /*Add the replaced text directly it's different from the original*/
-        if(strcmp(ta_insert_replace, (char *)letter_buf)) {
-            lv_textarea_add_text(ta, ta_insert_replace);
-            return;
-        }
-    }
+    letter_buf = (char *)&u32_buf;
+
+#if LV_BIG_ENDIAN_SYSTEM
+    if(c != 0) while(*letter_buf == 0) ++letter_buf;
+#endif
+
+    lv_res_t res = insert_handler(ta, letter_buf);
+    if(res != LV_RES_OK) return;
 
     if(ext->one_line && (c == '\n' || c == '\r')) {
         LV_LOG_INFO("Text area: line break ignored in one-line mode");
@@ -260,6 +260,7 @@ void lv_textarea_add_char(lv_obj_t * ta, uint32_t c)
         return;
     }
 
+
     /*If a new line was added it shouldn't show edge flash effect*/
     bool edge_flash_en = lv_textarea_get_edge_flash(ta);
     lv_textarea_set_edge_flash(ta, false);
@@ -272,7 +273,7 @@ void lv_textarea_add_char(lv_obj_t * ta, uint32_t c)
         if(txt[0] == '\0') lv_obj_invalidate(ta);
     }
 
-    lv_label_ins_text(ext->label, ext->cursor.pos, (const char *)letter_buf); /*Insert the character*/
+    lv_label_ins_text(ext->label, ext->cursor.pos, letter_buf); /*Insert the character*/
     lv_textarea_clear_selection(ta);                                                /*Clear selection*/
 
     if(ext->pwd_mode != 0) {
@@ -325,18 +326,6 @@ void lv_textarea_add_text(lv_obj_t * ta, const char * txt)
 
     lv_textarea_ext_t * ext = lv_obj_get_ext_attr(ta);
 
-    ta_insert_replace = NULL;
-    lv_event_send(ta, LV_EVENT_INSERT, txt);
-    if(ta_insert_replace) {
-        if(ta_insert_replace[0] == '\0') return; /*Drop this text*/
-
-        /*Add the replaced text directly it's different from the original*/
-        if(strcmp(ta_insert_replace, txt)) {
-            lv_textarea_add_text(ta, ta_insert_replace);
-            return;
-        }
-    }
-
     if(ext->pwd_mode != 0) pwd_char_hider(ta); /*Make sure all the current text contains only '*'*/
 
     /*Add the character one-by-one if not all characters are accepted or there is character limit.*/
@@ -349,6 +338,9 @@ void lv_textarea_add_text(lv_obj_t * ta, const char * txt)
         return;
     }
 
+    lv_res_t res = insert_handler(ta, txt);
+    if(res != LV_RES_OK) return;
+
     /*If a new line was added it shouldn't show edge flash effect*/
     bool edge_flash_en = lv_textarea_get_edge_flash(ta);
     lv_textarea_set_edge_flash(ta, false);
@@ -411,18 +403,10 @@ void lv_textarea_del_char(lv_obj_t * ta)
 
     if(cur_pos == 0) return;
 
-    ta_insert_replace = NULL;
     char del_buf[2]   = {LV_KEY_DEL, '\0'};
-    lv_event_send(ta, LV_EVENT_INSERT, del_buf);
-    if(ta_insert_replace) {
-        if(ta_insert_replace[0] == '\0') return; /*Drop this text*/
 
-        /*Add the replaced text directly it's different from the original*/
-        if(strcmp(ta_insert_replace, del_buf)) {
-            lv_textarea_add_text(ta, ta_insert_replace);
-            return;
-        }
-    }
+    lv_res_t res = insert_handler(ta, del_buf);
+    if(res != LV_RES_OK) return;
 
     char * label_txt = lv_label_get_text(ext->label);
 
@@ -1466,6 +1450,7 @@ static lv_res_t lv_textarea_signal(lv_obj_t * ta, lv_signal_t sign, void * param
         }
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         uint32_t c = *((uint32_t *)param); /*uint32_t because can be UTF-8*/
         if(c == LV_KEY_RIGHT)
             lv_textarea_cursor_right(ta);
@@ -1486,10 +1471,13 @@ static lv_res_t lv_textarea_signal(lv_obj_t * ta, lv_signal_t sign, void * param
         else {
             lv_textarea_add_char(ta, c);
         }
+#endif
     }
     else if(sign == LV_SIGNAL_GET_EDITABLE) {
+#if LV_USE_GROUP
         bool * editable = (bool *)param;
         *editable       = true;
+#endif
     }
     else if(sign == LV_SIGNAL_PRESSED || sign == LV_SIGNAL_PRESSING || sign == LV_SIGNAL_PRESS_LOST ||
             sign == LV_SIGNAL_RELEASED) {
@@ -1903,4 +1891,21 @@ static void update_cursor_position_on_click(lv_obj_t * ta, lv_signal_t sign, lv_
 #endif
 }
 
+static lv_res_t insert_handler(lv_obj_t * ta, const char * txt)
+{
+    ta_insert_replace = NULL;
+    lv_event_send(ta, LV_EVENT_INSERT, txt);
+    if(ta_insert_replace) {
+        if(ta_insert_replace[0] == '\0') return LV_RES_INV; /*Drop this text*/
+
+        /*Add the replaced text directly it's different from the original*/
+        if(strcmp(ta_insert_replace, txt)) {
+            lv_textarea_add_text(ta, ta_insert_replace);
+            return LV_RES_INV;
+        }
+    }
+
+    return LV_RES_OK;
+}
+
 #endif

src/lv_widgets/lv_textarea.h

@@ -106,7 +106,7 @@ lv_obj_t * lv_textarea_create(lv_obj_t * par, const lv_obj_t * copy);
 
 /**
  * Insert a character to the current cursor position.
- * To add a wide char, e.g. 'Á' use `lv_txt_encoded_conv_wc('Á')`
+ * To add a wide char, e.g. 'Á' use `_lv_txt_encoded_conv_wc('Á')`
  * @param ta pointer to a text area object
  * @param c a character (e.g. 'a')
  */
@@ -224,7 +224,7 @@ void lv_textarea_set_insert_replace(lv_obj_t * ta, const char * txt);
  * @param ta pointer to a text area object
  * @param sb_mode the new mode from 'lv_scrollbar_mode_t' enum
  */
-static inline void lv_textarea_set_sscrollbar_mode(lv_obj_t * ta, lv_scrollbar_mode_t mode)
+static inline void lv_textarea_set_scrollbar_mode(lv_obj_t * ta, lv_scrollbar_mode_t mode)
 {
     lv_page_set_scrollbar_mode(ta, mode);
 }

src/lv_widgets/lv_tileview.c

@@ -376,7 +376,7 @@ static lv_res_t lv_tileview_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void
 
             if(!ext->drag_right_en && indev->proc.types.pointer.vect.x < 0 && x < -(ext->act_id.x * w)) {
                 lv_page_start_edge_flash(tileview, LV_PAGE_EDGE_RIGHT);
-                lv_obj_set_x(scrl, -ext->act_id.x * w + top);
+                lv_obj_set_x(scrl, -ext->act_id.x * w + left);
             }
 
             /*Apply the drag constraints*/
@@ -403,8 +403,8 @@ static void drag_end_handler(lv_obj_t * tileview)
     lv_obj_t * scrl = lv_page_get_scrollable(tileview);
     lv_point_t p;
 
-    p.x = -(scrl->coords.x1 - lv_obj_get_width(tileview) / 2);
-    p.y = -(scrl->coords.y1 - lv_obj_get_height(tileview) / 2);
+    p.x = -(lv_obj_get_x(scrl) - lv_obj_get_width(tileview) / 2);
+    p.y = -(lv_obj_get_y(scrl) - lv_obj_get_height(tileview) / 2);
 
     lv_drag_dir_t drag_dir = indev->proc.types.pointer.drag_dir;
     /*From the drag vector (drag throw) predict the end position*/

src/lv_widgets/lv_win.c

@@ -23,6 +23,22 @@
  *      TYPEDEFS
  **********************/
 
+/** Extended data of win_btn*/
+typedef struct {
+    /** Ext. of ancestor*/
+    lv_btn_ext_t btn;
+
+    /** Which side of the header should the button be aligned to.
+     * 0: Align to right (default), 1: Align to left */
+    uint8_t alignment_in_header : 1;
+} lv_win_btn_ext_t;
+
+enum {
+    LV_WIN_BTN_ALIGN_RIGHT = 0,     /**< Align button to right of the header */
+    LV_WIN_BTN_ALIGN_LEFT   /**< Align button to left of the header */
+};
+typedef uint8_t lv_win_btn_align_t;
+
 /**********************
  *  STATIC PROTOTYPES
  **********************/
@@ -30,6 +46,9 @@ static lv_res_t lv_win_signal(lv_obj_t * win, lv_signal_t sign, void * param);
 static lv_design_res_t lv_win_header_design(lv_obj_t * header, const lv_area_t * clip_area, lv_design_mode_t mode);
 static lv_style_list_t * lv_win_get_style(lv_obj_t * win, uint8_t part);
 static void lv_win_realign(lv_obj_t * win);
+static lv_obj_t * lv_win_btn_create(lv_obj_t * par, const void * img_src);
+static void lv_win_btn_set_alignment(lv_obj_t * par, const lv_win_btn_align_t alignment);
+static lv_win_btn_align_t lv_win_btn_get_alignment(const lv_obj_t * par);
 
 /**********************
  *  STATIC VARIABLES
@@ -166,23 +185,39 @@ void lv_win_clean(lv_obj_t * win)
  * Add control button to the header of the window
  * @param win pointer to a window object
  * @param img_src an image source ('lv_img_t' variable, path to file or a symbol)
+ * @param alignment button alignment on the header
  * @return pointer to the created button object
  */
-lv_obj_t * lv_win_add_btn(lv_obj_t * win, const void * img_src)
+lv_obj_t * lv_win_add_btn_right(lv_obj_t * win, const void * img_src)
 {
     LV_ASSERT_OBJ(win, LV_OBJX_NAME);
     LV_ASSERT_NULL(img_src);
 
     lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
 
-    lv_obj_t * btn = lv_btn_create(ext->header, NULL);
-    lv_theme_apply(btn, LV_THEME_WIN_BTN);
-    lv_coord_t btn_size = lv_obj_get_height_fit(ext->header);
-    lv_obj_set_size(btn, btn_size, btn_size);
+    lv_obj_t * btn = lv_win_btn_create(ext->header, img_src);
+    lv_win_btn_set_alignment(btn, LV_WIN_BTN_ALIGN_RIGHT);
 
-    lv_obj_t * img = lv_img_create(btn, NULL);
-    lv_obj_set_click(img, false);
-    lv_img_set_src(img, img_src);
+    lv_win_realign(win);
+
+    return btn;
+}
+
+/**
+ * Add control button on the left side of the window header
+ * @param win pointer to a window object
+ * @param img_src an image source ('lv_img_t' variable, path to file or a symbol)
+ * @return pointer to the created button object
+ */
+lv_obj_t * lv_win_add_btn_left(lv_obj_t * win, const void * img_src)
+{
+    LV_ASSERT_OBJ(win, LV_OBJX_NAME);
+    LV_ASSERT_NULL(img_src);
+
+    lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
+
+    lv_obj_t * btn = lv_win_btn_create(ext->header, img_src);
+    lv_win_btn_set_alignment(btn, LV_WIN_BTN_ALIGN_LEFT);
 
     lv_win_realign(win);
 
@@ -501,7 +536,8 @@ static lv_design_res_t lv_win_header_design(lv_obj_t * header, const lv_area_t *
         lv_obj_t * win = lv_obj_get_parent(header);
         lv_win_ext_t * ext = lv_obj_get_ext_attr(win);
 
-        lv_style_int_t left = lv_obj_get_style_pad_left(header, LV_OBJ_PART_MAIN);
+        lv_style_int_t header_left = lv_obj_get_style_pad_left(win, LV_WIN_PART_HEADER);
+        lv_style_int_t header_inner = lv_obj_get_style_pad_inner(win, LV_WIN_PART_HEADER);
 
         lv_draw_label_dsc_t label_dsc;
         lv_draw_label_dsc_init(&label_dsc);
@@ -510,13 +546,29 @@ static lv_design_res_t lv_win_header_design(lv_obj_t * header, const lv_area_t *
         lv_area_t txt_area;
         lv_point_t txt_size;
 
-
         _lv_txt_get_size(&txt_size, ext->title_txt, label_dsc.font, label_dsc.letter_space, label_dsc.line_space, LV_COORD_MAX,
                          label_dsc.flag);
 
-        txt_area.x1 = header->coords.x1 + left;
+        lv_obj_t * btn = NULL;
+
+        lv_coord_t btn_h = lv_obj_get_height_fit(header);
+        lv_coord_t btn_w = ext->btn_w != 0 ? ext->btn_w : btn_h;
+
+        /*Get x position of the title (should be on the right of the buttons on the left)*/
+
+        lv_coord_t left_btn_offset = 0;
+        btn = lv_obj_get_child_back(ext->header, NULL);
+        while(btn != NULL) {
+            if(LV_WIN_BTN_ALIGN_LEFT == lv_win_btn_get_alignment(btn)) {
+                left_btn_offset += btn_w + header_inner;
+            }
+
+            btn = lv_obj_get_child_back(header, btn);
+        }
+
+        txt_area.x1 = header->coords.x1 + header_left + left_btn_offset;
         txt_area.y1 = header->coords.y1 + (lv_obj_get_height(header) - txt_size.y) / 2;
-        txt_area.x2 = txt_area.x1 + txt_size.x;
+        txt_area.x2 = txt_area.x1 + txt_size.x  + left_btn_offset;
         txt_area.y2 = txt_area.y1 + txt_size.y;
 
         lv_draw_label(&txt_area, clip_area, &label_dsc, ext->title_txt, NULL);
@@ -593,8 +645,10 @@ static lv_res_t lv_win_signal(lv_obj_t * win, lv_signal_t sign, void * param)
         ext->title_txt  = NULL;
     }
     else if(sign == LV_SIGNAL_CONTROL) {
+#if LV_USE_GROUP
         /*Forward all the control signals to the page*/
         ext->page->signal_cb(ext->page, sign, param);
+#endif
     }
 
     return res;
@@ -644,23 +698,54 @@ static void lv_win_realign(lv_obj_t * win)
     lv_obj_set_width(ext->header, lv_obj_get_width(win));
 
     lv_obj_t * btn;
-    lv_obj_t * btn_prev = NULL;
+    lv_obj_t * btn_prev_at_left = NULL;
+    lv_obj_t * btn_prev_at_right = NULL;
+
+    bool is_header_right_side_empty = true;
+    bool is_header_left_side_empty = true;
+
     lv_coord_t btn_h = lv_obj_get_height_fit(ext->header);
     lv_coord_t btn_w = ext->btn_w != 0 ? ext->btn_w : btn_h;
     lv_style_int_t header_inner = lv_obj_get_style_pad_inner(win, LV_WIN_PART_HEADER);
     lv_style_int_t header_right = lv_obj_get_style_pad_right(win, LV_WIN_PART_HEADER);
+    lv_style_int_t header_left = lv_obj_get_style_pad_left(win, LV_WIN_PART_HEADER);
+
     /*Refresh the size of all control buttons*/
     btn = lv_obj_get_child_back(ext->header, NULL);
     while(btn != NULL) {
-        lv_obj_set_size(btn, btn_h, btn_w);
-        if(btn_prev == NULL) {
-            lv_obj_align(btn, ext->header, LV_ALIGN_IN_RIGHT_MID, -header_right, 0);
+        lv_obj_set_size(btn, btn_w, btn_h);
+        uint8_t btn_alignment = lv_win_btn_get_alignment(btn);
+
+        if(LV_WIN_BTN_ALIGN_RIGHT == btn_alignment) {
+            if(is_header_right_side_empty) {
+                /* Align the button to the right of the header */
+                lv_obj_align(btn, ext->header, LV_ALIGN_IN_RIGHT_MID, -header_right, 0);
+
+                is_header_right_side_empty = false;
+            }
+            else {
+                /* Align the button to the left of the previous button */
+                lv_obj_align(btn, btn_prev_at_right, LV_ALIGN_OUT_LEFT_MID, -header_inner, 0);
+            }
+
+            btn_prev_at_right = btn;
         }
-        else {
-            lv_obj_align(btn, btn_prev, LV_ALIGN_OUT_LEFT_MID, - header_inner, 0);
+        else if(LV_WIN_BTN_ALIGN_LEFT == btn_alignment) {
+            if(is_header_left_side_empty) {
+                /* Align the button to the right of the header */
+                lv_obj_align(btn, ext->header, LV_ALIGN_IN_LEFT_MID, header_left, 0);
+
+                is_header_left_side_empty = false;
+            }
+            else {
+                /* Align the button to the right of the previous button */
+                lv_obj_align(btn, btn_prev_at_left, LV_ALIGN_OUT_RIGHT_MID, header_inner, 0);
+            }
+
+            btn_prev_at_left = btn;
         }
-        btn_prev = btn;
-        btn      = lv_obj_get_child_back(ext->header, btn);
+
+        btn = lv_obj_get_child_back(ext->header, btn);
     }
 
     lv_obj_set_pos(ext->header, 0, 0);
@@ -669,4 +754,54 @@ static void lv_win_realign(lv_obj_t * win)
     lv_obj_align(ext->page, ext->header, LV_ALIGN_OUT_BOTTOM_LEFT, 0, 0);
 }
 
+static lv_obj_t * lv_win_btn_create(lv_obj_t * par, const void * img_src)
+{
+    LV_LOG_TRACE("win btn create started");
+
+    lv_obj_t * win_btn;
+
+    win_btn = lv_btn_create(par, NULL);
+    LV_ASSERT_MEM(win_btn);
+    if(win_btn == NULL) return NULL;
+
+    /*Allocate the extended data*/
+    lv_win_btn_ext_t * ext = lv_obj_allocate_ext_attr(win_btn, sizeof(lv_win_btn_ext_t));
+    LV_ASSERT_MEM(ext);
+    if(ext == NULL) {
+        lv_obj_del(win_btn);
+        return NULL;
+    }
+
+    ext->alignment_in_header = LV_WIN_BTN_ALIGN_RIGHT;
+
+    lv_obj_set_click(win_btn, true);
+    lv_win_btn_set_alignment(win_btn, LV_WIN_BTN_ALIGN_RIGHT);
+
+    lv_theme_apply(win_btn, LV_THEME_WIN_BTN);
+    lv_coord_t btn_size = lv_obj_get_height_fit(par);
+    lv_obj_set_size(win_btn, btn_size, btn_size);
+
+    lv_obj_t * img = lv_img_create(win_btn, NULL);
+    lv_obj_set_click(img, false);
+    lv_img_set_src(img, img_src);
+
+    LV_LOG_INFO("win btn created");
+
+    return win_btn;
+}
+
+static void lv_win_btn_set_alignment(lv_obj_t * win_btn, const uint8_t alignment)
+{
+    lv_win_btn_ext_t * ext = lv_obj_get_ext_attr(win_btn);
+
+    ext->alignment_in_header = alignment;
+}
+
+static uint8_t lv_win_btn_get_alignment(const lv_obj_t * win_btn)
+{
+    lv_win_btn_ext_t * ext = lv_obj_get_ext_attr(win_btn);
+
+    return ext->alignment_in_header;
+}
+
 #endif

src/lv_widgets/lv_win.h

@@ -92,12 +92,20 @@ void lv_win_clean(lv_obj_t * win);
  *=====================*/
 
 /**
- * Add control button to the header of the window
+ * Add control button on the right side of the window header
  * @param win pointer to a window object
  * @param img_src an image source ('lv_img_t' variable, path to file or a symbol)
  * @return pointer to the created button object
  */
-lv_obj_t * lv_win_add_btn(lv_obj_t * win, const void * img_src);
+lv_obj_t * lv_win_add_btn_right(lv_obj_t * win, const void * img_src);
+
+/**
+ * Add control button on the left side of the window header
+ * @param win pointer to a window object
+ * @param img_src an image source ('lv_img_t' variable, path to file or a symbol)
+ * @return pointer to the created button object
+ */
+lv_obj_t * lv_win_add_btn_left(lv_obj_t * win, const void * img_src);
 
 /*=====================
  * Setter functions

src/lvgl.h

@@ -0,0 +1,39 @@
+/**
+ * @file lvgl.h
+ * This file exists only to be compatible with Arduino's library structure
+ */
+
+#ifndef LVGL_SRC_H
+#define LVGL_SRC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include "../lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*LVGL_SRC_H*/