prepare to release v7.4.0

Removed LV_USE_GROUP guard macro for signals != LV_SIGNAL_CONTROL in signal functions of roller and spinbox to allow signal propagating to ancestors

.github/FUNDING.yml

@@ -1 +1 @@
-custom: ["https://littlevgl.com/donate"]
+custom: ["https://paypal.me/littlevgl?locale.x=en_US"]

.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/ccpp.yml

@@ -2,9 +2,9 @@ name: C/C++ CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, dev ]
   pull_request:
-    branches: [master ]
+    branches: [master, dev ]
 
 jobs:
   build:
@@ -14,4 +14,4 @@ jobs:
     steps:
     - uses: actions/checkout@v2
     - name: Run tests
-      run: cd tests; python ./build.py
+      run: sudo apt-get install libpng-dev; cd tests; python ./build.py

.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,10 +1,144 @@
 # Changelog
 
-## v7.0.1 (under development)
-*Available in the `master` branch*
+## v7.4.0 (01.09.2020)
+
+The main new features of v7.4 are run-time font loading, style caching and arc knob with value setting by click.
+
+### New features
+- Add `lv_font_load()` function - Loads a `lv_font_t` object from a binary font file
+- Add `lv_font_free()` function - Frees the memory allocated by the `lv_font_load()` function
+- Add style caching to reduce acces time of properties with default value
+- arc: add set value by click feature
+- arc: add `LV_ARC_PART_KNOB` similarly to slider
+- send gestures even is the the obejct was dragged. User can check dragging with `lv_indev_is_dragging(lv_indev_act())` in the event function. 
+
+### Bugfixes
+- Fix color bleeding on border drawing
+- Fix using 'LV_SCROLLBAR_UNHIDE' after 'LV_SCROLLBAR_ON'
+- Fix croping of last column/row if an image is zoomed
+- Fix zooming and rotateing mosaic images
+- Fix deleting tabview with LEFT/RIGHT tab position
+- Fix btnmatrix to not send event when CLICK_TRIG = true and the cursor slid from a pressed button
+- Fix roller width if selected text is larger than the normal
+
+## v7.3.1 (18.08.2020)
+
+### Bugfixes
+- Fix drawing value string twice
+- Rename  `lv_chart_clear_serie` to `lv_chart_clear_series` and `lv_obj_align_origo` to `lv_obj_align_mid`
+- Add linemeter's mirror feature again
+- Fix text decor (udnerline strikethrough) with older versions of font converter
+- Fix setting local style property multiple times 
+- Add missing background drawing and radius handling to image button
+- Allow adding extra label to list buttons
+- Fix crash if `lv_table_set_col_cnt` is called before `lv_table_set_row_cnt` for the first time
+- Fix overflow in large image transformations
+- Limit extra button click area of button matrix's buttons. With large paddings it was counter intuitive. (Gaps are mapped to button when clicked).
+- Fix `lv_btnmatrix_set_one_check` not forcing exactly one button to be checked
+- Fix color picker invalidation in rectangle mode
+- Init disabled days to gray color in calendar
+
+## 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` and `LV_FONT_USE_SUBPX` 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
+- Do not call `set_px_cb` for transparent pixel
+- Fix list button focus in material theme
+- Fix crash when the a text area is cleared with the backspace of a keyboard
+- Add version number to `lv_conf_template.h`
+- Add log in true double buffering mode with `set_px_cb`
+- `lv_dropdown`: fix missing `LV_EVENT_VALUE_CHANGED` event when used with encoder
+- `lv_tileview`: fix if not the {0;0} tile is created first
+- `lv_debug`: restructure to allow asserting in from `lv_misc` too
+- add assert if `_lv_mem_buf_get()` fails
+- `lv_textarea`: fix character delete in password mode
+- Update `LV_OPA_MIN` and `LV_OPA_MAX` to widen the opacity processed range
+- `lv_btnm` fix sending events for hidden buttons
+- `lv_gaguge` make `lv_gauge_set_angle_offset` offset the labels and needles too
+- Fix typo in the API `scrllable` -> `scrollable`
+- `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)
 
 ### Bugfixes
 - Make the Microptyhon working by adding the required variables as GC_ROOT
+- Prefix some internal API functions with `_` to reduce the API of LVGL 
 - Fix built-in SimSun CJK font
 - Fix UTF-8 encoding when `LV_USE_ARABIC_PERSIAN_CHARS` is enabled
 - Fix DMA2D usage when 32 bit images directly blended
@@ -14,8 +148,8 @@
 - Improve DMA2D blending
 - Remove memcpy from `lv_ll` (caused issues with some optimization settings)
 - `lv_chart` fix X tick drawing
-- fix vertical dashed line drawing
-- some additonal minor fixes and formattings
+- Fix vertical dashed line drawing
+- Some additonal minor fixes and formattings
 
 ## v7.0.0 (18.05.2020)
 

README.md

@@ -1,8 +1,4 @@
-<h1 align="center"> LVGL - Little 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>
+<h1 align="center"> LVGL - Light and Versatile Graphics Library</h1>
 
 <p align="center">
 <img src="https://lvgl.io/assets/images/img_1.png">
@@ -14,219 +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)
-- [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://lvgl.com/developers) 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 and set at least `LV_HOR_RES_MAX`, `LV_VER_RES_MAX` and `LV_COLOR_DEPTH`. Don't forget to **change the `#if 0` statement near the top of the file to `#if 1`**, otherwise you will get compilation errors.
-4. Include `lvgl/lvgl.h` where you need to use LVGL related functions.
-5. Call `lv_tick_inc(x)` every `x` milliseconds **in a Timer or Task** (`x` should be between 1 and 10). 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++) {
-            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)
-{
-    static lv_coord_t last_x = 0;
-    static lv_coord_t last_y = 0;
-
-    /*Save the state and save the pressed coordinate*/
-    data->state = touchpad_is_pressed() ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL; 
-    if(data->state == LV_INDEV_STATE_PR) touchpad_get_xy(&last_x, &last_y);
-   
-    /*Set the coordinates (if released use the last pressed coordinates)*/
-    data->point.x = last_x;
-    data->point.y = last_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. 
-
-
-## Learn the basics
-
-In this section you can ready the very basics. 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 in LittelvGL. Go to [Object types](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. 
-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 has 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`).
-
-### Styles
-Widgets are created with a default appearance but it can be changed by adding new styles to the object. 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_BRN_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:
-```
-lv_obj_add_style(btn1, LV_BTN_PART_MAIN, &style1);
-```
-
-To remove all styles from an object use:
-```c
-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*/
@@ -246,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()
@@ -263,17 +155,6 @@ lv.scr_load(scr)
 ```
 
 ## 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.

a.patch

@@ -0,0 +1,29 @@
+diff --git a/scripts/release.py b/scripts/release.py
+index 28370c66..bc5234e7 100755
+--- a/scripts/release.py
++++ b/scripts/release.py
+@@ -395,12 +395,12 @@ def docs_update_dev_version():
+     os.chdir("../")
+ 
+ 
+-def publish_dev():   
++def publish_dev_and_master():   
+     pub_cmd = "git checkout dev; git push origin dev"
+     cmd("cd lvgl; " + pub_cmd)    
++    pub_cmd = "git checkout master; git push origin master"
++    cmd("cd lvgl; " + pub_cmd)    
+ 
+-    pub_cmd = "git checkout dev; git push origin dev"
+-    cmd("cd docs; " + pub_cmd)    
+     cmd("cd docs; git checkout master; ./update.py latest dev")
+ 
+ def cleanup():
+@@ -463,7 +463,7 @@ if __name__ == '__main__':
+ 
+         lvgl_update_dev_version()
+         docs_update_dev_version()
+-        publish_dev()
++        publish_dev_and_master()
+         
+     cleanup()
+     

docs/CONTRIBUTING.md

@@ -1,117 +1,5 @@
 # Contributing to LVGL
 
-**Do you have some free time to spend with programming?
-Are you working on an embedded GUI project with LVGL?
-See how can you help to improve the graphics library and help others!**
+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,38 @@
+# 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
+- Remove the align parameter from `lv_canvas_draw_text`
+
+## v9
+- Simplify `group`s. Discussion is [here](https://forum.lvgl.io/t/lv-group-tabindex/2927/3).
+
+## 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)
+- Support dot_begin and dot_middle long modes for labels
+- Add new label alignment modes. [#1656](https://github.com/lvgl/lvgl/issues/1656)

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 `lv_conf.h` next to the `src` 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.1",
-    "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.4.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.4.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 v7.4.0-dev
  */
 
 /*
@@ -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*/
@@ -330,15 +355,15 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
 
 /* 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
  */
 
 /* 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
@@ -498,7 +535,7 @@ typedef void * lv_obj_user_data_t;
 #endif
 #endif
 
-/*1: enable `lv_obj_realaign()` based on `lv_obj_align()` parameters*/
+/*1: enable `lv_obj_realign()` based on `lv_obj_align()` parameters*/
 #define LV_USE_OBJ_REALIGN          1
 
 /* Enable to make the object clickable on a larger area.
@@ -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
@@ -647,6 +687,9 @@ typedef void * lv_obj_user_data_t;
 #  define LV_ROLLER_INF_PAGES         7
 #endif
 
+/*Rotary (dependencies: lv_arc, lv_btn)*/
+#define LV_USE_ROTARY     1
+
 /*Slider (dependencies: lv_bar)*/
 #define LV_USE_SLIDER    1
 

lvgl.h

@@ -2,7 +2,7 @@
  * @file lvgl.h
  * Include all LittleV GL related headers
  */
-
+ 
 #ifndef LVGL_H
 #define LVGL_H
 
@@ -10,6 +10,15 @@
 extern "C" {
 #endif
 
+
+/***************************
+ * CURRENT VERSION OF LVGL
+ ***************************/
+#define LVGL_VERSION_MAJOR   7
+#define LVGL_VERSION_MINOR   4
+#define LVGL_VERSION_PATCH   0
+#define LVGL_VERSION_INFO ""
+
 /*********************
  *      INCLUDES
  *********************/
@@ -31,6 +40,7 @@ extern "C" {
 #include "src/lv_themes/lv_theme.h"
 
 #include "src/lv_font/lv_font.h"
+#include "src/lv_font/lv_font_loader.h"
 #include "src/lv_font/lv_font_fmt_txt.h"
 #include "src/lv_misc/lv_printf.h"
 
@@ -72,14 +82,11 @@ extern "C" {
 
 #include "src/lv_api_map.h"
 
+//#define LV_BUILD_TEST 1
+
 /*********************
  *      DEFINES
  *********************/
-/*Current version of LVGL*/
-#define LVGL_VERSION_MAJOR   7
-#define LVGL_VERSION_MINOR   0
-#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

@@ -0,0 +1,525 @@
+#!/usr/bin/env python
+
+# Release lvgl, lv_examples, lv_drivers. docs, blog and prepare the development of the next major, minoror bugfix release
+# Usage: ./release,py bugfix | minor | major
+# The option means what type of versin to prepare for development after release
+#
+# STEPS:
+#  - clone all 5 repos
+#  - get the version numnber from lvgl.h
+#  - set release branch (e.g. "release/v7")
+#  - prepare lvgl
+#    - run lv_conf_internal.py
+#    - run code formatter 
+#    - clear LVGL_VERSION_INFO (set to "")
+#    - run Doxygen 
+#    - update the version in lvgl's library.json, library.properties, lv_conf_template.h
+#    - update CHANGELOG.md
+#    - commit changes 
+#  - prepare lv_examples
+#    - upadte the required LVGL version in lv_examples.h (LV_VERSION_CHECK) 
+#    - update the version in lv_ex_conf_template.h
+#  - prepare lv_drivers
+#    - update the version in library.json, lv_drv_conf_template.h      
+#  - prepare docs
+#    - update API XML 
+#    - clear the versiopn info (should be plain vx.y.z)
+#  - tag all repos with the new version
+#  - merge to release branches
+#  - blog: add release post
+#  - push tags and commits
+#  - docs: run ./updade.py release/vX
+#
+# If --patch
+#  - merge master to dev branches
+#  - increment patch version by 1 and append "-dev". E.g. "vX.Y.(Z+1)-dev"
+#  - update version numbers in lvgl and docs
+#  - commit and push
+#  - docs: run ./updade.py latest dev
+#
+# Else (not --patch)
+#  - merge master to dev  
+#  - merge the dev to master
+#  - increment version number like "vX.(Y+1).0-dev"
+#  - apply the new version in dev branches of lvgl, lv_examples, lv_drivers, docs
+#  - commit and push to dev branches
+#  - docs: run ./updade.py latest dev
+
+import re
+import os, fnmatch
+import os.path
+from os import path
+from datetime import date
+import sys
+
+upstream_org_url = "https://github.com/lvgl/"
+workdir = "./release_tmp"
+proj_list = [ "lv_sim_eclipse_sdl"]
+
+ver_major = -1
+ver_minor = -1
+ver_patch = -1
+
+ver_str = ""
+dev_ver_str = ""
+release_br = ""
+release_note = ""
+
+prepare_type = ['major', 'minor', 'bugfix']
+
+dev_prepare = 'minor'
+
+def upstream(repo):
+    return upstream_org_url + repo + ".git"
+
+def cmd(c, exit_on_err = True):
+  print("\n" + c)
+  r = os.system(c)       
+  if r:
+    print("### Error: " + str(r))
+    if exit_on_err: exit(int(r))
+    
+def define_set(fn, name, value):    
+    print("In " + fn + " set " + name + " to " + value)
+    
+    new_content = ""      
+    s = r'^ *# *define +' + str(name).rstrip()
+    
+    f = open(fn, "r")
+    for i in f.read().splitlines():
+        r = re.search(s, i)
+        if r: 
+            d = i.split("define")
+            i = d[0] + "define " + name + " " + value 
+        new_content += i + '\n'
+     
+    f.close()
+    
+    f = open(fn, "w")
+    f.write(new_content)
+    f.close()
+    
+def clone_repos():
+    cmd("rm -fr " + workdir)
+    cmd("mkdir " + workdir)
+    os.chdir(workdir)
+
+    #For debuging just copy the repos
+    #cmd("cp -a ../repos/. .")
+    #return
+
+    cmd("git clone " + upstream("lvgl") + "; cd lvgl; git checkout master")
+    cmd("git clone " + upstream("lv_examples") + "; cd lv_examples; git checkout master")
+    cmd("git clone " + upstream("lv_drivers") + "; cd lv_drivers; git checkout master")
+    cmd("git clone --recurse-submodules " + upstream("docs") + "; cd docs; git checkout master")
+    cmd("git clone " + upstream("blog") + "; cd blog; git checkout master")
+
+    for p in proj_list:
+        cmd("git clone " + upstream(p) + " --recurse-submodules ; cd " + p + "; git checkout master")
+        
+
+def get_lvgl_version(br):
+    print("Get LVGL's version")
+    
+    global ver_str, ver_major, ver_minor, ver_patch, release_br 
+    
+    os.chdir("./lvgl")
+    
+    cmd("git checkout " + br)
+    
+    f = open("./lvgl.h", "r")
+      
+    lastNum = re.compile(r'(?:[^\d]*(\d+)[^\d]*)+')
+    for i in f.read().splitlines():
+        r = re.search(r'^#define LVGL_VERSION_MAJOR ', i)
+        if r: 
+            m = lastNum.search(i)
+            if m: ver_major = m.group(1)
+
+        r = re.search(r'^#define LVGL_VERSION_MINOR ', i)
+        if r: 
+            m = lastNum.search(i)
+            if m: ver_minor = m.group(1)
+      
+        r = re.search(r'^#define LVGL_VERSION_PATCH ', i)
+        if r: 
+            m = lastNum.search(i)
+            if m: ver_patch = m.group(1)
+     
+    f.close()
+    
+    cmd("git checkout master")
+    
+    ver_str =  "v" + str(ver_major) + "." + str(ver_minor) + "." + str(ver_patch)
+    print("New version:" + ver_str)
+    
+    release_br = "release/v" + ver_major
+    
+    os.chdir("../")
+    
+def update_version():
+    templ = fnmatch.filter(os.listdir('.'), '*templ*')
+    
+    if templ[0]:    
+        print("Updating version in " + templ[0])
+        cmd("sed -i -r 's/v[0-9]+\.[0-9]+\.[0-9]+/"+ ver_str +"/' " + templ[0])
+    
+    if os.path.exists("library.json"):  
+        print("Updating version in library.json")
+        cmd("sed -i -r 's/[0-9]+\.[0-9]+\.[0-9]+/"+ ver_str[1:] +"/' library.json")
+        
+    if path.exists("library.properties"):  
+        print("Updating version in library.properties")
+        cmd("sed -i -r 's/version=[0-9]+\.[0-9]+\.[0-9]+/"+ "version=" + ver_str[1:] + "/' library.properties")
+    
+def lvgl_prepare():
+    print("Prepare lvgl")
+    
+    global ver_str, ver_major, ver_minor, ver_patch 
+    
+    os.chdir("./lvgl")
+    define_set("./lvgl.h", "LVGL_VERSION_INFO", '\"\"')
+    
+    # Run some scripts
+    os.chdir("./scripts")
+    cmd("./code-format.sh")
+    cmd("./lv_conf_checker.py")
+    cmd("doxygen")
+    os.chdir("../")
+
+    update_version()
+
+    #update CHANGLELOG
+    new_content = ""
+    f = open("./CHANGELOG.md", "r")
+    
+    global release_note
+    release_note = ""
+    note_state = 0  
+    for i in f.read().splitlines():
+        if note_state == 0:
+            r = re.search(r'^## ' + ver_str, i)
+            if r: 
+                i = i.replace("planned on ", "") 
+                note_state+=1
+                
+        elif note_state == 1: 
+            r = re.search(r'^## ', i)
+            if r:
+                note_state+=1
+            else:
+                release_note += i + '\n'
+                    
+        new_content += i + '\n'
+     
+    f.close()
+    
+    f = open("./CHANGELOG.md", "w")
+    f.write(new_content)
+    f.close()
+    
+    cmd('git commit -am "prepare to release ' + ver_str + '"')
+    
+    os.chdir("../")
+    
+    
+def lv_examples_prepare():
+    print("Prepare lv_examples")
+    global ver_str, ver_major, ver_minor, ver_patch 
+    
+    os.chdir("./lv_examples")
+    
+    update_version()
+    
+    cmd("sed -i -r 's/LV_VERSION_CHECK\([0-9]+, *[0-9]+, *[0-9]+\)/"+ "LV_VERSION_CHECK(" + ver_major + ", " + ver_minor + ", " + ver_patch + ")/' lv_examples.h")
+    
+    cmd('git commit -am "prepare to release ' + ver_str + '"')
+    
+    os.chdir("../")
+    
+def lv_drivers_prepare():
+    print("Prepare lv_drivers")
+    global ver_str, ver_major, ver_minor, ver_patch 
+    
+    os.chdir("./lv_drivers")
+    
+    update_version()
+    
+    cmd('git commit -am "prepare to release ' + ver_str + '"')
+    
+    os.chdir("../")
+    
+def docs_prepare():
+    print("Prepare docs")
+    global ver_str, ver_major, ver_minor, ver_patch 
+    
+    os.chdir("./docs")
+    
+    cmd("git co latest --") 
+    cmd("rm -rf xml");  
+    cmd("cp -r ../lvgl/docs/api_doc/xml .");  
+    cmd("git add xml");
+    
+    cmd("sed -i -r \"s/'v[0-9]+\.[0-9]+\.[0-9]+.*'/\'" + ver_str + "'/\" conf.py")   
+    
+    cmd('git commit -am "prepare to release ' + ver_str + '"')
+    
+    os.chdir("../")
+    
+def blog_add_post():
+    global ver_str, release_note
+    
+    os.chdir("./blog/_posts")
+    
+    post = "---\nlayout: post\ntitle: " + ver_str + " is released\nauthor: \"kisvegabor\"\ncover: /assets/release_cover.png\n---\n\n"
+    post += release_note
+    
+    today = date.today()
+    d = today.strftime("%Y-%m-%d")
+    
+    f = open(d + "-release_" + ver_str + ".md", "w")
+    f.write(post)
+    f.close()
+    
+    cmd("git add .")
+    cmd("git commit -am 'Add " + ver_str + " release post'")
+    
+    os.chdir("../../")
+        
+def add_tags():
+    global ver_str
+    tag_cmd = " git tag -a " + ver_str + " -m 'Release " + ver_str + "' " 
+    cmd("cd lvgl; " + tag_cmd)    
+    cmd("cd lv_examples; " + tag_cmd)    
+    cmd("cd lv_drivers; " + tag_cmd)    
+    cmd("cd docs; " + tag_cmd)    
+    
+def update_release_branches():
+    global release_br
+    merge_cmd = " git checkout " + release_br + "; git pull origin " + release_br + "; git merge master  -X ours; git push origin " + release_br + "; git checkout master" 
+    cmd("cd lvgl; " + merge_cmd)    
+    cmd("cd lv_examples; " + merge_cmd)    
+    cmd("cd lv_drivers; " + merge_cmd)    
+    
+    merge_cmd = " git checkout " + release_br + "; git pull origin " + release_br  + "; git merge latest  -X ours; git push origin " + release_br + "; git checkout latest" 
+    cmd("cd docs; " + merge_cmd)
+    
+def publish_master():   
+    
+    #Merge LVGL master to dev first to avoid "merge-to-dev.yml" running asynchronous
+    os.chdir("./lvgl")
+    cmd("git checkout dev")
+    cmd("git merge master -X theirs")
+    cmd("git add .")
+    cmd("git commit -am 'Merge master'")
+    cmd("git push origin dev")
+    cmd("git checkout master")    
+    os.chdir("../")
+    
+    pub_cmd = "git push origin master; git push origin " + ver_str
+    cmd("cd lvgl; " + pub_cmd)    
+    cmd("cd lv_examples; " + pub_cmd)    
+    cmd("cd lv_drivers; " + pub_cmd)    
+
+    pub_cmd = "git push origin latest; git push origin " + ver_str
+    cmd("cd docs; " + pub_cmd)    
+    cmd("cd docs; git checkout master; ./update.py " + release_br)
+    
+    pub_cmd = "git push origin master"
+    cmd("cd blog; " + pub_cmd)    
+    
+    
+def merge_to_dev():
+    merge_cmd = "git checkout dev; git pull origin dev; git merge master -X ours; git checkout master"
+    cmd("cd lvgl; " + merge_cmd)    
+    
+    merge_cmd = "git checkout dev --;  git pull origin dev; git merge latest -X ours; git checkout master"
+    cmd("cd docs; " + merge_cmd)    
+    
+    
+def merge_from_dev():
+    merge_cmd = "git checkout master; git merge dev;"
+    cmd("cd lvgl; " + merge_cmd)    
+    
+    merge_cmd = "git checkout latest -- ; git merge dev;"
+    cmd("cd docs; " + merge_cmd)    
+        
+
+def lvgl_update_master_version():
+    global ver_major, ver_minor, ver_patch, ver_str
+    
+    os.chdir("./lvgl")
+
+    cmd("git checkout master")
+    define_set("./lvgl.h", "LVGL_VERSION_MAJOR", ver_major)
+    define_set("./lvgl.h", "LVGL_VERSION_MINOR", ver_minor)
+    define_set("./lvgl.h", "LVGL_VERSION_PATCH", ver_patch)
+    define_set("./lvgl.h", "LVGL_VERSION_INFO", "dev")
+    
+    templ = fnmatch.filter(os.listdir('.'), '*templ*')
+    if templ[0]:    
+        print("Updating version in " + templ[0])
+        cmd("sed -i -r 's/v[0-9]+\.[0-9]+\.[0-9]+.*/"+ ver_str +"/' " + templ[0])
+    
+    
+    cmd("git commit -am 'Update version'")
+    
+    os.chdir("../")
+
+def docs_update_latest_version():
+    global ver_str
+    
+    os.chdir("./docs")
+    cmd("git checkout latest --")
+    cmd("sed -i -r \"s/'v[0-9]+\.[0-9]+\.[0-9]+.*'/\'" + ver_str + "'/\" conf.py")   
+    cmd("git commit -am 'Update version'")
+    cmd("git checkout master --")
+    
+    os.chdir("../")
+        
+        
+def lvgl_update_dev_version():
+    global ver_major, ver_minor, ver_patch, dev_ver_str
+    
+    os.chdir("./lvgl")
+
+    cmd("git checkout dev")
+    define_set("./lvgl.h", "LVGL_VERSION_MAJOR", ver_major)
+    define_set("./lvgl.h", "LVGL_VERSION_MINOR", ver_minor)
+    define_set("./lvgl.h", "LVGL_VERSION_PATCH", ver_patch)
+    define_set("./lvgl.h", "LVGL_VERSION_INFO", "\"dev\"")
+    
+    templ = fnmatch.filter(os.listdir('.'), '*templ*')
+    if templ[0]:    
+        print("Updating version in " + templ[0])
+        cmd("sed -i -r 's/v[0-9]+\.[0-9]+\.[0-9]+.*/"+ dev_ver_str +"/' " + templ[0])
+    
+    
+    cmd("git commit -am 'Update dev version'")
+    cmd("git checkout master")
+    
+    os.chdir("../")
+
+def docs_update_dev_version():
+    global dev_ver_str
+    
+    os.chdir("./docs")
+    cmd("git checkout dev --")
+    cmd("sed -i -r \"s/'v[0-9]+\.[0-9]+\.[0-9]+.*'/\'" + dev_ver_str + "'/\" conf.py")   
+    cmd("git commit -am 'Update dev version'")
+    cmd("git checkout master --")
+    
+    os.chdir("../")
+
+
+def publish_dev_and_master():   
+    pub_cmd = "git checkout dev; git push origin dev"
+    cmd("cd lvgl; " + pub_cmd)    
+    pub_cmd = "git checkout master; git push origin master"
+    cmd("cd lvgl; " + pub_cmd)    
+
+    cmd("cd docs; git checkout master; ./update.py latest dev")
+
+def projs_update():
+    global proj_list, release_br, ver_str
+    for p in proj_list:
+        os.chdir("./" + p)
+        cmd('git checkout master')
+        print(p + ": upadte lvgl");
+        cmd("cd lvgl; git co " + release_br + "; git pull origin " + release_br)
+        cmd("cp -f lvgl/lv_conf_template.h lv_conf.h")
+        cmd("sed -i -r 's/#if 0/#if 1/' lv_conf.h")  # Enable lv_conf.h
+        d = {}
+        with open("confdef.txt") as f:
+            for line in f:
+                (key, val) = line.rstrip().split('\t')
+                d[key] = val
+
+        for k,v in d.items():
+            define_set("lv_conf.h", str(k), str(v))        
+            
+        if os.path.exists("lv_examples"): 
+            print(p + ": upadte lv_examples");
+            cmd("cd lv_examples; git co " + release_br + "; git pull origin " + release_br)
+            
+        if os.path.exists("lv_drivers"): 
+            print(p + ": upadte lv_drivers");
+            cmd("cd lv_drivers " + release_br + "; git pull origin " + release_br)
+
+        msg = 'Update to ' + ver_str
+        cmd("git add .")
+        cmd('git commit -am "' + msg +  '"')
+        cmd('git push origin master')
+        cmd("git tag -a " + ver_str + " -m '" + msg + "' " )
+        cmd('git push origin ' + ver_str)
+        
+        os.chdir("../")
+        
+
+def cleanup():
+    os.chdir("../")
+    cmd("rm -fr " + workdir)
+
+if __name__ == '__main__':
+    dev_prepare = 'minor'
+    if(len(sys.argv) != 2):
+        print("Missing argument. Usage ./release.py bugfix | minor | major")
+        print("Use minor by deafult")
+    else:      
+        dev_prepare = sys.argv[1]
+    
+    if not (dev_prepare in prepare_type): 
+        print("Invalid argument. Usage ./release.py bugfix | minor | major") 
+        exit(1)
+        
+    clone_repos()
+    get_lvgl_version("master")
+    lvgl_prepare()
+    lv_examples_prepare() 
+    lv_drivers_prepare()
+    docs_prepare()
+    blog_add_post()
+    add_tags()
+    update_release_branches()
+    publish_master()
+ 
+    if dev_prepare == 'bugfix': 
+        ver_patch = str(int(ver_patch) + 1)
+        ver_str = "v" + ver_major + "." + ver_minor + "." + ver_patch + "-dev"    
+
+        print("Prepare bugfix version " + ver_str)
+
+        lvgl_update_master_version()
+        docs_update_latest_version()
+
+        get_lvgl_version("dev")
+        dev_ver_str = "v" + ver_major + "." + ver_minor + "." + ver_patch + "-dev"
+        merge_to_dev()
+        
+        lvgl_update_dev_version()
+        docs_update_dev_version()
+        publish_dev()
+    else:
+        get_lvgl_version("dev")
+        if dev_prepare == 'minor': 
+            ver_minor = str(int(ver_minor) + 1)
+            ver_patch = "0"
+        else:
+            ver_major = str(int(ver_major) + 1)
+            ver_minor = "0"
+            ver_patch = "0"
+                
+        dev_ver_str = "v" + ver_major + "." + ver_minor + "." + ver_patch + "-dev"
+        
+        print("Prepare minor version " + ver_str)
+
+        merge_to_dev()
+        merge_from_dev()
+
+        lvgl_update_dev_version()
+        docs_update_dev_version()
+        publish_dev_and_master()
+        
+    projs_update()    
+    cleanup()
+    

scripts/release_patch.py

@@ -1,189 +0,0 @@
-import re
-import os
-lastNum = re.compile(r'(?:[^\d]*(\d+)[^\d]*)+')
-
-   
-def title(t):
-	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)
-
-
-def lvgl_clone():
-	title("lvgl: Clone")
-	cmd("git clone https://github.com/lvgl/lvgl.git")
-	os.chdir("./lvgl")
-	cmd("git co master") 
-
-def lvgl_update_version():
-	title("lvgl: Update version number")
-
-	f = open("./src/lv_version.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()
-
-	f = open("./src/lv_version.h", "w")
-		  
-	f.write(outbuf)
-	f.close()
-    
-	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")
-
-	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", "w")
-		  
-	f.write(outbuf)
-	f.close()
-
-def lvgl_commit_push(v):
-	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)
-	
-def lvgl_update_api_docs():
-	title("lvgl: Update API with Doxygen")
-
-	cmd("cd scripts; doxygen");
-
-
-def docs_clone():
-	title("docs: Clone")
-	os.chdir("../")
-	cmd("git clone --recursive https://github.com/lvgl/docs.git")
-	os.chdir("./docs/v7")
-	cmd("git co master") 
-
-def docs_get_api():
-	title("docs: Get API files")
-	
-	cmd("rm -rf xml");	
-	cmd("cp -r ../lvgl/docs/api_doc/xml .");	
-
-
-def docs_update_version(v):
-	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 + "'"
-
-		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()
-
-def docs_update_trans():
-	title("docs: Update translations")
-	cmd("cd en && ./trans_push.py && ./trans_pull.py")
-
-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)
-	
-def clean_up():
-	title("Clean up repos")
-	os.chdir("..")
-	cmd("rm -rf lvgl docs")
-
-lvgl_clone()
-lvgl_update_api_docs()
-ver_str = lvgl_update_version()    
-lvgl_update_library_json(ver_str)
-lvgl_commit_push(ver_str)
-
-docs_clone()
-docs_get_api()
-docs_update_version(ver_str)
-#docs_update_trans() # Zanata is not working now
-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
@@ -172,12 +172,60 @@ static inline lv_scrollbar_mode_t lv_page_get_scrlbar_mode(lv_obj_t * page)
 
 static inline lv_obj_t * lv_page_get_scrl(lv_obj_t * page)
 {
-    return lv_page_get_scrllable(page);
+    return lv_page_get_scrollable(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);
+}
+
+
+static inline void lv_chart_clear_serie(lv_obj_t * chart, lv_chart_series_t * series)
+{
+    lv_chart_clear_series(chart, series);
+}
+
+#endif
+
+static inline 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)
+{
+    lv_obj_align_mid(obj, base, align, x_ofs, y_ofs);
+}
+
+static inline 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_obj_align_mid_y(obj, base, align, x_ofs);
+}
+
+static inline 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_obj_align_mid_y(obj, base, align, y_ofs);
+}
+
+#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
 
 /*=================
@@ -748,7 +805,7 @@
 #endif
 #endif
 
-/*1: enable `lv_obj_realaign()` based on `lv_obj_align()` parameters*/
+/*1: enable `lv_obj_realign()` based on `lv_obj_align()` parameters*/
 #ifndef LV_USE_OBJ_REALIGN
 #define LV_USE_OBJ_REALIGN          1
 #endif
@@ -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
@@ -985,6 +1047,11 @@
 #endif
 #endif
 
+/*Rotary (dependencies: lv_arc, lv_btn)*/
+#ifndef LV_USE_ROTARY
+#define LV_USE_ROTARY     1
+#endif
+
 /*Slider (dependencies: lv_bar)*/
 #ifndef LV_USE_SLIDER
 #define LV_USE_SLIDER    1

src/lv_core/lv_core.mk

@@ -4,7 +4,6 @@ CSRCS += lv_disp.c
 CSRCS += lv_obj.c
 CSRCS += lv_refr.c
 CSRCS += lv_style.c
-CSRCS += lv_debug.c
 
 DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_core
 VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_core

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
  **********************/
@@ -152,7 +209,12 @@ static inline void lv_scr_load(lv_obj_t * scr)
  * 1 dip is 2 px on a 320 DPI screen
  * https://stackoverflow.com/questions/2025282/what-is-the-difference-between-px-dip-dp-and-sp
  */
-#define LV_DPX(n)   LV_MATH_MAX((( lv_disp_get_dpi(NULL) * (n) + 80) / 160), 1) /*+80 for rounding*/
+#define LV_DPX(n)   (n == 0 ? 0 :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" */

src/lv_core/lv_group.c

@@ -9,7 +9,7 @@
 #include "lv_group.h"
 #if LV_USE_GROUP != 0
 #include <stddef.h>
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_themes/lv_theme.h"
 #include "../lv_misc/lv_gc.h"
 
@@ -242,7 +242,7 @@ void lv_group_focus_obj(lv_obj_t * obj)
                 if(res != LV_RES_OK) return;
                 lv_obj_invalidate(*g->obj_focus);
 
-                /*If the object or its parent has `top == true` bring it to the foregorund*/
+                /*If the object or its parent has `top == true` bring it to the foreground*/
                 obj_to_foreground(*g->obj_focus);
             }
             break;
@@ -508,7 +508,7 @@ static void focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *)
     lv_res_t res = lv_event_send(*group->obj_focus, LV_EVENT_FOCUSED, NULL);
     if(res != LV_RES_OK) return;
 
-    /*If the object or its parent has `top == true` bring it to the foregorund*/
+    /*If the object or its parent has `top == true` bring it to the foreground*/
     obj_to_foreground(*group->obj_focus);
 
     lv_obj_invalidate(*group->obj_focus);

src/lv_core/lv_group.h

@@ -155,7 +155,7 @@ lv_res_t lv_group_send_data(lv_group_t * group, uint32_t c);
 void lv_group_set_focus_cb(lv_group_t * group, lv_group_focus_cb_t focus_cb);
 
 /**
- * Set whether the next or previous item in a group is focused if the currently focussed obj is
+ * Set whether the next or previous item in a group is focused if the currently focused obj is
  * deleted.
  * @param group pointer to a group
  * @param new refocus policy enum

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*/
@@ -791,7 +857,7 @@ static void indev_proc_press(lv_indev_proc_t * proc)
                                                                           &proc->types.pointer.act_point);
         new_obj_searched = true;
     }
-    /*If a dragable or a protected object was the last then keep it*/
+    /*If a draggable or a protected object was the last then keep it*/
     else {
     }
 
@@ -1049,7 +1115,7 @@ static void indev_proc_reset_query_handler(lv_indev_t * indev)
 /**
  * Search the most top, clickable object by a point
  * @param obj pointer to a start object, typically the screen
- * @param point pointer to a point for searhing the most top child
+ * @param point pointer to a point for searching the most top child
  * @return pointer to the found object or NULL if there was no suitable object
  */
 lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
@@ -1086,14 +1152,15 @@ lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point)
 }
 
 /**
- * Handle focus/defocus on click for POINTER inpt devices
+ * Handle focus/defocus on click for POINTER input devices
  * @param proc pointer to the state of the indev
  */
 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;
     }
 
 }
@@ -1399,7 +1468,7 @@ static void indev_drag_throw(lv_indev_proc_t * proc)
 
 /**
  * Get the really dragged object by taking `drag_parent` into account.
- * @param obj the start obejct
+ * @param obj the start object
  * @return the object to really drag
  */
 static lv_obj_t * get_dragged_obj(lv_obj_t * obj)
@@ -1421,18 +1490,18 @@ static lv_obj_t * get_dragged_obj(lv_obj_t * obj)
 static void indev_gesture(lv_indev_proc_t * proc)
 {
 
-    if(proc->types.pointer.drag_in_prog) return;
     if(proc->types.pointer.gesture_sent) return;
 
     lv_obj_t * gesture_obj = proc->types.pointer.act_obj;
 
-    /*If gesture parent is active check recursively the drag_parent attribute*/
+    /*If gesture parent is active check recursively the gesture attribute*/
     while(gesture_obj && lv_obj_get_gesture_parent(gesture_obj)) {
         gesture_obj = lv_obj_get_parent(gesture_obj);
     }
 
     if(gesture_obj == NULL) return;
 
+
     if((LV_MATH_ABS(proc->types.pointer.vect.x) < indev_act->driver.gesture_min_velocity) &&
        (LV_MATH_ABS(proc->types.pointer.vect.y) < indev_act->driver.gesture_min_velocity)) {
         proc->types.pointer.gesture_sum.x = 0;

src/lv_core/lv_indev.h

@@ -160,7 +160,7 @@ lv_obj_t * lv_indev_get_obj_act(void);
 /**
  * Search the most top, clickable object by a point
  * @param obj pointer to a start object, typically the screen
- * @param point pointer to a point for searhing the most top child
+ * @param point pointer to a point for searching the most top child
  * @return pointer to the found object or NULL if there was no suitable object
  */
 lv_obj_t * lv_indev_search_obj(lv_obj_t * obj, lv_point_t * point);

src/lv_core/lv_obj.h

@@ -21,6 +21,7 @@ extern "C" {
 #include "../lv_misc/lv_types.h"
 #include "../lv_misc/lv_area.h"
 #include "../lv_misc/lv_color.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_hal/lv_hal.h"
 #include "../lv_draw/lv_draw_rect.h"
 #include "../lv_draw/lv_draw_label.h"
@@ -46,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
  **********************/
@@ -90,7 +94,7 @@ enum {
     LV_EVENT_DRAG_BEGIN,
     LV_EVENT_DRAG_END,
     LV_EVENT_DRAG_THROW_BEGIN,
-    LV_EVENT_GESTURE,           /**< The object has been getture*/
+    LV_EVENT_GESTURE,           /**< The object has been gesture*/
     LV_EVENT_KEY,
     LV_EVENT_FOCUSED,
     LV_EVENT_DEFOCUSED,
@@ -101,6 +105,7 @@ enum {
     LV_EVENT_APPLY,  /**< "Ok", "Apply" or similar specific button has clicked*/
     LV_EVENT_CANCEL, /**< "Close", "Cancel" or similar specific button has clicked*/
     LV_EVENT_DELETE, /**< Object is being deleted */
+    _LV_EVENT_LAST /** Number of events*/
 };
 typedef uint8_t lv_event_t; /**< Type of event being sent to the object. */
 
@@ -158,7 +163,7 @@ typedef struct {
     lv_coord_t yofs;
     lv_align_t align;
     uint8_t auto_realign : 1;
-    uint8_t origo_align : 1; /**< 1: the origo (center of the object) was aligned with
+    uint8_t mid_align : 1; /**< 1: the origo (center of the object) was aligned with
                                 `lv_obj_align_origo`*/
 } lv_realign_t;
 #endif
@@ -209,7 +214,7 @@ typedef struct _lv_obj_t {
     lv_area_t ext_click_pad;   /**< Extra click padding area. */
 #endif
 
-    lv_coord_t ext_draw_pad; /**< EXTtend the size in every direction for drawing. */
+    lv_coord_t ext_draw_pad; /**< EXTend the size in every direction for drawing. */
 
     /*Attributes and states*/
     uint8_t click           : 1; /**< 1: Can be pressed by an input device*/
@@ -220,7 +225,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 */
@@ -245,8 +251,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,
 };
 
@@ -348,6 +354,22 @@ void lv_obj_invalidate_area(const lv_obj_t * obj, const lv_area_t * area);
  */
 void lv_obj_invalidate(const lv_obj_t * obj);
 
+
+/**
+ * Tell whether an area of an object is visible (even partially) now or not
+ * @param obj pointer to an object
+ * @param area the are to check. The visible part of the area will be written back here.
+ * @return true: visible; false: not visible (hidden, out of parent, on other screen, etc)
+ */
+bool lv_obj_area_is_visible(const lv_obj_t * obj, lv_area_t * area);
+
+/**
+ * Tell whether an object is visible (even partially) now or not
+ * @param obj pointer to an object
+ * @return true: visible; false: not visible (hidden, out of parent, on other screen, etc)
+ */
+bool lv_obj_is_visible(const lv_obj_t * obj);
+
 /*=====================
  * Setter functions
  *====================*/
@@ -439,7 +461,7 @@ void lv_obj_set_height_fit(lv_obj_t * obj, lv_coord_t h);
 
 /**
  * Set the width of an object by taking the left and right margin into account.
- * The object width will be `obj_w = w - margon_left - margin_right`
+ * The object width will be `obj_w = w - margin_left - margin_right`
  * @param obj pointer to an object
  * @param w new height including margins
  */
@@ -447,7 +469,7 @@ void lv_obj_set_width_margin(lv_obj_t * obj, lv_coord_t w);
 
 /**
  * Set the height of an object by taking the top and bottom margin into account.
- * The object height will be `obj_h = h - margon_top - margin_bottom`
+ * The object height will be `obj_h = h - margin_top - margin_bottom`
  * @param obj pointer to an object
  * @param h new height including margins
  */
@@ -463,6 +485,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
@@ -471,7 +511,26 @@ void lv_obj_align(lv_obj_t * obj, const lv_obj_t * base, lv_align_t align, lv_co
  * @param x_ofs x coordinate offset after alignment
  * @param y_ofs y coordinate offset after alignment
  */
-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);
+void lv_obj_align_mid(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_mid_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_mid_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.
@@ -544,7 +603,7 @@ void lv_obj_reset_style_list(lv_obj_t * obj, uint8_t part);
  * @param obj pointer to an object
  * @param prop `LV_STYLE_PROP_ALL` or an `LV_STYLE_...` property. It is used to optimize what needs to be refreshed.
  */
-void lv_obj_refresh_style(lv_obj_t * obj, lv_style_property_t prop);
+void lv_obj_refresh_style(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
 
 /**
  * Notify all object if a style is modified
@@ -618,10 +677,17 @@ void _lv_obj_set_style_local_ptr(lv_obj_t * obj, uint8_t type, lv_style_property
  * E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
  * @note shouldn't be used directly. Use the specific property remove functions instead.
  *       For example: `lv_obj_style_remove_border_opa()`
- * @return true: the property was found and removed; false: teh property was not found
+ * @return true: the property was found and removed; false: the property was not found
  */
 bool lv_obj_remove_style_local_prop(lv_obj_t * obj, uint8_t part, lv_style_property_t prop);
 
+/**
+ * Enable/disable the use of style cahche for an object
+ * @param obj pointer to an object
+ * @param dis true: disable; false: enable (re-enable)
+ */
+void _lv_obj_disable_style_caching(lv_obj_t * obj, bool dis);
+
 /*-----------------
  * Attribute set
  *----------------*/
@@ -658,7 +724,7 @@ void lv_obj_set_top(lv_obj_t * obj, bool en);
 /**
  * Enable the dragging of an object
  * @param obj pointer to an object
- * @param en true: make the object dragable
+ * @param en true: make the object draggable
  */
 void lv_obj_set_drag(lv_obj_t * obj, bool en);
 
@@ -684,6 +750,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
@@ -773,6 +847,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.
@@ -847,7 +935,6 @@ lv_obj_t * lv_obj_get_screen(const lv_obj_t * obj);
 
 /**
  * Get the display of an object
- * @param scr pointer to an object
  * @return pointer the object's display
  */
 lv_disp_t * lv_obj_get_disp(const lv_obj_t * obj);
@@ -956,7 +1043,7 @@ lv_coord_t lv_obj_get_height_fit(const lv_obj_t * obj);
 
 /**
  * Get the height of an object by taking the top and bottom margin into account.
- * The returned height will be `obj_h + margon_top + margin_bottom`
+ * The returned height will be `obj_h + margin_top + margin_bottom`
  * @param obj pointer to an object
  * @return the height including thee margins
  */
@@ -964,7 +1051,7 @@ lv_coord_t lv_obj_get_height_margin(lv_obj_t * obj);
 
 /**
  * Get the width of an object by taking the left and right margin into account.
- * The returned width will be `obj_w + margon_left + margin_right`
+ * The returned width will be `obj_w + margin_left + margin_right`
  * @param obj pointer to an object
  * @return the height including thee margins
  */
@@ -1043,7 +1130,7 @@ lv_coord_t lv_obj_get_ext_draw_pad(const lv_obj_t * obj);
  *---------------*/
 
 /**
- * Get the style list of an obejct's part.
+ * Get the style list of an object's part.
  * @param obj pointer to an object.
  * @param part part the part of the object which style list should be get.
  * E.g. `LV_OBJ_PART_MAIN`, `LV_BTN_PART_MAIN`, `LV_SLIDER_PART_KNOB`
@@ -1162,7 +1249,7 @@ bool lv_obj_get_top(const lv_obj_t * obj);
 /**
  * Get the drag enable attribute of an object
  * @param obj pointer to an object
- * @return true: the object is dragable
+ * @return true: the object is draggable
  */
 bool lv_obj_get_drag(const lv_obj_t * obj);
 
@@ -1187,6 +1274,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 +1414,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
  *------------------*/
@@ -1348,7 +1451,7 @@ void lv_obj_init_draw_line_dsc(lv_obj_t * obj, uint8_t part, lv_draw_line_dsc_t
 
 /**
  * Get the required extra size (around the object's part) to draw shadow, outline, value etc.
- * @param obj poinr to an object
+ * @param obj pointer to an object
  * @param part part of the object
  */
 lv_coord_t lv_obj_get_draw_rect_ext_pad_size(lv_obj_t * obj, uint8_t part);
@@ -1369,6 +1472,23 @@ void lv_obj_fade_in(lv_obj_t * obj, uint32_t time, uint32_t delay);
  */
 void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay);
 
+/**
+ * Check if any object has a given type
+ * @param obj pointer to an object
+ * @param obj_type type of the object. (e.g. "lv_btn")
+ * @return true: valid
+ */
+bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type);
+
+/**
+ * Check if any object is still "alive", and part of the hierarchy
+ * @param obj pointer to an object
+ * @param obj_type type of the object. (e.g. "lv_btn")
+ * @return true: valid
+ */
+bool lv_debug_check_obj_valid(const lv_obj_t * obj);
+
+
 /**********************
  *      MACROS
  **********************/
@@ -1378,7 +1498,7 @@ void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay);
  * Will be expanded to: `static void <name> (lv_obj_t * obj, lv_event_t e)`
  *
  * Examples:
- * LV_EVENT_CB_DECLARE(my_event1);  //Protoype declaration
+ * LV_EVENT_CB_DECLARE(my_event1);  //Prototype declaration
  *
  * LV_EVENT_CB_DECLARE(my_event1)
  * {
@@ -1389,6 +1509,32 @@ void lv_obj_fade_out(lv_obj_t * obj, uint32_t time, uint32_t delay);
  */
 #define LV_EVENT_CB_DECLARE(name) static void name(lv_obj_t * obj, lv_event_t e)
 
+
+#if LV_USE_DEBUG
+
+# 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))
+# endif
+
+
+# if LV_USE_ASSERT_OBJ
+#  ifndef LV_ASSERT_OBJ
+#   define LV_ASSERT_OBJ(obj_p, obj_type) LV_DEBUG_ASSERT(LV_DEBUG_IS_OBJ(obj_p, obj_type), "Invalid object", obj_p);
+#  endif
+# else /* LV_USE_ASSERT_OBJ == 0 */
+#  if LV_USE_ASSERT_NULL /*Use at least LV_ASSERT_NULL if enabled*/
+#    define LV_ASSERT_OBJ(obj_p, obj_type) LV_ASSERT_NULL(obj_p)
+#  else
+#    define LV_ASSERT_OBJ(obj_p, obj_type) true
+#  endif
+# endif
+#else
+# define LV_ASSERT_OBJ(obj, obj_type) true
+#endif
+
+
 #ifdef __cplusplus
 } /* extern "C" */
 #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

@@ -159,7 +159,7 @@ lv_disp_t * _lv_refr_get_disp_refreshing(void)
 
 /**
  * Set the display which is being refreshed.
- * It shouldn1t be used directly by the user.
+ * It shouldn't be used directly by the user.
  * It can be used to trick the drawing functions about there is an active display.
  * @param the display being refreshed
  */
@@ -202,55 +202,60 @@ void _lv_disp_refr_task(lv_task_t * task)
     if(disp_refr->inv_p != 0) {
         /* In true double buffered mode copy the refreshed areas to the new VDB to keep it up to date.
          * With set_px_cb we don't know anything about the buffer (even it's size) so skip copying.*/
-        if(lv_disp_is_true_double_buf(disp_refr) && disp_refr->driver.set_px_cb == NULL) {
-            lv_disp_buf_t * vdb = lv_disp_get_buf(disp_refr);
-
-            /*Flush the content of the VDB*/
-            lv_refr_vdb_flush();
-
-            /* With true double buffering the flushing should be only the address change of the
-             * current frame buffer. Wait until the address change is ready and copy the changed
-             * content to the other frame buffer (new active VDB) to keep the buffers synchronized*/
-            while(vdb->flushing);
-
-            lv_color_t * copy_buf = NULL;
-#if LV_USE_GPU_STM32_DMA2D
-            LV_UNUSED(copy_buf);
-#else
-            copy_buf = _lv_mem_buf_get(disp_refr->driver.hor_res * sizeof(lv_color_t));
-#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;
-
-            lv_coord_t hres = lv_disp_get_hor_res(disp_refr);
-            uint16_t a;
-            for(a = 0; a < disp_refr->inv_p; a++) {
-                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
-                    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
-
-                    lv_coord_t y;
-                    uint32_t line_length = lv_area_get_width(&disp_refr->inv_areas[a]) * sizeof(lv_color_t);
-
-                    for(y = disp_refr->inv_areas[a].y1; y <= disp_refr->inv_areas[a].y2; y++) {
-                        /* The frame buffer is probably in an external RAM where sequential access is much faster.
-                         * So first copy a line into a buffer and write it back the ext. RAM */
-                        _lv_memcpy(copy_buf, buf_ina + start_offs, line_length);
-                        _lv_memcpy(buf_act + start_offs, copy_buf, line_length);
-                        start_offs += hres * sizeof(lv_color_t);
-                    }
-#endif
-                }
+        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 {
+                lv_disp_buf_t * vdb = lv_disp_get_buf(disp_refr);
 
-            if(copy_buf) _lv_mem_buf_release(copy_buf);
+                /*Flush the content of the VDB*/
+                lv_refr_vdb_flush();
+
+                /* With true double buffering the flushing should be only the address change of the
+                 * current frame buffer. Wait until the address change is ready and copy the changed
+                 * content to the other frame buffer (new active VDB) to keep the buffers synchronized*/
+                while(vdb->flushing);
+
+                lv_color_t * copy_buf = NULL;
+#if LV_USE_GPU_STM32_DMA2D
+                LV_UNUSED(copy_buf);
+#else
+                copy_buf = _lv_mem_buf_get(disp_refr->driver.hor_res * sizeof(lv_color_t));
+#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;
+
+                lv_coord_t hres = lv_disp_get_hor_res(disp_refr);
+                uint16_t a;
+                for(a = 0; a < disp_refr->inv_p; a++) {
+                    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
+                        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
+
+                        lv_coord_t y;
+                        uint32_t line_length = lv_area_get_width(&disp_refr->inv_areas[a]) * sizeof(lv_color_t);
+
+                        for(y = disp_refr->inv_areas[a].y1; y <= disp_refr->inv_areas[a].y2; y++) {
+                            /* The frame buffer is probably in an external RAM where sequential access is much faster.
+                             * So first copy a line into a buffer and write it back the ext. RAM */
+                            _lv_memcpy(copy_buf, buf_ina + start_offs, line_length);
+                            _lv_memcpy(buf_act + start_offs, copy_buf, line_length);
+                            start_offs += hres * sizeof(lv_color_t);
+                        }
+#endif
+                    }
+                }
+
+                if(copy_buf) _lv_mem_buf_release(copy_buf);
+            }
         } /*End of true double buffer handling*/
 
         /*Clean up*/
@@ -485,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'*/
@@ -493,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);
@@ -521,10 +572,15 @@ static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
 
     /*If this object is fully cover the draw area check the children too */
     if(_lv_area_is_in(area_p, &obj->coords, 0) && obj->hidden == 0) {
-        lv_design_res_t design_res = obj->design_cb ? obj->design_cb(obj, area_p,
-                                                                     LV_DESIGN_COVER_CHK) : LV_DESIGN_RES_NOT_COVER;
+        lv_design_res_t design_res = obj->design_cb(obj, area_p, LV_DESIGN_COVER_CHK);
         if(design_res == LV_DESIGN_RES_MASKED) return NULL;
 
+#if LV_USE_OPA_SCALE
+        if(design_res == LV_DESIGN_RES_COVER && lv_obj_get_style_opa_scale(obj, LV_OBJ_PART_MAIN) != LV_OPA_COVER) {
+            design_res = LV_DESIGN_RES_NOT_COVER;
+        }
+#endif
+
         lv_obj_t * i;
         _LV_LL_READ(obj->child_ll, i) {
             found_p = lv_refr_get_top_obj(area_p, i);

src/lv_core/lv_refr.h

@@ -72,7 +72,7 @@ lv_disp_t * _lv_refr_get_disp_refreshing(void);
 
 /**
  * Set the display which is being refreshed.
- * It shouldn1t be used directly by the user.
+ * It shouldn't be used directly by the user.
  * It can be used to trick the drawing functions about there is an active display.
  * @param the display being refreshed
  */

src/lv_core/lv_style.c

@@ -7,7 +7,6 @@
  *      INCLUDES
  *********************/
 #include "lv_obj.h"
-#include "../lv_core/lv_debug.h"
 #include "../lv_misc/lv_mem.h"
 #include "../lv_misc/lv_anim.h"
 
@@ -37,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
@@ -103,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;
@@ -120,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;
         }
@@ -256,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");
@@ -270,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;
 }
@@ -336,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);
@@ -369,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;
         }
@@ -386,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;
 
@@ -415,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;
         }
@@ -433,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;
 
@@ -462,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;
         }
@@ -480,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;
 
@@ -509,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;
         }
@@ -527,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;
 
@@ -561,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);
     }
 }
 
@@ -598,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);
     }
 }
 
@@ -632,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);
     }
 }
 
@@ -667,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);
     }
 }
 
@@ -820,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;
 
@@ -872,12 +870,13 @@ 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;
 
-    lv_color_t value_act = { 0 };
+    lv_color_t value_act;
+    value_act.full = 0;
 
     int16_t ci;
     for(ci = 0; ci < list->style_cnt; ci++) {
@@ -922,8 +921,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;
 
@@ -972,8 +971,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;
 
@@ -1003,6 +1002,44 @@ lv_res_t _lv_style_list_get_ptr(lv_style_list_t * list, lv_style_property_t prop
     else return LV_RES_INV;
 }
 
+/**
+ * Check whether a style is valid (initialized correctly)
+ * @param style pointer to a style
+ * @return true: valid
+ */
+bool lv_debug_check_style(const lv_style_t * style)
+{
+    if(style == NULL) return true;  /*NULL style is still valid*/
+
+#if LV_USE_ASSERT_STYLE
+    if(style->sentinel != LV_DEBUG_STYLE_SENTINEL_VALUE) {
+        LV_LOG_WARN("Invalid style (local variable or not initialized?)");
+        return false;
+    }
+#endif
+
+    return true;
+}
+
+/**
+ * Check whether a style list is valid (initialized correctly)
+ * @param style pointer to a style
+ * @return true: valid
+ */
+bool lv_debug_check_style_list(const lv_style_list_t * list)
+{
+    if(list == NULL) return true;  /*NULL list is still valid*/
+
+#if LV_USE_ASSERT_STYLE
+    if(list->sentinel != LV_DEBUG_STYLE_LIST_SENTINEL_VALUE) {
+        LV_LOG_WARN("Invalid style (local variable or not initialized?)");
+        return false;
+    }
+#endif
+
+    return true;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -1023,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;
@@ -1071,7 +1104,7 @@ static lv_style_t * get_alloc_local_style(lv_style_list_t * list)
 {
     LV_ASSERT_STYLE_LIST(list);
 
-    if(list->has_local) return lv_style_list_get_style(list, 0);
+    if(list->has_local) return lv_style_list_get_style(list, list->has_trans ? 1 : 0);
 
     lv_style_t * local_style = lv_mem_alloc(sizeof(lv_style_t));
     LV_ASSERT_MEM(local_style);
@@ -1081,9 +1114,85 @@ static lv_style_t * get_alloc_local_style(lv_style_list_t * list)
     }
     lv_style_init(local_style);
 
-    /*Add the local style to the furst place*/
+    /*Add the local style to the first place*/
     _lv_style_list_add_style(list, local_style);
     list->has_local = 1;
 
     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

@@ -19,6 +19,7 @@ extern "C" {
 #include "../lv_misc/lv_area.h"
 #include "../lv_misc/lv_anim.h"
 #include "../lv_misc/lv_types.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_draw/lv_draw_blend.h"
 
 /*********************
@@ -80,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*/
@@ -101,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),
@@ -136,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),
@@ -193,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;
@@ -223,11 +221,37 @@ typedef struct {
 #if LV_USE_ASSERT_STYLE
     uint32_t sentinel;
 #endif
-    uint8_t style_cnt;
-    uint8_t has_local    : 1;
-    uint8_t has_trans    : 1;
-    uint8_t skip_trans   : 1;       /*1: Temporally skip the transition style if any*/
-    uint8_t ignore_trans   : 1;     /*1: Mark that this style list shouldn't receive transitions at all*/
+    uint32_t style_cnt     : 6;
+    uint32_t has_local     : 1;
+    uint32_t has_trans     : 1;
+    uint32_t skip_trans    : 1;      /*1: Temporally skip the transition style if any*/
+    uint32_t ignore_trans  : 1;      /*1: Mark that this style list shouldn't receive transitions at all*/
+    uint32_t valid_cache   : 1;      /*1: The cache is valid and can be used*/
+    uint32_t ignore_cache  : 1;      /*1: Ignore cache while getting value of properties*/
+
+    uint32_t radius_zero : 1;
+    uint32_t opa_scale_cover      : 1;
+    uint32_t clip_corner_off       : 1;
+    uint32_t transform_all_zero  : 1;
+    uint32_t pad_all_zero : 1;
+    uint32_t blend_mode_all_normal : 1;
+    uint32_t bg_opa_transp : 1;
+    uint32_t bg_opa_cover : 1;
+    uint32_t bg_grad_dir_none : 1;
+
+    uint32_t border_width_zero : 1;
+    uint32_t border_side_full : 1;
+    uint32_t border_post_off : 1;
+
+    uint32_t outline_width_zero : 1;
+    uint32_t pattern_img_null : 1;
+    uint32_t shadow_width_zero : 1;
+    uint32_t value_txt_str : 1;
+    uint32_t img_recolor_opa_transp : 1;
+
+    uint32_t text_space_zero : 1;
+    uint32_t text_decor_none : 1;
+    uint32_t text_font_normal : 1;
 } lv_style_list_t;
 
 /**********************
@@ -541,6 +565,19 @@ lv_res_t _lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop
  */
 lv_res_t _lv_style_list_get_ptr(lv_style_list_t * list, lv_style_property_t prop, const void ** res);
 
+/**
+ * Check whether a style is valid (initialized correctly)
+ * @param style pointer to a style
+ * @return true: valid
+ */
+bool lv_debug_check_style(const lv_style_t * style);
+
+/**
+ * Check whether a style list is valid (initialized correctly)
+ * @param style pointer to a style
+ * @return true: valid
+ */
+bool lv_debug_check_style_list(const lv_style_list_t * list);
 
 /*************************
  *    GLOBAL VARIABLES
@@ -559,9 +596,37 @@ lv_res_t _lv_style_list_get_ptr(lv_style_list_t * list, lv_style_property_t prop
  *     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);
 
 
+
+#if LV_USE_DEBUG
+
+# ifndef LV_DEBUG_IS_STYLE
+#  define LV_DEBUG_IS_STYLE(style_p) (lv_debug_check_style(style_p))
+# endif
+
+# ifndef LV_DEBUG_IS_STYLE_LIST
+#  define LV_DEBUG_IS_STYLE_LIST(list_p) (lv_debug_check_style_list(list_p))
+# endif
+
+# if LV_USE_ASSERT_STYLE
+#  ifndef LV_ASSERT_STYLE
+#   define LV_ASSERT_STYLE(style_p) LV_DEBUG_ASSERT(LV_DEBUG_IS_STYLE(style_p), "Invalid style", style_p);
+#  endif
+#  ifndef LV_ASSERT_STYLE_LIST
+#   define LV_ASSERT_STYLE_LIST(list_p) LV_DEBUG_ASSERT(LV_DEBUG_IS_STYLE_LIST(list_p), "Invalid style list", list_p);
+#  endif
+# else
+#   define LV_ASSERT_STYLE(style_p) true
+#   define LV_ASSERT_STYLE_LIST(list_p) true
+# endif
+
+#else
+# define LV_ASSERT_STYLE(p) true
+# define LV_ASSERT_STYLE_LIST(p) true
+#endif
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

src/lv_draw/lv_draw_arc.c

@@ -65,17 +65,18 @@ static void get_rounded_area(int16_t angle, lv_coord_t radius, uint8_t tickness,
  * @param mask the arc will be drawn only in this mask
  * @param start_angle the start angle of the arc (0 deg on the bottom, 90 deg on the right)
  * @param end_angle the end angle of the arc
- * @param style style of the arc (`body.thickness`, `body.main_color`, `body.opa` is used)
- * @param opa_scale scale down all opacities by the factor
+ * @param clip_area the arc will be drawn only in this area
+ * @param dsc pointer to an initialized `lv_draw_line_dsc_t` variable
  */
 void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uint16_t start_angle, uint16_t end_angle,
-                 const lv_area_t * clip_area, lv_draw_line_dsc_t * dsc)
+                 const lv_area_t * clip_area, const lv_draw_line_dsc_t * dsc)
 {
     if(dsc->opa <= LV_OPA_MIN) return;
     if(dsc->width == 0) return;
     if(start_angle == end_angle) return;
 
-    if(dsc->width > radius) dsc->width = radius;
+    lv_style_int_t width = dsc->width;
+    if(width > radius) width = radius;
 
     lv_draw_rect_dsc_t cir_dsc;
     lv_draw_rect_dsc_init(&cir_dsc);
@@ -83,7 +84,7 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
     cir_dsc.bg_opa = LV_OPA_TRANSP;
     cir_dsc.border_opa = dsc->opa;
     cir_dsc.border_color = dsc->color;
-    cir_dsc.border_width = dsc->width;
+    cir_dsc.border_width = width;
     cir_dsc.border_blend_mode = dsc->blend_mode;
 
     lv_area_t area;
@@ -123,7 +124,7 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
         q_dsc.end_angle = end_angle;
         q_dsc.start_quarter = (start_angle / 90) & 0x3;
         q_dsc.end_quarter = (end_angle / 90) & 0x3;
-        q_dsc.width = dsc->width;
+        q_dsc.width = width;
         q_dsc.draw_dsc =  &cir_dsc;
         q_dsc.draw_area = &area;
         q_dsc.clip_area = clip_area;
@@ -146,7 +147,7 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
 
         lv_area_t round_area;
         if(dsc->round_start) {
-            get_rounded_area(start_angle, radius, dsc->width, &round_area);
+            get_rounded_area(start_angle, radius, width, &round_area);
             round_area.x1 += center_x;
             round_area.x2 += center_x;
             round_area.y1 += center_y;
@@ -156,7 +157,7 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uin
         }
 
         if(dsc->round_end) {
-            get_rounded_area(end_angle, radius, dsc->width, &round_area);
+            get_rounded_area(end_angle, radius, width, &round_area);
             round_area.x1 += center_x;
             round_area.x2 += center_x;
             round_area.y1 += center_y;

src/lv_draw/lv_draw_arc.h

@@ -35,11 +35,11 @@ extern "C" {
  * @param mask the arc will be drawn only in this mask
  * @param start_angle the start angle of the arc (0 deg on the bottom, 90 deg on the right)
  * @param end_angle the end angle of the arc
- * @param style style of the arc (`body.thickness`, `body.main_color`, `body.opa` is used)
- * @param opa_scale scale down all opacities by the factor
+ * @param clip_area the arc will be drawn only in this area
+ * @param dsc pointer to an initialized `lv_draw_line_dsc_t` variable
  */
 void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius,  uint16_t start_angle, uint16_t end_angle,
-                 const lv_area_t * clip_area, lv_draw_line_dsc_t * dsc);
+                 const lv_area_t * clip_area, const lv_draw_line_dsc_t * dsc);
 
 /**********************
  *      MACROS

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
 }
 
 
@@ -267,8 +279,10 @@ static void fill_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  con
 
         for(y = draw_area->y1; y <= draw_area->y2; y++) {
             for(x = draw_area->x1; x <= draw_area->x2; 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);
+                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);
+                }
             }
             mask_tmp += draw_area_w;
         }
@@ -336,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++) {
@@ -350,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;
@@ -511,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)
@@ -602,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,
@@ -643,8 +656,10 @@ static void map_set_px(const lv_area_t * disp_area, lv_color_t * disp_buf,  cons
 
         for(y = draw_area->y1; y <= draw_area->y2; y++) {
             for(x = draw_area->x1; x <= draw_area->x2; x++) {
-                disp->driver.set_px_cb(&disp->driver, (void *)disp_buf, disp_w, x, y, map_buf_tmp[x],
-                                       (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
+                if(mask_tmp[x]) {
+                    disp->driver.set_px_cb(&disp->driver, (void *)disp_buf, disp_w, x, y, map_buf_tmp[x],
+                                           (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
+                }
             }
             mask_tmp += draw_area_w;
             map_buf_tmp += map_w;
@@ -839,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)
@@ -990,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

@@ -29,11 +29,11 @@
  **********************/
 LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * clip_area,
                                                        const void * src,
-                                                       lv_draw_img_dsc_t * draw_dsc);
+                                                       const lv_draw_img_dsc_t * draw_dsc);
 
 LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const lv_area_t * clip_area,
                                               const uint8_t * map_p,
-                                              lv_draw_img_dsc_t * draw_dsc,
+                                              const lv_draw_img_dsc_t * draw_dsc,
                                               bool chroma_key, bool alpha_byte);
 
 static void show_error(const lv_area_t * coords, const lv_area_t * clip_area, const char * msg);
@@ -65,13 +65,9 @@ void lv_draw_img_dsc_init(lv_draw_img_dsc_t * dsc)
  * @param coords the coordinates of the image
  * @param mask the image will be drawn only in this area
  * @param src pointer to a lv_color_t array which contains the pixels of the image
- * @param style style of the image
- * @param angle rotation angle of the image
- * @param center rotation center of the image
- * @param antialias anti-alias transformations (rotate, zoom) or not
- * @param opa_scale scale down all opacities by the factor
+ * @param dsc pointer to an initialized `lv_draw_img_dsc_t` variable
  */
-void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, lv_draw_img_dsc_t * dsc)
+void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, const lv_draw_img_dsc_t * dsc)
 {
     if(src == NULL) {
         LV_LOG_WARN("Image draw: src is NULL");
@@ -232,7 +228,7 @@ lv_img_src_t lv_img_src_get_type(const void * src)
 
 LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * clip_area,
                                                        const void * src,
-                                                       lv_draw_img_dsc_t * draw_dsc)
+                                                       const lv_draw_img_dsc_t * draw_dsc)
 {
     if(draw_dsc->opa <= LV_OPA_MIN) return LV_RES_OK;
 
@@ -327,18 +323,14 @@ LV_ATTRIBUTE_FAST_MEM static lv_res_t lv_img_draw_core(const lv_area_t * coords,
  * @param cords_p coordinates the color map
  * @param mask_p the map will drawn only on this area  (truncated to VDB area)
  * @param map_p pointer to a lv_color_t array
- * @param opa opacity of the map
+ * @param draw_dsc pointer to an initialized `lv_draw_img_dsc_t` variable
  * @param chroma_keyed true: enable transparency of LV_IMG_LV_COLOR_TRANSP color pixels
  * @param alpha_byte true: extra alpha byte is inserted for every pixel
- * @param style style of the image
- * @param angle angle in degree
- * @param pivot center of rotation
- * @param zoom zoom factor
- * @param antialias anti-alias transformations (rotate, zoom) or not
  */
 LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const lv_area_t * clip_area,
                                               const uint8_t * map_p,
-                                              lv_draw_img_dsc_t * draw_dsc, bool chroma_key, bool alpha_byte)
+                                              const lv_draw_img_dsc_t * draw_dsc,
+                                              bool chroma_key, bool alpha_byte)
 {
     /* Use the clip area as draw area*/
     lv_area_t draw_area;
@@ -407,7 +399,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 +411,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 +449,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;
@@ -548,7 +539,9 @@ LV_ATTRIBUTE_FAST_MEM static void lv_draw_map(const lv_area_t * map_area, const
                             mask_buf[px_i] = 0xFF;
                         }
 
-#if LV_COLOR_DEPTH == 8
+#if LV_COLOR_DEPTH == 1
+                        c.full = map_px[0];
+#elif LV_COLOR_DEPTH == 8
                         c.full =  map_px[0];
 #elif LV_COLOR_DEPTH == 16
                         c.full =  map_px[0] + (map_px[1] << 8);

src/lv_draw/lv_draw_img.h

@@ -53,13 +53,9 @@ void lv_draw_img_dsc_init(lv_draw_img_dsc_t * dsc);
  * @param coords the coordinates of the image
  * @param mask the image will be drawn only in this area
  * @param src pointer to a lv_color_t array which contains the pixels of the image
- * @param style style of the image
- * @param angle rotation angle of the image
- * @param center rotation center of the image
- * @param antialias anti-alias transformations (rotate, zoom) or not
- * @param opa_scale scale down all opacities by the factor
+ * @param dsc pointer to an initialized `lv_draw_img_dsc_t` variable
  */
-void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, lv_draw_img_dsc_t * dsc);
+void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, const lv_draw_img_dsc_t * dsc);
 
 /**
  * Get the type of an image source

src/lv_draw/lv_draw_label.c

@@ -11,7 +11,7 @@
 #include "../lv_hal/lv_hal_disp.h"
 #include "../lv_core/lv_refr.h"
 #include "../lv_misc/lv_bidi.h"
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 
 /*********************
  *      DEFINES
@@ -111,8 +111,10 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc)
  * @param hint pointer to a `lv_draw_label_hint_t` variable.
  * It is managed by the drawer to speed up the drawing of very long texts (thousands of lines).
  */
-LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, lv_draw_label_dsc_t * dsc,
-                                         const char * txt, lv_draw_label_hint_t * hint)
+LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask,
+                                         const lv_draw_label_dsc_t * dsc,
+                                         const char * txt,
+                                         lv_draw_label_hint_t * hint)
 {
 
     if(dsc->opa <= LV_OPA_MIN) return;
@@ -206,26 +208,26 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
 
     lv_opa_t opa = dsc->opa;
 
-    uint16_t sel_start = dsc->sel_start;
-    uint16_t sel_end = dsc->sel_end;
+    uint32_t sel_start = dsc->sel_start;
+    uint32_t sel_end = dsc->sel_end;
     if(sel_start > sel_end) {
-        uint16_t tmp = sel_start;
+        uint32_t tmp = sel_start;
         sel_start = sel_end;
         sel_end = tmp;
     }
-
     lv_draw_line_dsc_t line_dsc;
+
     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 ? font->underline_thickness : LV_MATH_MAX(font->line_height / 10, 1);
         line_dsc.opa = dsc->opa;
         line_dsc.blend_mode = dsc->blend_mode;
     }
 
     cmd_state_t cmd_state = CMD_STATE_WAIT;
     uint32_t i;
-    uint16_t par_start = 0;
+    uint32_t par_start = 0;
     lv_color_t recolor;
     int32_t letter_w;
 
@@ -250,11 +252,11 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area
 #endif
 
         while(i < line_end - line_start) {
-            uint16_t logical_char_pos = 0;
+            uint32_t logical_char_pos = 0;
             if(sel_start != 0xFFFF && sel_end != 0xFFFF) {
 #if LV_USE_BIDI
                 logical_char_pos = _lv_txt_encoded_get_char_id(txt, line_start);
-                uint16_t t = _lv_txt_encoded_get_char_id(bidi_txt, i);
+                uint32_t t = _lv_txt_encoded_get_char_id(bidi_txt, i);
                 logical_char_pos += _lv_bidi_get_logical_pos(bidi_txt, NULL, line_end - line_start, dsc->bidi_dir, t, NULL);
 #else
                 logical_char_pos = _lv_txt_encoded_get_char_id(txt, line_start + i);
@@ -342,7 +344,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 +422,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 +609,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 +761,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 +809,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_label.h

@@ -33,8 +33,8 @@ typedef struct {
     lv_opa_t opa;
     lv_style_int_t line_space;
     lv_style_int_t letter_space;
-    uint16_t sel_start;
-    uint16_t sel_end;
+    uint32_t sel_start;
+    uint32_t sel_end;
     lv_coord_t ofs_x;
     lv_coord_t ofs_y;
     lv_bidi_dir_t bidi_dir;
@@ -77,7 +77,8 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc);
  * @param hint pointer to a `lv_draw_label_hint_t` variable.
  * It is managed by the drawer to speed up the drawing of very long texts (thousands of lines).
  */
-LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, lv_draw_label_dsc_t * dsc,
+LV_ATTRIBUTE_FAST_MEM void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask,
+                                         const lv_draw_label_dsc_t * dsc,
                                          const char * txt, lv_draw_label_hint_t * hint);
 
 //! @endcond

src/lv_draw/lv_draw_line.c

@@ -26,13 +26,13 @@
  **********************/
 LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(const lv_point_t * point1, const lv_point_t * point2,
                                                  const lv_area_t * clip,
-                                                 lv_draw_line_dsc_t * dsc);
+                                                 const lv_draw_line_dsc_t * dsc);
 LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const lv_point_t * point2,
                                                 const lv_area_t * clip,
-                                                lv_draw_line_dsc_t * dsc);
+                                                const lv_draw_line_dsc_t * dsc);
 LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const lv_point_t * point2,
                                                 const lv_area_t * clip,
-                                                lv_draw_line_dsc_t * dsc);
+                                                const lv_draw_line_dsc_t * dsc);
 
 /**********************
  *  STATIC VARIABLES
@@ -58,12 +58,11 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc)
  * Draw a line
  * @param point1 first point of the line
  * @param point2 second point of the line
- * @param mask the line will be drawn only on this area
- * @param style pointer to a line's style
- * @param opa_scale scale down all opacities by the factor
+ * @param clip the line will be drawn only in this area
+ * @param dsc pointer to an initialized `lv_draw_line_dsc_t` variable
  */
 LV_ATTRIBUTE_FAST_MEM void lv_draw_line(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * clip,
-                                        lv_draw_line_dsc_t * dsc)
+                                        const lv_draw_line_dsc_t * dsc)
 {
     if(dsc->width == 0) return;
     if(dsc->opa <= LV_OPA_MIN) return;
@@ -120,7 +119,7 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_line(const lv_point_t * point1, const lv_poin
 
 LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const lv_point_t * point2,
                                                 const lv_area_t * clip,
-                                                lv_draw_line_dsc_t * dsc)
+                                                const lv_draw_line_dsc_t * dsc)
 {
     lv_opa_t opa = dsc->opa;
 
@@ -221,7 +220,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_hor(const lv_point_t * point1, const
 
 LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const lv_point_t * point2,
                                                 const lv_area_t * clip,
-                                                lv_draw_line_dsc_t * dsc)
+                                                const lv_draw_line_dsc_t * dsc)
 {
     lv_opa_t opa = dsc->opa;
 
@@ -316,7 +315,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_line_ver(const lv_point_t * point1, const
 
 LV_ATTRIBUTE_FAST_MEM static void draw_line_skew(const lv_point_t * point1, const lv_point_t * point2,
                                                  const lv_area_t * clip,
-                                                 lv_draw_line_dsc_t * dsc)
+                                                 const lv_draw_line_dsc_t * dsc)
 {
     /*Keep the great y in p1*/
     lv_point_t p1;

src/lv_draw/lv_draw_line.h

@@ -43,12 +43,11 @@ typedef struct {
  * Draw a line
  * @param point1 first point of the line
  * @param point2 second point of the line
- * @param mask the line will be drawn only on this area
- * @param style pointer to a line's style
- * @param opa_scale scale down all opacities by the factor
+ * @param clip the line will be drawn only in this area
+ * @param dsc pointer to an initialized `lv_draw_line_dsc_t` variable
  */
-LV_ATTRIBUTE_FAST_MEM void lv_draw_line(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * mask,
-                                        lv_draw_line_dsc_t * dsc);
+LV_ATTRIBUTE_FAST_MEM void lv_draw_line(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * clip,
+                                        const lv_draw_line_dsc_t * dsc);
 
 LV_ATTRIBUTE_FAST_MEM void lv_draw_line_dsc_init(lv_draw_line_dsc_t * dsc);
 

src/lv_draw/lv_draw_mask.c

@@ -13,7 +13,7 @@
 #include "lv_draw_mask.h"
 #include "../lv_misc/lv_math.h"
 #include "../lv_misc/lv_log.h"
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_misc/lv_gc.h"
 
 #if defined(LV_GC_INCLUDE)
@@ -95,12 +95,12 @@ int16_t lv_draw_mask_add(void * param, void * custom_id)
 }
 
 /**
- * Apply the added buffers on a line. Used internally by the library's drawing routins.
+ * Apply the added buffers on a line. Used internally by the library's drawing routines.
  * @param mask_buf store the result mask here. Has to be `len` byte long. Should be initialized with `0xFF`.
  * @param abs_x absolute X coordinate where the line to calculate start
  * @param abs_y absolute Y coordinate where the line to calculate start
  * @param len length of the line to calculate (in pixel count)
- * @return Oneof these values:
+ * @return One of these values:
  * - `LV_DRAW_MASK_RES_FULL_TRANSP`: the whole line is transparent. `mask_buf` is not set to zero
  * - `LV_DRAW_MASK_RES_FULL_COVER`: the whole line is fully visible. `mask_buf` is unchanged
  * - `LV_DRAW_MASK_RES_CHANGED`: `mask_buf` has changed, it shows the desired opacity of each pixel in the given line
@@ -272,8 +272,8 @@ void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t
 /**
  *Initialize a line mask from a point and an angle.
  * @param param pointer to a `lv_draw_mask_param_t` to initialize
- * @param px X coordiante of a point of the line
- * @param py X coordiante of a point of the line
+ * @param px X coordinate of a point of the line
+ * @param py X coordinate of a point of the line
  * @param angle right 0 deg, bottom: 90
  * @param side and element of `lv_draw_mask_line_side_t` to describe which side to keep.
  * With `LV_DRAW_MASK_LINE_SIDE_LEFT/RIGHT` and horizontal line all pixels are kept
@@ -370,7 +370,7 @@ void lv_draw_mask_angle_init(lv_draw_mask_angle_param_t * param, lv_coord_t vert
  * @param param param pointer to a `lv_draw_mask_param_t` to initialize
  * @param rect coordinates of the rectangle to affect (absolute coordinates)
  * @param radius radius of the rectangle
- * @param inv: true: keep the pixels inside teh rectangle; keep teh pixels outside of the rectangle
+ * @param inv: true: keep the pixels inside the rectangle; keep the pixels outside of the rectangle
  */
 void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area_t * rect, lv_coord_t radius, bool inv)
 {

src/lv_draw/lv_draw_mask.h

@@ -190,7 +190,7 @@ int16_t lv_draw_mask_add(void * param, void * custom_id);
  * @param abs_x absolute X coordinate where the line to calculate start
  * @param abs_y absolute Y coordinate where the line to calculate start
  * @param len length of the line to calculate (in pixel count)
- * @return Oneof these values:
+ * @return One of these values:
  * - `LV_DRAW_MASK_RES_FULL_TRANSP`: the whole line is transparent. `mask_buf` is not set to zero
  * - `LV_DRAW_MASK_RES_FULL_COVER`: the whole line is fully visible. `mask_buf` is unchanged
  * - `LV_DRAW_MASK_RES_CHANGED`: `mask_buf` has changed, it shows the desired opacity of each pixel in the given line
@@ -245,8 +245,8 @@ void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t
 /**
  *Initialize a line mask from a point and an angle.
  * @param param pointer to a `lv_draw_mask_param_t` to initialize
- * @param px X coordiante of a point of the line
- * @param py X coordiante of a point of the line
+ * @param px X coordinate of a point of the line
+ * @param py X coordinate of a point of the line
  * @param angle right 0 deg, bottom: 90
  * @param side and element of `lv_draw_mask_line_side_t` to describe which side to keep.
  * With `LV_DRAW_MASK_LINE_SIDE_LEFT/RIGHT` and horizontal line all pixels are kept
@@ -271,7 +271,7 @@ void lv_draw_mask_angle_init(lv_draw_mask_angle_param_t * param, lv_coord_t vert
  * @param param param pointer to a `lv_draw_mask_param_t` to initialize
  * @param rect coordinates of the rectangle to affect (absolute coordinates)
  * @param radius radius of the rectangle
- * @param inv: true: keep the pixels inside teh rectangle; keep teh pixels outside of the rectangle
+ * @param inv: true: keep the pixels inside the rectangle; keep the pixels outside of the rectangle
  */
 void lv_draw_mask_radius_init(lv_draw_mask_radius_param_t * param, const lv_area_t * rect, lv_coord_t radius, bool inv);
 

src/lv_draw/lv_draw_rect.c

@@ -11,7 +11,7 @@
 #include "lv_draw_mask.h"
 #include "../lv_misc/lv_math.h"
 #include "../lv_core/lv_refr.h"
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 
 /*********************
  *      DEFINES
@@ -27,20 +27,32 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-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_bg(const lv_area_t * coords, const lv_area_t * clip,
+                                          const 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);
+                                              const lv_draw_rect_dsc_t * dsc);
+
+#if LV_USE_OUTLINE
+    static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, const 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);
+                                              const lv_draw_rect_dsc_t * dsc);
 LV_ATTRIBUTE_FAST_MEM static void shadow_draw_corner_buf(const lv_area_t * coords,  uint16_t * sh_buf, lv_coord_t s,
                                                          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, const 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, const 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(const lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i);
 
 /**********************
  *  STATIC VARIABLES
@@ -85,9 +97,9 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc)
  * Draw a rectangle
  * @param coords the coordinates of the rectangle
  * @param mask the rectangle will be drawn only in this mask
- * @param style pointer to a style
+ * @param dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
-void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc)
+void lv_draw_rect(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
 {
     if(lv_area_get_height(coords) < 1 || lv_area_get_width(coords) < 1) return;
 #if LV_USE_SHADOW
@@ -95,10 +107,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();
 }
@@ -142,7 +163,8 @@ void lv_draw_px(const lv_point_t * point, const lv_area_t * clip_area, const lv_
  *   STATIC FUNCTIONS
  **********************/
 
-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_bg(const lv_area_t * coords, const lv_area_t * clip,
+                                          const lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->bg_opa <= LV_OPA_MIN) return;
 
@@ -185,10 +207,13 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
     /*Create a mask if there is a radius*/
     lv_opa_t * mask_buf = _lv_mem_buf_get(draw_area_w);
 
+    lv_grad_dir_t grad_dir = dsc->bg_grad_dir;
+    if(dsc->bg_color.full == dsc->bg_grad_color.full) grad_dir = LV_GRAD_DIR_NONE;
+
     uint16_t other_mask_cnt = lv_draw_mask_get_cnt();
     bool simple_mode = true;
     if(other_mask_cnt) simple_mode = false;
-    else if(dsc->bg_grad_dir == LV_GRAD_DIR_HOR) simple_mode = false;
+    else if(grad_dir == LV_GRAD_DIR_HOR) simple_mode = false;
 
     int16_t mask_rout_id = LV_MASK_ID_INV;
 
@@ -201,7 +226,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
     if(rout > short_side >> 1) rout = short_side >> 1;
 
     /*Most simple case: just a plain rectangle*/
-    if(simple_mode && rout == 0 && (dsc->bg_grad_dir == LV_GRAD_DIR_NONE)) {
+    if(simple_mode && rout == 0 && (grad_dir == LV_GRAD_DIR_NONE)) {
         _lv_blend_fill(clip, &coords_bg,
                        dsc->bg_color, NULL, LV_DRAW_MASK_RES_FULL_COVER, opa,
                        dsc->bg_blend_mode);
@@ -222,7 +247,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
 
         lv_color_t * grad_map = NULL;
         /*In case of horizontal gradient pre-compute a line with a gradient*/
-        if(dsc->bg_grad_dir == LV_GRAD_DIR_HOR && dsc->bg_color.full != dsc->bg_grad_color.full) {
+        if(grad_dir == LV_GRAD_DIR_HOR) {
             grad_map = _lv_mem_buf_get(coords_w * sizeof(lv_color_t));
 
             int32_t i;
@@ -267,12 +292,12 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
             }
 
             /*Get the current line color*/
-            if(dsc->bg_grad_dir == LV_GRAD_DIR_VER && dsc->bg_color.full != dsc->bg_grad_color.full) {
+            if(grad_dir == LV_GRAD_DIR_VER) {
                 grad_color = grad_get(dsc, lv_area_get_height(&coords_bg), y - coords_bg.y1);
             }
 
             /* If there is not other mask and drawing the corner area split the drawing to corner and middle areas
-             * because it the middle mask shuldn't be taken into account (therefore its faster)*/
+             * because it the middle mask shouldn't be taken into account (therefore its faster)*/
             if(simple_mode && split &&
                (y < coords_bg.y1 + rout + 1 ||
                 y > coords_bg.y2 - rout - 1)) {
@@ -288,7 +313,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
                                grad_color, mask_buf, mask_res, opa2, dsc->bg_blend_mode);
 
                 /*Center part*/
-                if(dsc->bg_grad_dir == LV_GRAD_DIR_VER) {
+                if(grad_dir == LV_GRAD_DIR_VER) {
                     fill_area2.x1 = coords_bg.x1 + rout;
                     fill_area2.x2 = coords_bg.x2 - rout;
                     _lv_blend_fill(clip, &fill_area2,
@@ -307,10 +332,10 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
 
             }
             else {
-                if(dsc->bg_grad_dir == LV_GRAD_DIR_HOR) {
+                if(grad_dir == LV_GRAD_DIR_HOR) {
                     _lv_blend_map(clip, &fill_area, grad_map, mask_buf, mask_res, opa2, dsc->bg_blend_mode);
                 }
-                else if(dsc->bg_grad_dir == LV_GRAD_DIR_VER) {
+                else if(grad_dir == LV_GRAD_DIR_VER) {
                     _lv_blend_fill(clip, &fill_area,
                                    grad_color, mask_buf, mask_res, opa2, dsc->bg_blend_mode);
                 }
@@ -323,7 +348,7 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
             fill_area.y2++;
         }
 
-        if(dsc->bg_grad_dir == LV_GRAD_DIR_NONE && other_mask_cnt == 0 && split) {
+        if(grad_dir == LV_GRAD_DIR_NONE && other_mask_cnt == 0 && split) {
             /*Central part*/
             fill_area.x1 = coords_bg.x1 + rout;
             fill_area.x2 = coords_bg.x2 - rout;
@@ -361,46 +386,12 @@ LV_ATTRIBUTE_FAST_MEM static void draw_bg(const lv_area_t * coords, const lv_are
 }
 
 LV_ATTRIBUTE_FAST_MEM static void draw_border(const lv_area_t * coords, const lv_area_t * clip,
-                                              lv_draw_rect_dsc_t * dsc)
+                                              const lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->border_opa <= LV_OPA_MIN) return;
     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;
+    if(dsc->border_post) return;
 
     int32_t coords_w = lv_area_get_width(coords);
     int32_t coords_h = lv_area_get_height(coords);
@@ -410,140 +401,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;
@@ -562,19 +493,19 @@ 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)
+LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(const lv_draw_rect_dsc_t * dsc, lv_coord_t s, lv_coord_t i)
 {
     int32_t min = (dsc->bg_main_color_stop * s) >> 8;
     if(i <= min) return dsc->bg_color;
@@ -591,7 +522,7 @@ LV_ATTRIBUTE_FAST_MEM static inline lv_color_t grad_get(lv_draw_rect_dsc_t * dsc
 
 #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)
+                                              const lv_draw_rect_dsc_t * dsc)
 {
     /*Check whether the shadow is visible*/
     if(dsc->shadow_width == 0) return;
@@ -1044,7 +975,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++;
         }
@@ -1108,7 +1039,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);
@@ -1137,7 +1068,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];
@@ -1219,7 +1150,8 @@ LV_ATTRIBUTE_FAST_MEM static void shadow_blur_corner(lv_coord_t size, lv_coord_t
 
 #endif
 
-static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, lv_draw_rect_dsc_t * dsc)
+#if LV_USE_OUTLINE
+static void draw_outline(const lv_area_t * coords, const lv_area_t * clip, const lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->outline_opa <= LV_OPA_MIN) return;
     if(dsc->outline_width == 0) return;
@@ -1228,10 +1160,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);
@@ -1240,16 +1168,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);
 
@@ -1258,166 +1176,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
 
-static void draw_pattern(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, const lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->pattern_image == NULL) return;
     if(dsc->pattern_opa <= LV_OPA_MIN) return;
@@ -1517,9 +1282,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, const lv_draw_rect_dsc_t * dsc)
 {
     if(dsc->value_str == NULL) return;
     if(dsc->value_opa <= LV_OPA_MIN) return;
@@ -1552,4 +1319,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_draw_rect.h

@@ -41,6 +41,7 @@ typedef struct {
     lv_style_int_t border_side;
     lv_opa_t border_opa;
     lv_blend_mode_t border_blend_mode;
+    uint8_t border_post : 1;        /*There is a border it will be drawn later. */
 
     /*Outline*/
     lv_color_t outline_color;
@@ -92,9 +93,9 @@ LV_ATTRIBUTE_FAST_MEM void lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc);
  * Draw a rectangle
  * @param coords the coordinates of the rectangle
  * @param mask the rectangle will be drawn only in this mask
- * @param style pointer to a style
+ * @param dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
-void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, lv_draw_rect_dsc_t * dsc);
+void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, const lv_draw_rect_dsc_t * dsc);
 
 /**
  * Draw a pixel

src/lv_draw/lv_draw_triangle.c

@@ -40,7 +40,7 @@
  * @param clip_area the triangle will be drawn only in this area
  * @param draw_dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
-void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip_area, lv_draw_rect_dsc_t * draw_dsc)
+void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip_area, const lv_draw_rect_dsc_t * draw_dsc)
 {
     lv_draw_polygon(points, 3, clip_area, draw_dsc);
 }
@@ -53,7 +53,7 @@ void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip_area, lv
  * @param draw_dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
 void lv_draw_polygon(const lv_point_t points[], uint16_t point_cnt, const lv_area_t * clip_area,
-                     lv_draw_rect_dsc_t * draw_dsc)
+                     const lv_draw_rect_dsc_t * draw_dsc)
 {
     if(point_cnt < 3) return;
     if(points == NULL) return;

src/lv_draw/lv_draw_triangle.h

@@ -33,7 +33,7 @@ extern "C" {
  * @param clip_area the triangle will be drawn only in this area
  * @param draw_dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
-void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip, lv_draw_rect_dsc_t * draw_dsc);
+void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip, const lv_draw_rect_dsc_t * draw_dsc);
 
 /**
  * Draw a polygon. Only convex polygons are supported.
@@ -43,7 +43,7 @@ void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip, lv_draw
  * @param draw_dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
 void lv_draw_polygon(const lv_point_t points[], uint16_t point_cnt, const lv_area_t * mask,
-                     lv_draw_rect_dsc_t * draw_dsc);
+                     const lv_draw_rect_dsc_t * draw_dsc);
 
 /**********************
  *      MACROS

src/lv_draw/lv_img_buf.c

@@ -60,7 +60,7 @@ lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t
         uint32_t px     = dsc->header.w * y * px_size + x * px_size;
         _lv_memcpy_small(&p_color, &buf_u8[px], sizeof(lv_color_t));
 #if LV_COLOR_SIZE == 32
-        p_color.ch.alpha = 0xFF; /*Only the color should be get so use a deafult alpha value*/
+        p_color.ch.alpha = 0xFF; /*Only the color should be get so use a default alpha value*/
 #endif
     }
     else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) {
@@ -414,7 +414,7 @@ uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
 
 #if LV_USE_IMG_TRANSFORM
 /**
- * Initialize a descriptor to tranform an image
+ * Initialize a descriptor to transform an image
  * @param dsc pointer to an `lv_img_transform_dsc_t` variable whose `cfg` field is initialized
  */
 void _lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc)
@@ -435,6 +435,10 @@ void _lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc)
     dsc->tmp.sinma = (s1 * (10 - angle_rem) + s2 * angle_rem) / 10;
     dsc->tmp.cosma = (c1 * (10 - angle_rem) + c2 * angle_rem) / 10;
 
+    /*Use smaller value to avoid overflow*/
+    dsc->tmp.sinma = dsc->tmp.sinma >> (LV_TRIGO_SHIFT - _LV_TRANSFORM_TRIGO_SHIFT);
+    dsc->tmp.cosma = dsc->tmp.cosma >> (LV_TRIGO_SHIFT - _LV_TRANSFORM_TRIGO_SHIFT);
+
     dsc->tmp.chroma_keyed = lv_img_cf_is_chroma_keyed(dsc->cfg.cf) ? 1 : 0;
     dsc->tmp.has_alpha = lv_img_cf_has_alpha(dsc->cfg.cf) ? 1 : 0;
     if(dsc->cfg.cf == LV_IMG_CF_TRUE_COLOR || dsc->cfg.cf == LV_IMG_CF_TRUE_COLOR_ALPHA ||
@@ -451,7 +455,9 @@ void _lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc)
     dsc->tmp.img_dsc.header.w = dsc->cfg.src_w;
     dsc->tmp.img_dsc.header.h = dsc->cfg.src_h;
 
-    dsc->tmp.zoom_inv = (256 * 256) / dsc->cfg.zoom;
+    /* The inverse of the zoom will be sued during the transformation
+     *  + dsc->cfg.zoom / 2 for rounding*/
+    dsc->tmp.zoom_inv = (((256 * 256) << _LV_ZOOM_INV_UPSCALE) + dsc->cfg.zoom / 2) / dsc->cfg.zoom;
 
     dsc->res.opa = LV_OPA_COVER;
     dsc->res.color = dsc->cfg.color;
@@ -468,9 +474,31 @@ void _lv_img_buf_transform_init(lv_img_transform_dsc_t * dsc)
  * @param pivot x,y pivot coordinates of rotation
  */
 void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h, int16_t angle, uint16_t zoom,
-                                      lv_point_t * pivot)
+                                      const 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;
+    }
+
+
+    res->x1 = (((-pivot->x) * zoom) >> 8) - 1;
+    res->y1 = (((-pivot->y) * zoom) >> 8) - 1;
+    res->x2 = (((w - pivot->x) * zoom) >> 8) + 2;
+    res->y2 = (((h - pivot->y) * zoom) >> 8) + 2;
+
+    if(angle == 0) {
+        res->x1 += pivot->x;
+        res->y1 += pivot->y;
+        res->x2 += pivot->x;
+        res->y2 += pivot->y;
+        return;
+    }
+
     int32_t angle_low = angle / 10;
     int32_t angle_hight = angle_low + 1;
     int32_t angle_rem = angle  - (angle_low * 10);
@@ -484,6 +512,10 @@ void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t
     int32_t sinma = (s1 * (10 - angle_rem) + s2 * angle_rem) / 10;
     int32_t cosma = (c1 * (10 - angle_rem) + c2 * angle_rem) / 10;
 
+    /*Use smaller value to avoid overflow*/
+    sinma = sinma >> (LV_TRIGO_SHIFT - _LV_TRANSFORM_TRIGO_SHIFT);
+    cosma = cosma >> (LV_TRIGO_SHIFT - _LV_TRANSFORM_TRIGO_SHIFT);
+
     lv_point_t lt;
     lv_point_t rt;
     lv_point_t lb;
@@ -492,31 +524,25 @@ void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t
     lv_coord_t xt;
     lv_coord_t yt;
 
-    lv_area_t a;
-    a.x1 = ((-pivot->x) * zoom) >> 8;
-    a.y1 = ((-pivot->y) * zoom) >> 8;
-    a.x2 = ((w - pivot->x) * zoom) >> 8;
-    a.y2 = ((h - pivot->y) * zoom) >> 8;
+    xt = res->x1;
+    yt = res->y1;
+    lt.x = ((cosma * xt - sinma * yt) >> _LV_TRANSFORM_TRIGO_SHIFT) + pivot->x;
+    lt.y = ((sinma * xt + cosma * yt) >> _LV_TRANSFORM_TRIGO_SHIFT) + pivot->y;
 
-    xt = a.x1;
-    yt = a.y1;
-    lt.x = ((cosma * xt - sinma * yt) >> LV_TRIGO_SHIFT) + pivot->x;
-    lt.y = ((sinma * xt + cosma * yt) >> LV_TRIGO_SHIFT) + pivot->y;
+    xt = res->x2;
+    yt = res->y1;
+    rt.x = ((cosma * xt - sinma * yt) >> _LV_TRANSFORM_TRIGO_SHIFT) + pivot->x;
+    rt.y = ((sinma * xt + cosma * yt) >> _LV_TRANSFORM_TRIGO_SHIFT) + pivot->y;
 
-    xt = a.x2;
-    yt = a.y1;
-    rt.x = ((cosma * xt - sinma * yt) >> LV_TRIGO_SHIFT) + pivot->x;
-    rt.y = ((sinma * xt + cosma * yt) >> LV_TRIGO_SHIFT) + pivot->y;
+    xt = res->x1;
+    yt = res->y2;
+    lb.x = ((cosma * xt - sinma * yt) >> _LV_TRANSFORM_TRIGO_SHIFT) + pivot->x;
+    lb.y = ((sinma * xt + cosma * yt) >> _LV_TRANSFORM_TRIGO_SHIFT) + pivot->y;
 
-    xt = a.x1;
-    yt = a.y2;
-    lb.x = ((cosma * xt - sinma * yt) >> LV_TRIGO_SHIFT) + pivot->x;
-    lb.y = ((sinma * xt + cosma * yt) >> LV_TRIGO_SHIFT) + pivot->y;
-
-    xt = a.x2;
-    yt = a.y2;
-    rb.x = ((cosma * xt - sinma * yt) >> LV_TRIGO_SHIFT) + pivot->x;
-    rb.y = ((sinma * xt + cosma * yt) >> LV_TRIGO_SHIFT) + pivot->y;
+    xt = res->x2;
+    yt = res->y2;
+    rb.x = ((cosma * xt - sinma * yt) >> _LV_TRANSFORM_TRIGO_SHIFT) + pivot->x;
+    rb.y = ((sinma * xt + cosma * yt) >> _LV_TRANSFORM_TRIGO_SHIFT) + pivot->y;
 
     res->x1 = LV_MATH_MIN4(lb.x, lt.x, rb.x, rt.x);
     res->x2 = LV_MATH_MAX4(lb.x, lt.x, rb.x, rt.x);
@@ -528,8 +554,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
 }
 
@@ -545,7 +571,7 @@ bool _lv_img_buf_transform_anti_alias(lv_img_transform_dsc_t * dsc)
     /*Get the fractional part of the source pixel*/
     int xs_fract = dsc->tmp.xs & 0xff;
     int ys_fract = dsc->tmp.ys & 0xff;
-    int32_t xn;      /*x neightboor*/
+    int32_t xn;      /*x neighbor*/
     lv_opa_t xr; /*x mix ratio*/
 
     if(xs_fract < 0x70) {
@@ -563,7 +589,7 @@ bool _lv_img_buf_transform_anti_alias(lv_img_transform_dsc_t * dsc)
         xr = 0xFF;
     }
 
-    int32_t yn;      /*x neightboor*/
+    int32_t yn;      /*x neighbor*/
     lv_opa_t yr; /*x mix ratio*/
 
     if(ys_fract < 0x70) {

src/lv_draw/lv_img_buf.h

@@ -48,6 +48,9 @@ extern "C" {
 
 #define LV_IMG_ZOOM_NONE   256
 
+#define _LV_TRANSFORM_TRIGO_SHIFT 10
+#define _LV_ZOOM_INV_UPSCALE 5
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -102,10 +105,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 +134,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*/
@@ -156,7 +175,7 @@ typedef struct {
         uint8_t has_alpha : 1;
         uint8_t native_color : 1;
 
-        uint16_t zoom_inv;
+        uint32_t zoom_inv;
 
         /*Runtime data*/
         lv_coord_t xs;
@@ -285,20 +304,20 @@ static inline bool _lv_img_buf_transform(lv_img_transform_dsc_t * dsc, lv_coord_
     int32_t ys;
     if(dsc->cfg.zoom == LV_IMG_ZOOM_NONE) {
         /*Get the source pixel from the upscaled image*/
-        xs = ((dsc->tmp.cosma * xt - dsc->tmp.sinma * yt) >> (LV_TRIGO_SHIFT - 8)) + dsc->tmp.pivot_x_256;
-        ys = ((dsc->tmp.sinma * xt + dsc->tmp.cosma * yt) >> (LV_TRIGO_SHIFT - 8)) + dsc->tmp.pivot_y_256;
+        xs = ((dsc->tmp.cosma * xt - dsc->tmp.sinma * yt) >> (_LV_TRANSFORM_TRIGO_SHIFT - 8)) + dsc->tmp.pivot_x_256;
+        ys = ((dsc->tmp.sinma * xt + dsc->tmp.cosma * yt) >> (_LV_TRANSFORM_TRIGO_SHIFT - 8)) + dsc->tmp.pivot_y_256;
     }
     else if(dsc->cfg.angle == 0) {
-        xt *= dsc->tmp.zoom_inv;
-        yt *= dsc->tmp.zoom_inv;
+        xt = (int32_t)((int32_t)xt * dsc->tmp.zoom_inv) >> _LV_ZOOM_INV_UPSCALE;
+        yt = (int32_t)((int32_t)yt * dsc->tmp.zoom_inv) >> _LV_ZOOM_INV_UPSCALE;
         xs = xt + dsc->tmp.pivot_x_256;
         ys = yt + dsc->tmp.pivot_y_256;
     }
     else {
-        xt *= dsc->tmp.zoom_inv;
-        yt *= dsc->tmp.zoom_inv;
-        xs = ((dsc->tmp.cosma * xt - dsc->tmp.sinma * yt) >> (LV_TRIGO_SHIFT)) + dsc->tmp.pivot_x_256;
-        ys = ((dsc->tmp.sinma * xt + dsc->tmp.cosma * yt) >> (LV_TRIGO_SHIFT)) + dsc->tmp.pivot_y_256;
+        xt = (int32_t)((int32_t)xt * dsc->tmp.zoom_inv) >> _LV_ZOOM_INV_UPSCALE;
+        yt = (int32_t)((int32_t)yt * dsc->tmp.zoom_inv) >> _LV_ZOOM_INV_UPSCALE;
+        xs = ((dsc->tmp.cosma * xt - dsc->tmp.sinma * yt) >> (_LV_TRANSFORM_TRIGO_SHIFT)) + dsc->tmp.pivot_x_256;
+        ys = ((dsc->tmp.sinma * xt + dsc->tmp.cosma * yt) >> (_LV_TRANSFORM_TRIGO_SHIFT)) + dsc->tmp.pivot_y_256;
     }
 
     /*Get the integer part of the source pixel*/
@@ -364,7 +383,7 @@ static inline bool _lv_img_buf_transform(lv_img_transform_dsc_t * dsc, lv_coord_
  * @param pivot x,y pivot coordinates of rotation
  */
 void _lv_img_buf_get_transformed_area(lv_area_t * res, lv_coord_t w, lv_coord_t h, int16_t angle, uint16_t zoom,
-                                      lv_point_t * pivot);
+                                      const lv_point_t * pivot);
 
 /**********************
  *      MACROS

src/lv_draw/lv_img_cache.c

@@ -6,7 +6,7 @@
 /*********************
  *      INCLUDES
  *********************/
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "lv_img_cache.h"
 #include "lv_img_decoder.h"
 #include "lv_draw_img.h"
@@ -59,7 +59,7 @@ static uint16_t entry_cnt;
  * The image will be left open meaning if the image decoder open callback allocated memory then it will remain.
  * The image is closed if a new image is opened and the new image takes its place in the cache.
  * @param src source of the image. Path to file or pointer to an `lv_img_dsc_t` variable
- * @param style style of the image
+ * @param color color The color of the image with `LV_IMG_CF_ALPHA_...`
  * @return pointer to the cache entry or NULL if can open the image
  */
 lv_img_cache_entry_t * _lv_img_cache_open(const void * src, lv_color_t color)

src/lv_draw/lv_img_cache.h

@@ -46,7 +46,7 @@ typedef struct {
  * The image will be left open meaning if the image decoder open callback allocated memory then it will remain.
  * The image is closed if a new image is opened and the new image takes its place in the cache.
  * @param src source of the image. Path to file or pointer to an `lv_img_dsc_t` variable
- * @param style style of the image
+ * @param color The color of the image with `LV_IMG_CF_ALPHA_...`
  * @return pointer to the cache entry or NULL if can open the image
  */
 lv_img_cache_entry_t * _lv_img_cache_open(const void * src, lv_color_t color);

src/lv_draw/lv_img_decoder.c

@@ -7,7 +7,7 @@
  *      INCLUDES
  *********************/
 #include "lv_img_decoder.h"
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_draw/lv_draw_img.h"
 #include "../lv_misc/lv_ll.h"
 #include "../lv_misc/lv_color.h"
@@ -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;
@@ -111,7 +114,7 @@ lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
  *  1) File name: E.g. "S:folder/img1.png" (The drivers needs to registered via `lv_fs_add_drv()`)
  *  2) Variable: Pointer to an `lv_img_dsc_t` variable
  *  3) Symbol: E.g. `LV_SYMBOL_OK`
- * @param style the style of the image
+ * @param color The color of the image with `LV_IMG_CF_ALPHA_...`
  * @return LV_RES_OK: opened the image. `dsc->img_data` and `dsc->header` are set.
  *         LV_RES_INV: none of the registered image decoders were able to open the image.
  */
@@ -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;
 }
 
@@ -560,7 +559,7 @@ static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * d
     }
     uint32_t btr = len * (px_size >> 3);
     uint32_t br  = 0;
-    lv_fs_read(user_data->f, buf, btr, &br);
+    res = lv_fs_read(user_data->f, buf, btr, &br);
     if(res != LV_FS_RES_OK || btr != br) {
         LV_LOG_WARN("Built-in image decoder read failed");
         return LV_RES_INV;

src/lv_draw/lv_img_decoder.h

@@ -157,7 +157,7 @@ lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header);
  *  1) File name: E.g. "S:folder/img1.png" (The drivers needs to registered via `lv_fs_add_drv()`)
  *  2) Variable: Pointer to an `lv_img_dsc_t` variable
  *  3) Symbol: E.g. `LV_SYMBOL_OK`
- * @param style the style of the image
+ * @param color The color of the image with `LV_IMG_CF_ALPHA_...`
  * @return LV_RES_OK: opened the image. `dsc->img_data` and `dsc->header` are set.
  *         LV_RES_INV: none of the registered image decoders were able to open the image.
  */

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

@@ -1,5 +1,6 @@
 CSRCS += lv_font.c
 CSRCS += lv_font_fmt_txt.c
+CSRCS += lv_font_loader.c
 CSRCS += lv_font_montserrat_12.c
 CSRCS += lv_font_montserrat_14.c
 CSRCS += lv_font_montserrat_16.c

src/lv_font/lv_font_fmt_txt.c

@@ -8,7 +8,7 @@
  *********************/
 #include "lv_font.h"
 #include "lv_font_fmt_txt.h"
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_draw/lv_draw.h"
 #include "../lv_misc/lv_types.h"
 #include "../lv_misc/lv_log.h"
@@ -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;
+            }
         }
     }
 
@@ -384,7 +407,7 @@ static inline void decompress_line(uint8_t * out, lv_coord_t w)
 /**
  * Read bits from an input buffer. The read can cross byte boundary.
  * @param in the input buffer to read from.
- * @param bit_pos index of teh first bit to read.
+ * @param bit_pos index of the first bit to read.
  * @param len number of bits to read (must be <= 8).
  * @return the read bits
  */

src/lv_font/lv_font_fmt_txt.h

@@ -135,7 +135,7 @@ typedef struct {
           2  Get the class of the left and right glyphs as `left_class` and `right_class`
               left_class = left_class_mapping[glyph_id_left];
               right_class = right_class_mapping[glyph_id_right];
-          3. value = class_pair_values[(left_class-1)*right_class_cnt + (righ_class-1)]
+          3. value = class_pair_values[(left_class-1)*right_class_cnt + (right_class-1)]
         */
 
     const int8_t * class_pair_values;    /*left_class_num * right_class_num value*/
@@ -150,12 +150,13 @@ 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;
 
 
 /*Describe store additional data for fonts */
 typedef struct {
-    /*The bitmaps os all glyphs*/
+    /*The bitmaps of all glyphs*/
     const uint8_t * glyph_bitmap;
 
     /*Describe the glyphs*/

src/lv_font/lv_font_loader.c

@@ -0,0 +1,694 @@
+/**
+ * @file lv_font_loader.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "../lvgl.h"
+#include "../lv_misc/lv_fs.h"
+#include "lv_font_loader.h"
+
+#if LV_USE_FILESYSTEM
+
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+typedef struct {
+    lv_fs_file_t * fp;
+    int8_t bit_pos;
+    uint8_t byte_value;
+} bit_iterator_t;
+
+typedef struct font_header_bin {
+    uint32_t version;
+    uint16_t tables_count;
+    uint16_t font_size;
+    uint16_t ascent;
+    int16_t descent;
+    uint16_t typo_ascent;
+    int16_t typo_descent;
+    uint16_t typo_line_gap;
+    int16_t min_y;
+    int16_t max_y;
+    uint16_t default_advance_width;
+    uint16_t kerning_scale;
+    uint8_t index_to_loc_format;
+    uint8_t glyph_id_format;
+    uint8_t advance_width_format;
+    uint8_t bits_per_pixel;
+    uint8_t xy_bits;
+    uint8_t wh_bits;
+    uint8_t advance_width_bits;
+    uint8_t compression_id;
+    uint8_t subpixels_mode;
+    uint8_t padding;
+} font_header_bin_t;
+
+typedef struct cmap_table_bin {
+    uint32_t data_offset;
+    uint32_t range_start;
+    uint16_t range_length;
+    uint16_t glyph_id_start;
+    uint16_t data_entries_count;
+    uint8_t format_type;
+    uint8_t padding;
+} cmap_table_bin_t;
+
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static bit_iterator_t init_bit_iterator(lv_fs_file_t * fp);
+static bool lvgl_load_font(lv_fs_file_t * fp, lv_font_t * font);
+int32_t load_kern(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, uint8_t format, uint32_t start);
+
+static int read_bits_signed(bit_iterator_t * it, int n_bits, lv_fs_res_t * res);
+static int read_bits(bit_iterator_t * it, int n_bits, lv_fs_res_t * res);
+
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+/**
+ * Loads a `lv_font_t` object from a binary font file
+ * @param font_name filename where the font file is located
+ * @return a pointer to the font or NULL in case of error
+ */
+lv_font_t * lv_font_load(const char * font_name)
+{
+    bool success = false;
+
+    lv_font_t * font = lv_mem_alloc(sizeof(lv_font_t));
+    memset(font, 0, sizeof(lv_font_t));
+
+    lv_fs_file_t file;
+    lv_fs_res_t res = lv_fs_open(&file, font_name, LV_FS_MODE_RD);
+
+    if(res == LV_FS_RES_OK) {
+        success = lvgl_load_font(&file, font);
+    }
+
+    if(!success) {
+        LV_LOG_WARN("Error loading font file: %s\n", font_name);
+        /*
+         * When `lvgl_load_font` fails it can leak some pointers.
+         * All non-null pointers can be assumed as allocated and
+         * `lv_font_free` should free them correctly.
+         */
+        lv_font_free(font);
+        font = NULL;
+    }
+
+    lv_fs_close(&file);
+
+    return font;
+}
+
+
+/**
+ * Frees the memory allocated by the `lv_font_load()` function
+ * @param font lv_font_t object created by the lv_font_load function
+ */
+void lv_font_free(lv_font_t * font)
+{
+    if(NULL != font) {
+        lv_font_fmt_txt_dsc_t * dsc = (lv_font_fmt_txt_dsc_t *) font->dsc;
+
+        if(NULL != dsc) {
+
+            if(dsc->kern_classes == 0) {
+                lv_font_fmt_txt_kern_pair_t * kern_dsc =
+                    (lv_font_fmt_txt_kern_pair_t *) dsc->kern_dsc;
+
+                if(NULL != kern_dsc) {
+                    if(kern_dsc->glyph_ids)
+                        lv_mem_free((void *) kern_dsc->glyph_ids);
+
+                    if(kern_dsc->values)
+                        lv_mem_free((void *) kern_dsc->values);
+
+                    lv_mem_free((void *) kern_dsc);
+                }
+            }
+            else {
+                lv_font_fmt_txt_kern_classes_t * kern_dsc =
+                    (lv_font_fmt_txt_kern_classes_t *) dsc->kern_dsc;
+
+                if(NULL != kern_dsc) {
+                    if(kern_dsc->class_pair_values)
+                        lv_mem_free((void *) kern_dsc->class_pair_values);
+
+                    if(kern_dsc->left_class_mapping)
+                        lv_mem_free((void *) kern_dsc->left_class_mapping);
+
+                    if(kern_dsc->right_class_mapping)
+                        lv_mem_free((void *) kern_dsc->right_class_mapping);
+
+                    lv_mem_free((void *) kern_dsc);
+                }
+            }
+
+            lv_font_fmt_txt_cmap_t * cmaps =
+                (lv_font_fmt_txt_cmap_t *) dsc->cmaps;
+
+            if(NULL != cmaps) {
+                for(int i = 0; i < dsc->cmap_num; ++i) {
+                    if(NULL != cmaps[i].glyph_id_ofs_list)
+                        lv_mem_free((void *) cmaps[i].glyph_id_ofs_list);
+                    if(NULL != cmaps[i].unicode_list)
+                        lv_mem_free((void *) cmaps[i].unicode_list);
+                }
+                lv_mem_free(cmaps);
+            }
+
+            if(NULL != dsc->glyph_bitmap) {
+                lv_mem_free((void *) dsc->glyph_bitmap);
+            }
+            if(NULL != dsc->glyph_dsc) {
+                lv_mem_free((void *) dsc->glyph_dsc);
+            }
+            lv_mem_free(dsc);
+        }
+        lv_mem_free(font);
+    }
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static bit_iterator_t init_bit_iterator(lv_fs_file_t * fp)
+{
+    bit_iterator_t it;
+    it.fp = fp;
+    it.bit_pos = -1;
+    it.byte_value = 0;
+    return it;
+}
+
+static int read_bits(bit_iterator_t * it, int n_bits, lv_fs_res_t * res)
+{
+    int value = 0;
+    while(n_bits--) {
+        it->byte_value = it->byte_value << 1;
+        it->bit_pos--;
+
+        if(it->bit_pos < 0) {
+            it->bit_pos = 7;
+            *res = lv_fs_read(it->fp, &(it->byte_value), 1, NULL);
+            if(*res != LV_FS_RES_OK) {
+                return -1;
+            }
+        }
+        int8_t bit = (it->byte_value & 0x80) ? 1 : 0;
+
+        value |= (bit << n_bits);
+    }
+    *res = LV_FS_RES_OK;
+    return value;
+}
+
+static int read_bits_signed(bit_iterator_t * it, int n_bits, lv_fs_res_t * res)
+{
+    int value = read_bits(it, n_bits, res);
+    if(value & (1 << (n_bits - 1))) {
+        for(int bit = n_bits; bit < 8; ++bit) {
+            value |= (1 << bit);
+        }
+    }
+    return value;
+}
+
+static int read_label(lv_fs_file_t * fp, int start, const char * label)
+{
+    lv_fs_seek(fp, start);
+
+    uint32_t length;
+    char buf[4];
+
+    if(lv_fs_read(fp, &length, 4, NULL) != LV_FS_RES_OK
+       || lv_fs_read(fp, buf, 4, NULL) != LV_FS_RES_OK
+       || memcmp(label, buf, 4) != 0) {
+        LV_LOG_WARN("Error reading '%s' label.", label);
+        return -1;
+    }
+
+    return length;
+}
+
+static bool load_cmaps_tables(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc,
+                              uint32_t cmaps_start, cmap_table_bin_t * cmap_table)
+{
+    for(unsigned int i = 0; i < font_dsc->cmap_num; ++i) {
+        if(lv_fs_read(fp, &cmap_table[i], sizeof(cmap_table_bin_t), NULL) != LV_FS_RES_OK) {
+            return false;
+        }
+
+        lv_font_fmt_txt_cmap_t * cmap = (lv_font_fmt_txt_cmap_t *) & (font_dsc->cmaps[i]);
+
+        cmap->range_start = cmap_table[i].range_start;
+        cmap->range_length = cmap_table[i].range_length;
+        cmap->glyph_id_start = cmap_table[i].glyph_id_start;
+    }
+
+    for(unsigned int i = 0; i < font_dsc->cmap_num; ++i) {
+        lv_fs_res_t res = lv_fs_seek(fp, cmaps_start + cmap_table[i].data_offset);
+        if(res != LV_FS_RES_OK) {
+            return false;
+        }
+
+        lv_font_fmt_txt_cmap_t * cmap = (lv_font_fmt_txt_cmap_t *) & (font_dsc->cmaps[i]);
+
+        switch(cmap_table[i].format_type) {
+            case 0: {
+                    uint8_t ids_size = sizeof(uint8_t) * cmap_table[i].data_entries_count;
+                    uint8_t * glyph_id_ofs_list = lv_mem_alloc(ids_size);
+
+                    cmap->glyph_id_ofs_list = glyph_id_ofs_list;
+
+                    if(lv_fs_read(fp, glyph_id_ofs_list, ids_size, NULL) != LV_FS_RES_OK) {
+                        return false;
+                    }
+
+                    cmap->type = LV_FONT_FMT_TXT_CMAP_FORMAT0_FULL;
+                    cmap->list_length = cmap->range_length;
+                    cmap->unicode_list = NULL;
+                    break;
+                }
+            case 2:
+                cmap->type = LV_FONT_FMT_TXT_CMAP_FORMAT0_TINY;
+                cmap->list_length = 0;
+                cmap->unicode_list = NULL;
+                cmap->glyph_id_ofs_list = NULL;
+                break;
+            case 1:
+            case 3: {
+                    uint32_t list_size = sizeof(uint16_t) * cmap_table[i].data_entries_count;
+                    uint16_t * unicode_list = (uint16_t *) lv_mem_alloc(list_size);
+
+                    cmap->unicode_list = unicode_list;
+                    cmap->list_length = cmap_table[i].data_entries_count;
+
+                    if(lv_fs_read(fp, unicode_list, list_size, NULL) != LV_FS_RES_OK) {
+                        return false;
+                    }
+
+                    if(cmap_table[i].format_type == 1) {
+                        uint16_t * buf = lv_mem_alloc(sizeof(uint16_t) * cmap->list_length);
+
+                        cmap->type = LV_FONT_FMT_TXT_CMAP_SPARSE_FULL;
+                        cmap->glyph_id_ofs_list = buf;
+
+                        if(lv_fs_read(fp, buf, sizeof(uint16_t) * cmap->list_length, NULL) != LV_FS_RES_OK) {
+                            return false;
+                        }
+                    }
+                    else {
+                        cmap->type = LV_FONT_FMT_TXT_CMAP_SPARSE_TINY;
+                        cmap->glyph_id_ofs_list = NULL;
+                    }
+                    break;
+                }
+            default:
+                LV_LOG_WARN("Unknown cmaps format type %d.", cmap_table[i].format_type);
+                return false;
+        }
+    }
+    return true;
+}
+
+static int32_t load_cmaps(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, uint32_t cmaps_start)
+{
+    int32_t cmaps_length = read_label(fp, cmaps_start, "cmap");
+    if(cmaps_length < 0) {
+        return -1;
+    }
+
+    uint32_t cmaps_subtables_count;
+    if(lv_fs_read(fp, &cmaps_subtables_count, sizeof(uint32_t), NULL) != LV_FS_RES_OK) {
+        return -1;
+    }
+
+    lv_font_fmt_txt_cmap_t * cmaps =
+        lv_mem_alloc(cmaps_subtables_count * sizeof(lv_font_fmt_txt_cmap_t));
+
+    memset(cmaps, 0, cmaps_subtables_count * sizeof(lv_font_fmt_txt_cmap_t));
+
+    font_dsc->cmaps = cmaps;
+    font_dsc->cmap_num = cmaps_subtables_count;
+
+    cmap_table_bin_t * cmaps_tables = lv_mem_alloc(sizeof(cmap_table_bin_t) * font_dsc->cmap_num);
+
+    bool success = load_cmaps_tables(fp, font_dsc, cmaps_start, cmaps_tables);
+
+    lv_mem_free(cmaps_tables);
+
+    return success ? cmaps_length : -1;
+}
+
+static int32_t load_glyph(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc,
+                          uint32_t start, uint32_t * glyph_offset, uint32_t loca_count, font_header_bin_t * header)
+{
+    int32_t glyph_length = read_label(fp, start, "glyf");
+    if(glyph_length < 0) {
+        return -1;
+    }
+
+    lv_font_fmt_txt_glyph_dsc_t * glyph_dsc = (lv_font_fmt_txt_glyph_dsc_t *)
+                                              lv_mem_alloc(loca_count * sizeof(lv_font_fmt_txt_glyph_dsc_t));
+
+    memset(glyph_dsc, 0, loca_count * sizeof(lv_font_fmt_txt_glyph_dsc_t));
+
+    font_dsc->glyph_dsc = glyph_dsc;
+
+    int cur_bmp_size = 0;
+
+    for(unsigned int i = 0; i < loca_count; ++i) {
+        lv_font_fmt_txt_glyph_dsc_t * gdsc = &glyph_dsc[i];
+
+        lv_fs_res_t res = lv_fs_seek(fp, start + glyph_offset[i]);
+        if(res != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        bit_iterator_t bit_it = init_bit_iterator(fp);
+
+        if(header->advance_width_bits == 0) {
+            gdsc->adv_w = header->default_advance_width;
+        }
+        else {
+            gdsc->adv_w = read_bits(&bit_it, header->advance_width_bits, &res);
+            if(res != LV_FS_RES_OK) {
+                return -1;
+            }
+        }
+
+        if(header->advance_width_format == 0) {
+            gdsc->adv_w *= 16;
+        }
+
+        gdsc->ofs_x = read_bits_signed(&bit_it, header->xy_bits, &res);
+        if(res != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        gdsc->ofs_y = read_bits_signed(&bit_it, header->xy_bits, &res);
+        if(res != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        gdsc->box_w = read_bits(&bit_it, header->wh_bits, &res);
+        if(res != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        gdsc->box_h = read_bits(&bit_it, header->wh_bits, &res);
+        if(res != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        int nbits = header->advance_width_bits + 2 * header->xy_bits + 2 * header->wh_bits;
+        int next_offset = (i < loca_count - 1) ? glyph_offset[i + 1] : (uint32_t)(glyph_length - 1);
+        int bmp_size = next_offset - glyph_offset[i] - nbits / 8;
+
+        if(i == 0) {
+            gdsc->adv_w = 0;
+            gdsc->box_w = 0;
+            gdsc->box_h = 0;
+            gdsc->ofs_x = 0;
+            gdsc->ofs_y = 0;
+        }
+
+        gdsc->bitmap_index = cur_bmp_size;
+        if(gdsc->box_w * gdsc->box_h != 0) {
+            cur_bmp_size += bmp_size;
+        }
+    }
+
+    uint8_t * glyph_bmp = (uint8_t *) lv_mem_alloc(sizeof(uint8_t) * cur_bmp_size);
+
+    font_dsc->glyph_bitmap = glyph_bmp;
+
+    cur_bmp_size = 0;
+
+    for(unsigned int i = 1; i < loca_count; ++i) {
+        lv_fs_res_t res = lv_fs_seek(fp, start + glyph_offset[i]);
+        if(res != LV_FS_RES_OK) {
+            return -1;
+        }
+        bit_iterator_t bit_it = init_bit_iterator(fp);
+
+        int nbits = header->advance_width_bits + 2 * header->xy_bits + 2 * header->wh_bits;
+
+        read_bits(&bit_it, nbits, &res);
+        if(res != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        if(glyph_dsc[i].box_w * glyph_dsc[i].box_h == 0) {
+            continue;
+        }
+
+        int next_offset = (i < loca_count - 1) ? glyph_offset[i + 1] : (uint32_t)(glyph_length - 1);
+        int bmp_size = next_offset - glyph_offset[i] - nbits / 8;
+
+        for(int k = 0; k < bmp_size; ++k) {
+            glyph_bmp[cur_bmp_size + k] = read_bits(&bit_it, 8, &res);
+            if(res != LV_FS_RES_OK) {
+                return -1;
+            }
+        }
+        cur_bmp_size += bmp_size;
+    }
+    return glyph_length;
+}
+
+/*
+ * Loads a `lv_font_t` from a binary file, given a `lv_fs_file_t`.
+ *
+ * Memory allocations on `lvgl_load_font` should be immediately zeroed and
+ * the pointer should be set on the `lv_font_t` data before any possible return.
+ *
+ * When something fails, it returns `false` and the memory on the `lv_font_t`
+ * still needs to be freed using `lv_font_free`.
+ *
+ * `lv_font_free` will assume that all non-null pointers are allocated and
+ * should be freed.
+ */
+static bool lvgl_load_font(lv_fs_file_t * fp, lv_font_t * font)
+{
+    lv_font_fmt_txt_dsc_t * font_dsc = (lv_font_fmt_txt_dsc_t *)
+                                       lv_mem_alloc(sizeof(lv_font_fmt_txt_dsc_t));
+
+    memset(font_dsc, 0, sizeof(lv_font_fmt_txt_dsc_t));
+
+    font->dsc = font_dsc;
+
+    /* header */
+    int32_t header_length = read_label(fp, 0, "head");
+    if(header_length < 0) {
+        return false;
+    }
+
+    font_header_bin_t font_header;
+    if(lv_fs_read(fp, &font_header, sizeof(font_header_bin_t), NULL) != LV_FS_RES_OK) {
+        return false;
+    }
+
+    font->base_line = -font_header.descent;
+    font->line_height = font_header.ascent - font_header.descent;
+    font->get_glyph_dsc = lv_font_get_glyph_dsc_fmt_txt;
+    font->get_glyph_bitmap = lv_font_get_bitmap_fmt_txt;
+    font->subpx = LV_FONT_SUBPX_NONE;
+
+    font_dsc->bpp = font_header.bits_per_pixel;
+    font_dsc->kern_scale = font_header.kerning_scale;
+    font_dsc->bitmap_format = font_header.compression_id;
+
+    /* cmaps */
+    uint32_t cmaps_start = header_length;
+    int32_t cmaps_length = load_cmaps(fp, font_dsc, cmaps_start);
+    if(cmaps_length < 0) {
+        return false;
+    }
+
+    /* loca */
+    uint32_t loca_start = cmaps_start + cmaps_length;
+    int32_t loca_length = read_label(fp, loca_start, "loca");
+    if(loca_length < 0) {
+        return false;
+    }
+
+    uint32_t loca_count;
+    if(lv_fs_read(fp, &loca_count, sizeof(uint32_t), NULL) != LV_FS_RES_OK) {
+        return false;
+    }
+
+    bool failed = false;
+    uint32_t * glyph_offset = lv_mem_alloc(sizeof(uint32_t) * (loca_count + 1));
+
+    for(unsigned int i = 0; i < loca_count; ++i) {
+        if(font_header.index_to_loc_format == 0) {
+            uint16_t offset;
+            if(lv_fs_read(fp, &offset, sizeof(uint16_t), NULL) != LV_FS_RES_OK) {
+                failed = true;
+                break;
+            }
+            glyph_offset[i] = offset;
+        }
+        else if(font_header.index_to_loc_format == 1) {
+            uint32_t offset;
+            if(lv_fs_read(fp, &offset, sizeof(uint32_t), NULL) != LV_FS_RES_OK) {
+                failed = true;
+                break;
+            }
+            glyph_offset[i] = offset;
+        }
+        else {
+            LV_LOG_WARN("Unknown index_to_loc_format: %d.", font_header.index_to_loc_format);
+            failed = true;
+            break;
+        }
+    }
+
+    if(failed) {
+        lv_mem_free(glyph_offset);
+        return false;
+    }
+
+    /* glyph */
+    uint32_t glyph_start = loca_start + loca_length;
+    int32_t glyph_length = load_glyph(
+                               fp, font_dsc, glyph_start, glyph_offset, loca_count, &font_header);
+
+    lv_mem_free(glyph_offset);
+
+    if(glyph_length < 0) {
+        return false;
+    }
+
+    if(font_header.tables_count < 4) {
+        font_dsc->kern_dsc = NULL;
+        font_dsc->kern_classes = 0;
+        font_dsc->kern_scale = 0;
+        return true;
+    }
+
+    uint32_t kern_start = glyph_start + glyph_length;
+
+    int32_t kern_length = load_kern(fp, font_dsc, font_header.glyph_id_format, kern_start);
+
+    return kern_length >= 0;
+}
+
+int32_t load_kern(lv_fs_file_t * fp, lv_font_fmt_txt_dsc_t * font_dsc, uint8_t format, uint32_t start)
+{
+    int32_t kern_length = read_label(fp, start, "kern");
+    if(kern_length < 0) {
+        return -1;
+    }
+
+    uint8_t kern_format_type;
+    int32_t padding;
+    if(lv_fs_read(fp, &kern_format_type, sizeof(uint8_t), NULL) != LV_FS_RES_OK ||
+       lv_fs_read(fp, &padding, 3 * sizeof(uint8_t), NULL) != LV_FS_RES_OK) {
+        return -1;
+    }
+
+    if(0 == kern_format_type) { /* sorted pairs */
+        lv_font_fmt_txt_kern_pair_t * kern_pair = lv_mem_alloc(sizeof(lv_font_fmt_txt_kern_pair_t));
+
+        memset(kern_pair, 0, sizeof(lv_font_fmt_txt_kern_pair_t));
+
+        font_dsc->kern_dsc = kern_pair;
+        font_dsc->kern_classes = 0;
+
+        uint32_t glyph_entries;
+        if(lv_fs_read(fp, &glyph_entries, sizeof(uint32_t), NULL) != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        int ids_size;
+        if(format == 0) {
+            ids_size = sizeof(int8_t) * 2 * glyph_entries;
+        }
+        else {
+            ids_size = sizeof(int16_t) * 2 * glyph_entries;
+        }
+
+        uint8_t * glyph_ids = lv_mem_alloc(ids_size);
+        int8_t * values = lv_mem_alloc(glyph_entries);
+
+        kern_pair->glyph_ids_size = format;
+        kern_pair->pair_cnt = glyph_entries;
+        kern_pair->glyph_ids = glyph_ids;
+        kern_pair->values = values;
+
+        if(lv_fs_read(fp, glyph_ids, ids_size, NULL) != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        if(lv_fs_read(fp, values, glyph_entries, NULL) != LV_FS_RES_OK) {
+            return -1;
+        }
+    }
+    else if(3 == kern_format_type) { /* array M*N of classes */
+
+        lv_font_fmt_txt_kern_classes_t * kern_classes = lv_mem_alloc(sizeof(lv_font_fmt_txt_kern_classes_t));
+
+        memset(kern_classes, 0, sizeof(lv_font_fmt_txt_kern_classes_t));
+
+        font_dsc->kern_dsc = kern_classes;
+        font_dsc->kern_classes = 1;
+
+        uint16_t kern_class_mapping_length;
+        uint8_t kern_table_rows;
+        uint8_t kern_table_cols;
+
+        if(lv_fs_read(fp, &kern_class_mapping_length, sizeof(uint16_t), NULL) != LV_FS_RES_OK ||
+           lv_fs_read(fp, &kern_table_rows, sizeof(uint8_t), NULL) != LV_FS_RES_OK ||
+           lv_fs_read(fp, &kern_table_cols, sizeof(uint8_t), NULL) != LV_FS_RES_OK) {
+            return -1;
+        }
+
+        int kern_values_length = sizeof(int8_t) * kern_table_rows * kern_table_cols;
+
+        uint8_t * kern_left = lv_mem_alloc(kern_class_mapping_length);
+        uint8_t * kern_right = lv_mem_alloc(kern_class_mapping_length);
+        int8_t * kern_values = lv_mem_alloc(kern_values_length);
+
+        kern_classes->left_class_mapping  = kern_left;
+        kern_classes->right_class_mapping = kern_right;
+        kern_classes->left_class_cnt = kern_table_rows;
+        kern_classes->right_class_cnt = kern_table_cols;
+        kern_classes->class_pair_values = kern_values;
+
+        if(lv_fs_read(fp, kern_left, kern_class_mapping_length, NULL) != LV_FS_RES_OK ||
+           lv_fs_read(fp, kern_right, kern_class_mapping_length, NULL) != LV_FS_RES_OK ||
+           lv_fs_read(fp, kern_values, kern_values_length, NULL) != LV_FS_RES_OK) {
+            return -1;
+        }
+    }
+    else {
+        LV_LOG_WARN("Unknown kern_format_type: %d", kern_format_type);
+        return -1;
+    }
+
+    return kern_length;
+}
+
+#endif /*LV_USE_FILESYSTEM*/
+

src/lv_font/lv_font_loader.h

@@ -0,0 +1,44 @@
+/**
+ * @file lv_font_loader.h
+ *
+ */
+
+#ifndef LV_FONT_LOADER_H
+#define LV_FONT_LOADER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+#if LV_USE_FILESYSTEM
+
+lv_font_t * lv_font_load(const char * fontName);
+void lv_font_free(lv_font_t * font);
+
+#endif
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_FONT_LOADER_H*/

src/lv_font/lv_symbol_def.h

@@ -9,7 +9,7 @@ extern "C" {
 #include "../lv_conf_internal.h"
 
 /*-------------------------------
- * Symbols from FontAwsome font
+ * Symbols from FontAwesome font
  *-----------------------------*/
 
 /* In the font converter use this list as range:

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
 }
 
 /**
@@ -141,7 +148,7 @@ void lv_gpu_stm32_dma2d_fill_mask(lv_color_t * buf, lv_coord_t buf_w, lv_color_t
  * @param buf a buffer where map should be copied
  * @param buf_w width of the buffer in pixels
  * @param map an "image" to copy
- * @param map_w width of teh map in pixels
+ * @param map_w width of the map in pixels
  * @param copy_w width of the area to copy in pixels (<= buf_w)
  * @param copy_h height of the area to copy in pixels
  * @note `map_w - fill_w` is offset to the next line after copy
@@ -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();
 }
 
@@ -176,7 +178,7 @@ void lv_gpu_stm32_dma2d_copy(lv_color_t * buf, lv_coord_t buf_w, const lv_color_
  * @param buf_w width of the buffer in pixels
  * @param map an "image" to copy
  * @param opa opacity of `map`
- * @param map_w width of teh map in pixels
+ * @param map_w width of the map in pixels
  * @param copy_w width of the area to copy in pixels (<= buf_w)
  * @param copy_h height of the area to copy in pixels
  * @note `map_w - fill_w` is offset to the next line after copy
@@ -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
@@ -60,7 +71,7 @@ void lv_gpu_stm32_dma2d_fill_mask(lv_color_t * buf, lv_coord_t buf_w, lv_color_t
  * @param buf a buffer where map should be copied
  * @param buf_w width of the buffer in pixels
  * @param map an "image" to copy
- * @param map_w width of teh map in pixels
+ * @param map_w width of the map in pixels
  * @param copy_w width of the area to copy in pixels (<= buf_w)
  * @param copy_h height of the area to copy in pixels
  * @note `map_w - fill_w` is offset to the next line after copy
@@ -73,7 +84,7 @@ void lv_gpu_stm32_dma2d_copy(lv_color_t * buf, lv_coord_t buf_w, const lv_color_
  * @param buf_w width of the buffer in pixels
  * @param map an "image" to copy
  * @param opa opacity of `map`
- * @param map_w width of teh map in pixels
+ * @param map_w width of the map in pixels
  * @param copy_w width of the area to copy in pixels (<= buf_w)
  * @param copy_h height of the area to copy in pixels
  * @note `map_w - fill_w` is offset to the next line after copy

src/lv_hal/lv_hal_disp.c

@@ -14,7 +14,7 @@
 #include "lv_hal.h"
 #include "../lv_misc/lv_mem.h"
 #include "../lv_misc/lv_gc.h"
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_core/lv_obj.h"
 #include "../lv_core/lv_refr.h"
 #include "../lv_themes/lv_theme.h"
@@ -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*/
@@ -158,6 +167,11 @@ lv_disp_t * lv_disp_drv_register(lv_disp_drv_t * driver)
 
     lv_task_ready(disp->refr_task); /*Be sure the screen will be refreshed immediately on start up*/
 
+    /*Can't handle this case later so add an error*/
+    if(lv_disp_is_true_double_buf(disp) && disp->driver.set_px_cb) {
+        LV_LOG_ERROR("Can't handle 2 screen sized buffers with set_px_cb. Display will not be refreshed.");
+    }
+
     return disp;
 }
 

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

@@ -8,7 +8,7 @@
 /*********************
  *      INCLUDES
  *********************/
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_hal/lv_hal_indev.h"
 #include "../lv_core/lv_indev.h"
 #include "../lv_misc/lv_mem.h"
@@ -73,7 +73,7 @@ lv_indev_t * lv_indev_drv_register(lv_indev_drv_t * driver)
     if(driver->disp == NULL) driver->disp = lv_disp_get_default();
 
     if(driver->disp == NULL) {
-        LV_LOG_WARN("lv_indev_drv_register: no display registered hence can't attache the indev to "
+        LV_LOG_WARN("lv_indev_drv_register: no display registered hence can't attach the indev to "
                     "a display");
         return NULL;
     }
@@ -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_indev.h

@@ -137,7 +137,7 @@ typedef struct _lv_indev_proc_t {
             lv_point_t drag_sum; /*Count the dragged pixels to check LV_INDEV_DEF_DRAG_LIMIT*/
             lv_point_t drag_throw_vect;
             struct _lv_obj_t * act_obj;      /*The object being pressed*/
-            struct _lv_obj_t * last_obj;     /*The last obejct which was pressed (used by dragthrow and
+            struct _lv_obj_t * last_obj;     /*The last object which was pressed (used by drag_throw and
                                                 other post-release event)*/
             struct _lv_obj_t * last_pressed; /*The lastly pressed object*/
 

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_anim.c

@@ -11,7 +11,7 @@
 #if LV_USE_ANIMATION
 #include <stddef.h>
 #include <string.h>
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_hal/lv_hal_tick.h"
 #include "lv_task.h"
 #include "lv_math.h"
@@ -64,7 +64,7 @@ void _lv_anim_core_init(void)
     last_task_run = lv_tick_get();
     _lv_anim_task = lv_task_create(anim_task, LV_DISP_DEF_REFR_PERIOD, LV_ANIM_TASK_PRIO, NULL);
     anim_mark_list_change(); /*Turn off the animation task*/
-    anim_list_changed = false; /*The list has not actaully changed*/
+    anim_list_changed = false; /*The list has not actually changed*/
 }
 
 /**
@@ -73,7 +73,6 @@ void _lv_anim_core_init(void)
  * lv_anim_t a;
  * lv_anim_init(&a);
  * lv_anim_set_...(&a);
- * lv_anim_craete(&a);
  * @param a pointer to an `lv_anim_t` variable to initialize
  */
 void lv_anim_init(lv_anim_t * a)
@@ -476,8 +475,11 @@ static void anim_task(lv_task_t * param)
                 if(a->path.cb) new_value = a->path.cb(&a->path, a);
                 else new_value = lv_anim_path_linear(&a->path, a);
 
-                /*Apply the calculated value*/
-                if(a->exec_cb) a->exec_cb(a->var, new_value);
+                if(new_value != a->current) {
+                    a->current = new_value;
+                    /*Apply the calculated value*/
+                    if(a->exec_cb) a->exec_cb(a->var, new_value);
+                }
 
                 /*If the time is elapsed the animation is ready*/
                 if(a->act_time >= a->time) {
@@ -501,7 +503,7 @@ static void anim_task(lv_task_t * param)
  * Called when an animation is ready to do the necessary thinks
  * e.g. repeat, play back, delete etc.
  * @param a pointer to an animation descriptor
- * @return true: animation delete occurred nnd the `LV_GC_ROOT(_lv_anim_ll)` has changed
+ * @return true: animation delete occurred and the `LV_GC_ROOT(_lv_anim_ll)` has changed
  * */
 static bool anim_ready_handler(lv_anim_t * a)
 {
@@ -529,11 +531,11 @@ static bool anim_ready_handler(lv_anim_t * a)
     }
     /*If the animation is not deleted then restart it*/
     else {
-        a->act_time = -a->repeat_delay; /*Restart the animation*/
+        a->act_time = -(int32_t)(a->repeat_delay); /*Restart the animation*/
         /*Swap the start and end values in play back mode*/
         if(a->playback_time != 0) {
             /*If now turning back use the 'playback_pause*/
-            if(a->playback_now == 0) a->act_time = -a->playback_delay;
+            if(a->playback_now == 0) a->act_time = -(int32_t)(a->playback_delay);
 
             /*Toggle the play back state*/
             a->playback_now = a->playback_now == 0 ? 1 : 0;

src/lv_misc/lv_anim.h

@@ -82,6 +82,7 @@ typedef struct _lv_anim_t {
     lv_anim_ready_cb_t ready_cb; /**< Call it when the animation is ready*/
     lv_anim_path_t path;         /**< Describe the path (curve) of animations*/
     int32_t start;               /**< Start value*/
+    int32_t current;             /**< Current value */
     int32_t end;                 /**< End value*/
     int32_t time;               /**< Animation time in ms*/
     int32_t act_time;            /**< Current time in animation. Set to negative to make delay.*/
@@ -116,7 +117,6 @@ void _lv_anim_core_init(void);
  * lv_anim_t a;
  * lv_anim_init(&a);
  * lv_anim_set_...(&a);
- * lv_anim_create(&a);
  * @param a pointer to an `lv_anim_t` variable to initialize
  */
 void lv_anim_init(lv_anim_t * a);
@@ -160,7 +160,7 @@ static inline void lv_anim_set_time(lv_anim_t * a, uint32_t duration)
  */
 static inline void lv_anim_set_delay(lv_anim_t * a, uint32_t delay)
 {
-    a->act_time = (int32_t)(-delay);
+    a->act_time = -(int32_t)(delay);
 }
 
 /**
@@ -172,6 +172,7 @@ static inline void lv_anim_set_delay(lv_anim_t * a, uint32_t delay)
 static inline void lv_anim_set_values(lv_anim_t * a, lv_anim_value_t start, lv_anim_value_t end)
 {
     a->start = start;
+    a->current = start;
     a->end   = end;
 }
 

src/lv_misc/lv_async.h

@@ -44,7 +44,7 @@ struct _lv_obj_t;
 /**
  * Call an asynchronous function the next time lv_task_handler() is run. This function is likely to return
  * **before** the call actually happens!
- * @param task_xcb a callback which is the task itself.
+ * @param async_xcb a callback which is the task itself.
  *                 (the 'x' in the argument name indicates that its not a fully generic function because it not follows
  *                  the `func_name(object, callback, ...)` convention)
  * @param user_data custom parameter

src/lv_misc/lv_bidi.c

@@ -130,8 +130,8 @@ lv_bidi_dir_t _lv_bidi_detect_base_dir(const char * txt)
  * Can be `NULL` is unused
  * @param len length of the line in character count
  * @param base_dir base direction of the text: `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL`
- * @param vicual_pos the visual character position which logical position should be get
- * @param is_rtl tell the the char at `viasual_pos` is RTL or LTR context
+ * @param visual_pos the visual character position which logical position should be get
+ * @param is_rtl tell the the char at `visual_pos` is RTL or LTR context
  * @return the logical character position
  */
 uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t len, lv_bidi_dir_t base_dir,
@@ -207,7 +207,7 @@ uint16_t _lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t
  * Bidi process a paragraph of text
  * @param str_in the string to process
  * @param str_out store the result here
- * @param len length of teh text
+ * @param len length of the text
  * @param base_dir base dir of the text
  * @param pos_conv_out an `uint16_t` array to store the related logical position of the character.
  * Can be `NULL` is unused

src/lv_misc/lv_bidi.h

@@ -71,8 +71,8 @@ lv_bidi_dir_t _lv_bidi_detect_base_dir(const char * txt);
  * Can be `NULL` is unused
  * @param len length of the line in character count
  * @param base_dir base direction of the text: `LV_BIDI_DIR_LTR` or `LV_BIDI_DIR_RTL`
- * @param vicual_pos the visual character position which logical position should be get
- * @param is_rtl tell the the char at `viasual_pos` is RTL or LTR context
+ * @param visual_pos the visual character position which logical position should be get
+ * @param is_rtl tell the the char at `visual_pos` is RTL or LTR context
  * @return the logical character position
  */
 uint16_t _lv_bidi_get_logical_pos(const char * str_in, char ** bidi_txt, uint32_t len, lv_bidi_dir_t base_dir,
@@ -97,7 +97,7 @@ uint16_t _lv_bidi_get_visual_pos(const char * str_in, char ** bidi_txt, uint16_t
  * Bidi process a paragraph of text
  * @param str_in the string to process
  * @param str_out store the result here
- * @param len length of teh text
+ * @param len length of the text
  * @param base_dir base dir of the text
  * @param pos_conv_out an `uint16_t` array to store the related logical position of the character.
  * Can be `NULL` is unused

src/lv_misc/lv_color.h

@@ -72,8 +72,8 @@ enum {
     LV_OPA_COVER  = 255,
 };
 
-#define LV_OPA_MIN 5    /*Opacities below this will be transparent*/
-#define LV_OPA_MAX 250  /*Opacities above this will fully cover*/
+#define LV_OPA_MIN 2    /*Opacities below this will be transparent*/
+#define LV_OPA_MAX 253  /*Opacities above this will fully cover*/
 
 #if LV_COLOR_DEPTH == 1
 #define LV_COLOR_SIZE 8
@@ -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*/
@@ -593,19 +596,26 @@ static inline uint8_t lv_color_brightness(lv_color_t color)
     return (uint8_t)(bright >> 3);
 }
 
+#ifdef __cplusplus
+/* Fix of msvc 2019 compiler error C4576 inside C++ code */
+#define _LV_COLOR_MAKE_TYPE_HELPER lv_color_t
+#else
+#define _LV_COLOR_MAKE_TYPE_HELPER (lv_color_t)
+#endif
+
 /* The most simple macro to create a color from R,G and B values */
 #if LV_COLOR_DEPTH == 1
-#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){.full = (uint8_t)((b8 >> 7) | (g8 >> 7) | (r8 >> 7))})
+#define LV_COLOR_MAKE(r8, g8, b8) (_LV_COLOR_MAKE_TYPE_HELPER{.full = (uint8_t)((b8 >> 7) | (g8 >> 7) | (r8 >> 7))})
 #elif LV_COLOR_DEPTH == 8
-#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{(uint8_t)((b8 >> 6) & 0x3U), (uint8_t)((g8 >> 5) & 0x7U), (uint8_t)((r8 >> 5) & 0x7U)}})
+#define LV_COLOR_MAKE(r8, g8, b8) (_LV_COLOR_MAKE_TYPE_HELPER{{(uint8_t)((b8 >> 6) & 0x3U), (uint8_t)((g8 >> 5) & 0x7U), (uint8_t)((r8 >> 5) & 0x7U)}})
 #elif LV_COLOR_DEPTH == 16
 #if LV_COLOR_16_SWAP == 0
-#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{(uint16_t)((b8 >> 3) & 0x1FU), (uint16_t)((g8 >> 2) & 0x3FU), (uint16_t)((r8 >> 3) & 0x1FU)}})
+#define LV_COLOR_MAKE(r8, g8, b8) (_LV_COLOR_MAKE_TYPE_HELPER{{(uint16_t)((b8 >> 3) & 0x1FU), (uint16_t)((g8 >> 2) & 0x3FU), (uint16_t)((r8 >> 3) & 0x1FU)}})
 #else
-#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{(uint16_t)((g8 >> 5) & 0x7U), (uint16_t)((r8 >> 3) & 0x1FU), (uint16_t)((b8 >> 3) & 0x1FU), (uint16_t)((g8 >> 2) & 0x7U)}})
+#define LV_COLOR_MAKE(r8, g8, b8) (_LV_COLOR_MAKE_TYPE_HELPER{{(uint16_t)((g8 >> 5) & 0x7U), (uint16_t)((r8 >> 3) & 0x1FU), (uint16_t)((b8 >> 3) & 0x1FU), (uint16_t)((g8 >> 2) & 0x7U)}})
 #endif
 #elif LV_COLOR_DEPTH == 32
-#define LV_COLOR_MAKE(r8, g8, b8) ((lv_color_t){{b8, g8, r8, 0xff}}) /*Fix 0xff alpha*/
+#define LV_COLOR_MAKE(r8, g8, b8) (_LV_COLOR_MAKE_TYPE_HELPER{{b8, g8, r8, 0xff}}) /*Fix 0xff alpha*/
 #endif
 
 static inline lv_color_t lv_color_make(uint8_t r, uint8_t g, uint8_t b)

src/lv_misc/lv_debug.c

@@ -6,11 +6,13 @@
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_obj.h"
 #include "lv_debug.h"
 
 #if LV_USE_DEBUG
 
+#include "lv_mem.h"
+#include <string.h>
+
 /*********************
  *      DEFINES
  *********************/
@@ -28,7 +30,6 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static bool obj_valid_child(const lv_obj_t * parent, const  lv_obj_t * obj_to_find);
 
 /**********************
  *  STATIC VARIABLES
@@ -54,68 +55,6 @@ bool lv_debug_check_mem_integrity(void)
     return lv_mem_test() == LV_RES_OK ? true : false;
 }
 
-bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type)
-{
-    if(obj_type[0] == '\0') return true;
-
-    lv_obj_type_t types;
-    lv_obj_get_type((lv_obj_t *)obj, &types);
-
-    uint8_t i;
-    for(i = 0; i < LV_MAX_ANCESTOR_NUM; i++) {
-        if(types.type[i] == NULL) break;
-        if(strcmp(types.type[i], obj_type) == 0) return true;
-    }
-
-    return false;
-}
-
-bool lv_debug_check_obj_valid(const lv_obj_t * obj)
-{
-    lv_disp_t * disp = lv_disp_get_next(NULL);
-    while(disp) {
-        lv_obj_t * scr;
-        _LV_LL_READ(disp->scr_ll, scr) {
-
-            if(scr == obj) return true;
-            bool found = obj_valid_child(scr, obj);
-            if(found) return true;
-        }
-
-        disp = lv_disp_get_next(disp);
-    }
-
-    return false;
-}
-
-bool lv_debug_check_style(const lv_style_t * style)
-{
-    if(style == NULL) return true;  /*NULL style is still valid*/
-
-#if LV_USE_ASSERT_STYLE
-    if(style->sentinel != LV_DEBUG_STYLE_SENTINEL_VALUE) {
-        LV_LOG_WARN("Invalid style (local variable or not initialized?)");
-        return false;
-    }
-#endif
-
-    return true;
-}
-
-bool lv_debug_check_style_list(const lv_style_list_t * list)
-{
-    if(list == NULL) return true;  /*NULL list is still valid*/
-
-#if LV_USE_ASSERT_STYLE
-    if(list->sentinel != LV_DEBUG_STYLE_LIST_SENTINEL_VALUE) {
-        LV_LOG_WARN("Invalid style (local variable or not initialized?)");
-        return false;
-    }
-#endif
-
-    return true;
-}
-
 bool lv_debug_check_str(const void * str)
 {
     const uint8_t * s = (const uint8_t *)str;
@@ -196,20 +135,6 @@ void lv_debug_log_error(const char * msg, uint64_t value)
  *   STATIC FUNCTIONS
  **********************/
 
-static bool obj_valid_child(const lv_obj_t * parent, const lv_obj_t * obj_to_find)
-{
-    /*Check all children of `parent`*/
-    lv_obj_t * child;
-    _LV_LL_READ(parent->child_ll, child) {
-        if(child == obj_to_find) return true;
-
-        /*Check the children*/
-        bool found = obj_valid_child(child, obj_to_find);
-        if(found) return true;
-    }
-
-    return false;
-}
 
 #endif /*LV_USE_DEBUG*/
 

src/lv_misc/lv_debug.h

@@ -13,9 +13,10 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_obj.h"
+#include "../lv_conf_internal.h"
 
 #if LV_USE_DEBUG
+#include <stdbool.h>
 
 /*********************
  *      DEFINES
@@ -32,14 +33,6 @@ bool lv_debug_check_null(const void * p);
 
 bool lv_debug_check_mem_integrity(void);
 
-bool lv_debug_check_obj_type(const lv_obj_t * obj, const char * obj_type);
-
-bool lv_debug_check_obj_valid(const lv_obj_t * obj);
-
-bool lv_debug_check_style(const lv_style_t * style);
-
-bool lv_debug_check_style_list(const lv_style_list_t * list);
-
 bool lv_debug_check_str(const void * str);
 
 void lv_debug_log_error(const char * msg, uint64_t value);
@@ -77,20 +70,6 @@ void lv_debug_log_error(const char * msg, uint64_t value);
                                 lv_debug_check_str(str))
 #endif
 
-#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))
-#endif
-
-#ifndef LV_DEBUG_IS_STYLE
-#define LV_DEBUG_IS_STYLE(style_p) (lv_debug_check_style(style_p))
-#endif
-
-#ifndef LV_DEBUG_IS_STYLE_LIST
-#define LV_DEBUG_IS_STYLE_LIST(list_p) (lv_debug_check_style_list(list_p))
-#endif
-
 /*-----------------
  * ASSERTS
  *-----------------*/
@@ -133,30 +112,6 @@ void lv_debug_log_error(const char * msg, uint64_t value);
 # endif
 #endif
 
-#if LV_USE_ASSERT_OBJ
-# ifndef LV_ASSERT_OBJ
-#  define LV_ASSERT_OBJ(obj_p, obj_type) LV_DEBUG_ASSERT(LV_DEBUG_IS_OBJ(obj_p, obj_type), "Invalid object", obj_p);
-# endif
-#else /* LV_USE_ASSERT_OBJ == 0 */
-# if LV_USE_ASSERT_NULL /*Use at least LV_ASSERT_NULL if enabled*/
-#   define LV_ASSERT_OBJ(obj_p, obj_type) LV_ASSERT_NULL(obj_p)
-# else
-#   define LV_ASSERT_OBJ(obj_p, obj_type) true
-# endif
-#endif
-
-
-#if LV_USE_ASSERT_STYLE
-# ifndef LV_ASSERT_STYLE
-#  define LV_ASSERT_STYLE(style_p) LV_DEBUG_ASSERT(LV_DEBUG_IS_STYLE(style_p), "Invalid style", style_p);
-# endif
-# ifndef LV_ASSERT_STYLE_LIST
-#  define LV_ASSERT_STYLE_LIST(list_p) LV_DEBUG_ASSERT(LV_DEBUG_IS_STYLE_LIST(list_p), "Invalid style list", list_p);
-# endif
-#else
-#  define LV_ASSERT_STYLE(style_p) true
-#  define LV_ASSERT_STYLE_LIST(list_p) true
-#endif
 
 #else /* LV_USE_DEBUG == 0 */
 
@@ -167,8 +122,6 @@ void lv_debug_log_error(const char * msg, uint64_t value);
 #define LV_ASSERT_MEM_INTEGRITY() true
 #define LV_ASSERT_STR(p) true
 #define LV_ASSERT_OBJ(obj, obj_type) true
-#define LV_ASSERT_STYLE(p) true
-#define LV_ASSERT_STYLE_LIST(p) true
 
 #endif /* LV_USE_DEBUG */
 /*clang-format on*/

src/lv_misc/lv_fs.c

@@ -9,7 +9,7 @@
 #include "lv_fs.h"
 #if LV_USE_FILESYSTEM
 
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "lv_ll.h"
 #include <string.h>
 #include "lv_gc.h"
@@ -60,7 +60,7 @@ void _lv_fs_init(void)
 }
 
 /**
- * Test if a drive is rady or not. If the `ready` function was not initialized `true` will be
+ * Test if a drive is ready or not. If the `ready` function was not initialized `true` will be
  * returned.
  * @param letter letter of the drive
  * @return true: drive is ready; false: drive is not ready

src/lv_misc/lv_fs.h

@@ -129,7 +129,7 @@ void lv_fs_drv_register(lv_fs_drv_t * drv_p);
 lv_fs_drv_t * lv_fs_get_drv(char letter);
 
 /**
- * Test if a drive is rady or not. If the `ready` function was not initialized `true` will be
+ * Test if a drive is ready or not. If the `ready` function was not initialized `true` will be
  * returned.
  * @param letter letter of the drive
  * @return true: drive is ready; false: drive is not ready

src/lv_misc/lv_ll.c

@@ -51,18 +51,12 @@ void _lv_ll_init(lv_ll_t * ll_p, uint32_t node_size)
 {
     ll_p->head = NULL;
     ll_p->tail = NULL;
-#ifdef LV_MEM_ENV64
+#ifdef LV_ARCH_64
     /*Round the size up to 8*/
-    if(node_size & 0x7) {
-        node_size = node_size & (~0x7);
-        node_size += 8;
-    }
+    node_size = (node_size + 7) & (~0x7);
 #else
     /*Round the size up to 4*/
-    if(node_size & 0x3) {
-        node_size = node_size & (~0x3);
-        node_size += 4;
-    }
+    node_size = (node_size + 3) & (~0x3);
 #endif
 
     ll_p->n_size = node_size;
@@ -140,7 +134,7 @@ void * _lv_ll_ins_tail(lv_ll_t * ll_p)
 
     if(n_new != NULL) {
         node_set_next(ll_p, n_new, NULL);       /*No next after the new tail*/
-        node_set_prev(ll_p, n_new, ll_p->tail); /*The prev. before new is tho old tail*/
+        node_set_prev(ll_p, n_new, ll_p->tail); /*The prev. before new is the old tail*/
         if(ll_p->tail != NULL) {                /*If there is old tail then the new comes after it*/
             node_set_next(ll_p, ll_p->tail, n_new);
         }
@@ -339,7 +333,7 @@ uint32_t _lv_ll_get_len(const lv_ll_t * ll_p)
 }
 
 /**
- * Move a nodw before an other node in the same linked list
+ * Move a node before an other node in the same linked list
  * @param ll_p pointer to a linked list
  * @param n_act pointer to node to move
  * @param n_after pointer to a node which should be after `n_act`
@@ -401,14 +395,13 @@ static void node_set_prev(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * pre
     if(act == NULL) return; /*Can't set the prev node of `NULL`*/
 
     uint8_t * act8 = (uint8_t *) act;
-    uint8_t * prev8 = (uint8_t *) &prev;
 
     act8 += LL_PREV_P_OFFSET(ll_p);
 
-    uint32_t i;
-    for(i = 0; i < sizeof(lv_ll_node_t *); i++) {
-        act8[i] = prev8[i];
-    }
+    lv_ll_node_t ** act_node_p = (lv_ll_node_t **) act8;
+    lv_ll_node_t ** prev_node_p = (lv_ll_node_t **) &prev;
+
+    *act_node_p = *prev_node_p;
 }
 
 /**
@@ -421,12 +414,10 @@ static void node_set_next(lv_ll_t * ll_p, lv_ll_node_t * act, lv_ll_node_t * nex
 {
     if(act == NULL) return; /*Can't set the next node of `NULL`*/
     uint8_t * act8 = (uint8_t *) act;
-    uint8_t * prev8 = (uint8_t *) &next;
 
     act8 += LL_NEXT_P_OFFSET(ll_p);
+    lv_ll_node_t ** act_node_p = (lv_ll_node_t **) act8;
+    lv_ll_node_t ** next_node_p = (lv_ll_node_t **) &next;
 
-    uint32_t i;
-    for(i = 0; i < sizeof(lv_ll_node_t *); i++) {
-        act8[i] = prev8[i];
-    }
+    *act_node_p = *next_node_p;
 }

src/lv_misc/lv_ll.h

@@ -139,7 +139,7 @@ void lv_ll_swap(lv_ll_t * ll_p, void * n1_p, void * n2_p);
  */
 
 /**
- * Move a nodw before an other node in the same linked list
+ * Move a node before an other node in the same linked list
  * @param ll_p pointer to a linked list
  * @param n_act pointer to node to move
  * @param n_after pointer to a node which should be after `n_act`

src/lv_misc/lv_log.c

@@ -45,7 +45,7 @@ static lv_log_print_g_cb_t custom_print_cb;
 /**
  * Register custom print/write function to call when a log is added.
  * It can format its "File path", "Line number" and "Description" as required
- * and send the formatted log message to a consol or serial port.
+ * and send the formatted log message to a console or serial port.
  * @param print_cb a function pointer to print a log
  */
 void lv_log_register_print_cb(lv_log_print_g_cb_t print_cb)

src/lv_misc/lv_log.h

@@ -56,7 +56,7 @@ typedef void (*lv_log_print_g_cb_t)(lv_log_level_t level, const char *, uint32_t
 /**
  * Register custom print/write function to call when a log is added.
  * It can format its "File path", "Line number" and "Description" as required
- * and send the formatted log message to a consol or serial port.
+ * and send the formatted log message to a console or serial port.
  * @param print_cb a function pointer to print a log
  */
 void lv_log_register_print_cb(lv_log_print_g_cb_t print_cb);

src/lv_misc/lv_math.c

@@ -103,7 +103,7 @@ int32_t _lv_bezier3(uint32_t t, int32_t u0, int32_t u1, int32_t u2, int32_t u3)
 
 /**
  * Get the square root of a number
- * @param x integer which square root should be calculatoed
+ * @param x integer which square root should be calculated
  * @param q store the result here. q->i: integer part, q->f: fractional part in 1/256 unit
  * @param mask: optional to skip some iterations if the magnitude of the root is known.
  * Set to 0x8000 by default.
@@ -128,7 +128,6 @@ LV_ATTRIBUTE_FAST_MEM void _lv_sqrt(uint32_t x, lv_sqrt_res_t * q, uint32_t mask
     q->f = (uint32_t)(root & 0xf) << 4;
 }
 
-
 /**
  * Calculate the atan2 of a vector.
  * @param x
@@ -232,6 +231,32 @@ int64_t _lv_pow(int64_t base, int8_t exp)
     return result;
 }
 
+/**
+ * Get the mapped of a number given an input and output range
+ * @param x integer which mapped value should be calculated
+ * @param min_in min input range
+ * @param max_in max input range
+ * @param min_out max output range
+ * @param max_out max output range
+ * @return the mapped number
+ */
+int16_t _lv_map(int32_t x, int32_t min_in, int32_t max_in, int32_t min_out, int32_t max_out)
+{
+    if(x <= min_in) return min_out;
+    if(x >= max_in) return max_out;
+
+    /* The equation should be:
+     *   ((x - min_in) / delta in) * delta_out + min_out
+     * To avoid rounding error reorder the operations:
+     *   (((x - min_in) * delta_out) / delta in) + min_out
+     */
+
+    int32_t delta_in = max_in - min_in;
+    int32_t delta_out = max_out - min_out;
+
+    return ((x - min_in) * delta_out) / delta_in + min_out;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/

src/lv_misc/lv_math.h

@@ -92,7 +92,7 @@ uint16_t _lv_atan2(int x, int y);
 
 /**
  * Get the square root of a number
- * @param x integer which square root should be calculatoed
+ * @param x integer which square root should be calculated
  * @param q store the result here. q->i: integer part, q->f: fractional part in 1/256 unit
  * @param mask: optional to skip some iterations if the magnitude of the root is known.
  * Set to 0x8000 by default.
@@ -112,6 +112,17 @@ LV_ATTRIBUTE_FAST_MEM void _lv_sqrt(uint32_t x, lv_sqrt_res_t * q, uint32_t mask
  */
 int64_t _lv_pow(int64_t base, int8_t exp);
 
+/**
+ * Get the mapped of a number given an input and output range
+ * @param x integer which mapped value should be calculated
+ * @param min_in min input range
+ * @param max_in max input range
+ * @param min_out max output range
+ * @param max_out max output range
+ * @return the mapped number
+ */
+int16_t _lv_map(int32_t x, int32_t min_in, int32_t max_in, int32_t min, int32_t max);
+
 /**********************
  *      MACROS
  **********************/

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];
@@ -108,7 +111,7 @@ static lv_mem_buf_t mem_buf_small[] = {{.p = mem_buf1_32, .size = MEM_BUF_SMALL_
  **********************/
 
 /**
- * Initiaiize the dyn_mem module (work memory and other variables)
+ * Initialize the dyn_mem module (work memory and other variables)
  */
 void _lv_mem_init(void)
 {
@@ -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
@@ -157,16 +161,10 @@ void * lv_mem_alloc(size_t size)
 
 #ifdef LV_ARCH_64
     /*Round the size up to 8*/
-    if(size & 0x7) {
-        size = size & (~0x7);
-        size += 8;
-    }
+    size = (size + 7) & (~0x7);
 #else
     /*Round the size up to 4*/
-    if(size & 0x3) {
-        size = size & (~0x3);
-        size += 4;
-    }
+    size = (size + 3) & (~0x3);
 #endif
     void * alloc = NULL;
 
@@ -206,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;
 }
@@ -281,16 +291,10 @@ void * lv_mem_realloc(void * data_p, size_t new_size)
 
 #ifdef LV_ARCH_64
     /*Round the size up to 8*/
-    if(new_size & 0x7) {
-        new_size = new_size & (~0x7);
-        new_size += 8;
-    }
+    new_size = (new_size + 7) & (~0x7);
 #else
     /*Round the size up to 4*/
-    if(new_size & 0x3) {
-        new_size = new_size & (~0x3);
-        new_size += 4;
-    }
+    new_size = (new_size + 3) & (~0x3);
 #endif
 
     /*data_p could be previously freed pointer (in this case it is invalid)*/
@@ -436,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;
@@ -525,14 +530,13 @@ void * _lv_mem_buf_get(uint32_t size)
             /*if this fails you probably need to increase your LV_MEM_SIZE/heap size*/
             LV_GC_ROOT(_lv_mem_buf[i]).p = lv_mem_realloc(LV_GC_ROOT(_lv_mem_buf[i]).p, size);
             if(LV_GC_ROOT(_lv_mem_buf[i]).p == NULL) {
-                LV_LOG_ERROR("lv_mem_buf_get: Out of memory, can't allocate a new  buffer (increase your LV_MEM_SIZE/heap size)")
+                LV_DEBUG_ASSERT(false, "Out of memory, can't allocate a new  buffer (increase your LV_MEM_SIZE/heap size", 0x00);
             }
             return  LV_GC_ROOT(_lv_mem_buf[i]).p;
         }
     }
 
-    LV_LOG_ERROR("lv_mem_buf_get: no free buffer. Increase LV_DRAW_BUF_MAX_NUM.");
-
+    LV_DEBUG_ASSERT(false, "No free buffer. Increase LV_DRAW_BUF_MAX_NUM.", 0x00);
     return NULL;
 }
 
@@ -582,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
@@ -648,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
@@ -703,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
  */
@@ -753,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
  */
@@ -801,6 +803,7 @@ LV_ATTRIBUTE_FAST_MEM void _lv_memset_ff(void * dst, size_t len)
     }
 }
 
+#endif /*LV_MEMCPY_MEMSET_STD*/
 
 /**********************
  *   STATIC FUNCTIONS
@@ -858,18 +861,13 @@ static void * ent_alloc(lv_mem_ent_t * e, size_t size)
  */
 static void ent_trunc(lv_mem_ent_t * e, size_t size)
 {
+
 #ifdef LV_ARCH_64
     /*Round the size up to 8*/
-    if(size & 0x7) {
-        size = size & (~0x7);
-        size += 8;
-    }
+    size = (size + 7) & (~0x7);
 #else
     /*Round the size up to 4*/
-    if(size & 0x3) {
-        size = size & (~0x3);
-        size += 4;
-    }
+    size = (size + 3) & (~0x3);
 #endif
 
     /*Don't let empty space only for a header without data*/

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;
@@ -59,7 +64,7 @@ extern lv_mem_buf_arr_t _lv_mem_buf;
  **********************/
 
 /**
- * Initiaize the dyn_mem module (work memory and other variables)
+ * Initialize the dyn_mem module (work memory and other variables)
  */
 void _lv_mem_init(void);
 
@@ -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_misc.mk

@@ -14,6 +14,7 @@ CSRCS += lv_utils.c
 CSRCS += lv_async.c
 CSRCS += lv_printf.c
 CSRCS += lv_bidi.c
+CSRCS += lv_debug.c
 
 DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_misc
 VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_misc

src/lv_misc/lv_task.c

@@ -9,7 +9,7 @@
  *********************/
 #include <stddef.h>
 #include "lv_task.h"
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "../lv_hal/lv_hal_tick.h"
 #include "lv_gc.h"
 
@@ -193,9 +193,9 @@ LV_ATTRIBUTE_TASK_HANDLER uint32_t lv_task_handler(void)
     return time_till_next;
 }
 /**
- * Create an "empty" task. It needs to initialzed with at least
+ * Create an "empty" task. It needs to initialized with at least
  * `lv_task_set_cb` and `lv_task_set_period`
- * @return pointer to the craeted task
+ * @return pointer to the created task
  */
 lv_task_t * lv_task_create_basic(void)
 {
@@ -256,13 +256,13 @@ lv_task_t * lv_task_create_basic(void)
  * @param user_data custom parameter
  * @return pointer to the new task
  */
-lv_task_t * lv_task_create(lv_task_cb_t task_cb, uint32_t period, lv_task_prio_t prio, void * user_data)
+lv_task_t * lv_task_create(lv_task_cb_t task_xcb, uint32_t period, lv_task_prio_t prio, void * user_data)
 {
     lv_task_t * new_task = lv_task_create_basic();
     LV_ASSERT_MEM(new_task);
     if(new_task == NULL) return NULL;
 
-    lv_task_set_cb(new_task, task_cb);
+    lv_task_set_cb(new_task, task_xcb);
     lv_task_set_period(new_task, period);
     lv_task_set_prio(new_task, prio);
     new_task->user_data = user_data;
@@ -273,7 +273,7 @@ lv_task_t * lv_task_create(lv_task_cb_t task_cb, uint32_t period, lv_task_prio_t
 /**
  * Set the callback the task (the function to call periodically)
  * @param task pointer to a task
- * @param task_cb teh function to call periodically
+ * @param task_cb the function to call periodically
  */
 void lv_task_set_cb(lv_task_t * task, lv_task_cb_t task_cb)
 {
@@ -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

@@ -88,9 +88,9 @@ LV_ATTRIBUTE_TASK_HANDLER uint32_t lv_task_handler(void);
 //! @endcond
 
 /**
- * Create an "empty" task. It needs to initialzed with at least
+ * Create an "empty" task. It needs to initialized with at least
  * `lv_task_set_cb` and `lv_task_set_period`
- * @return pointer to the craeted task
+ * @return pointer to the created task
  */
 lv_task_t * lv_task_create_basic(void);
 
@@ -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

@@ -147,7 +147,7 @@ void _lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t
  *
  * If the first character is a break character, returns the next index.
  *
- * Example calls from lv_txt_get_next_line() assuming sufficent max_width and
+ * Example calls from lv_txt_get_next_line() assuming sufficient max_width and
  * txt = "Test text\n"
  *        0123456789
  *
@@ -169,7 +169,7 @@ void _lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t
  * @param force Force return the fraction of the word that can fit in the provided space.
  * @return the index of the first char of the next word (in byte index not letter index. With UTF-8 they are different)
  */
-static uint16_t lv_txt_get_next_word(const char * txt, const lv_font_t * font,
+static uint32_t lv_txt_get_next_word(const char * txt, const lv_font_t * font,
                                      lv_coord_t letter_space, lv_coord_t max_width,
                                      lv_txt_flag_t flag, uint32_t * word_w_ptr, lv_txt_cmd_state_t * cmd_state, bool force)
 {
@@ -290,7 +290,7 @@ static uint16_t lv_txt_get_next_word(const char * txt, const lv_font_t * font,
  * @param flags settings for the text from 'txt_flag_type' enum
  * @return the index of the first char of the new line (in byte index not letter index. With UTF-8 they are different)
  */
-uint16_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font,
+uint32_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font,
                                lv_coord_t letter_space, lv_coord_t max_width, lv_txt_flag_t flag)
 {
     if(txt == NULL) return 0;
@@ -350,7 +350,7 @@ uint16_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font,
  * @param flags settings for the text from 'txt_flag_t' enum
  * @return length of a char_num long text
  */
-lv_coord_t _lv_txt_get_width(const char * txt, uint16_t length, const lv_font_t * font, lv_coord_t letter_space,
+lv_coord_t _lv_txt_get_width(const char * txt, uint32_t length, const lv_font_t * font, lv_coord_t letter_space,
                              lv_txt_flag_t flag)
 {
     if(txt == NULL) return 0;
@@ -436,6 +436,8 @@ void _lv_txt_ins(char * txt_buf, uint32_t pos, const char * ins_txt)
 {
     size_t old_len = strlen(txt_buf);
     size_t ins_len = strlen(ins_txt);
+    if(ins_len == 0) return;
+
     size_t new_len = ins_len + old_len;
     pos              = _lv_txt_encoded_get_byte_id(txt_buf, pos); /*Convert to byte index instead of letter index*/
 
@@ -534,6 +536,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 +550,7 @@ static uint32_t lv_txt_utf8_conv_wc(uint32_t c)
         }
         c = swapped;
     }
-
+#endif
     return c;
 }
 

src/lv_misc/lv_txt.h

@@ -84,7 +84,7 @@ void _lv_txt_get_size(lv_point_t * size_res, const char * text, const lv_font_t
  * @return the index of the first char of the new line (in byte index not letter index. With UTF-8
  * they are different)
  */
-uint16_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font, lv_coord_t letter_space, lv_coord_t max_width,
+uint32_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font, lv_coord_t letter_space, lv_coord_t max_width,
                                lv_txt_flag_t flag);
 
 /**
@@ -97,11 +97,11 @@ uint16_t _lv_txt_get_next_line(const char * txt, const lv_font_t * font, lv_coor
  * @param flags settings for the text from 'txt_flag_t' enum
  * @return length of a char_num long text
  */
-lv_coord_t _lv_txt_get_width(const char * txt, uint16_t length, const lv_font_t * font, lv_coord_t letter_space,
+lv_coord_t _lv_txt_get_width(const char * txt, uint32_t length, const lv_font_t * font, lv_coord_t letter_space,
                              lv_txt_flag_t flag);
 
 /**
- * Check next character in a string and decide if te character is part of the command or not
+ * Check next character in a string and decide if the character is part of the command or not
  * @param state pointer to a txt_cmd_state_t variable which stores the current state of command
  * processing
  * @param c the current character