Release v7.1.0

Fix a memory leak bug in function "lv_objmask_remove_mask" .

.clang-format

@@ -1,97 +0,0 @@
----
-Language:        Cpp
-# BasedOnStyle:  LLVM
-AccessModifierOffset: -2
-AlignAfterOpenBracket: Align
-AlignConsecutiveAssignments: true
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlinesLeft: false
-AlignOperands:   true
-AlignTrailingComments: true
-AllowAllParametersOfDeclarationOnNextLine: true
-AllowShortBlocksOnASingleLine: false
-AllowShortCaseLabelsOnASingleLine: true
-AllowShortFunctionsOnASingleLine: None
-AllowShortIfStatementsOnASingleLine: true
-AllowShortLoopsOnASingleLine: true
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: None
-AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: false
-BinPackArguments: true
-BinPackParameters: true
-BreakBeforeBraces: Custom
-BraceWrapping:   
-  AfterClass:      false
-  AfterControlStatement: false
-  AfterEnum:       false
-  AfterFunction:   true
-  AfterNamespace:  false
-  AfterObjCDeclaration: false
-  AfterStruct:     true
-  AfterUnion:      true
-  BeforeCatch:     false
-  BeforeElse:      false
-  IndentBraces:    false
-  SplitEmptyFunction: false
-BreakBeforeBinaryOperators: None
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: false
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-ColumnLimit:     120
-CommentPragmas:  '^ IWYU pragma:'
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 4
-ContinuationIndentWidth: 4
-Cpp11BracedListStyle: true
-DerivePointerAlignment: false
-DisableFormat:   false
-ExperimentalAutoDetectBinPacking: false
-ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-IncludeCategories: 
-  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-    Priority:        2
-  - Regex:           '^(<|"(gtest|isl|json)/)'
-    Priority:        3
-  - Regex:           '.*'
-    Priority:        1
-IncludeIsMainRegex: '$'
-IndentCaseLabels: true
-IndentWidth:     4
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: true
-MacroBlockBegin: ''
-MacroBlockEnd:   ''
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBlockIndentWidth: 2
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-PenaltyBreakBeforeFirstCallParameter: 19
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyExcessCharacter: 1000000
-PenaltyReturnTypeOnItsOwnLine: 60
-PointerAlignment: Middle
-ReflowComments:  true
-SortIncludes:    false
-SpaceAfterCStyleCast: false
-SpaceAfterTemplateKeyword: true
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeParens: Never
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 1
-SpacesInAngles:  false
-SpacesInContainerLiterals: false
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-Standard:        Cpp11
-TabWidth:        4
-UseTab:          Never
-...
-

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,14 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Documentation
+    url: https://docs.lvgl.io
+    about: Be sure to read to documentation first
+  - name: Forum
+    url: https://forum.lvgl.io
+    about: For how-to questions use the forum
+  - name: CONTIBUTING.md
+    url: https://github.com/lvgl/lvgl/blob/master/docs/CONTRIBUTING.md#faq-about-contributing
+    about: The basic rules of contributing
+  - name: CODING_STYLE.md
+    url: https://github.com/lvgl/lvgl/blob/master/docs/CODING_STYLE.md
+    about: Quick summary of LVGL's code style

.github/workflows/ccpp.yml

@@ -0,0 +1,17 @@
+name: C/C++ CI
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    branches: [master, dev ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Run tests
+      run: 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}}

.gitignore

@@ -1,5 +1,8 @@
 **/*.o
+**/*bin
 **/*.swp
 **/*.swo
 tags
 docs/api_doc
+scripts/cppcheck_res.txt
+scripts/built_in_font/lv_font_*

CHANGELOG.md

@@ -0,0 +1,168 @@
+# Changelog
+
+## v7.1.0 (planned on 07.07.2020)
+*Available in the `master` branch*
+
+### 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
+
+### 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.
+- 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
+- Fix lv_roller in infinite mode when used with encoder
+- Add `lv_theme_get_color_secondary()`
+- Add `LV_COLOR_MIX_ROUND_OFS` to adjust color mixing to make it compatible with the GPU
+- 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
+
+## v7.0.0 (18.05.2020)
+
+### Documentation
+The docs for v7 is available at https://docs.littlevgl.com/v7/en/html/index.html
+
+### Legal changes
+
+The name of the project is changed to LVGL and the new website is on https://lvgl.io
+
+LVGL remains free under the same conditions (MIT license) and a company is created to manage LVGL and offer services.
+
+
+### New drawing system
+Complete rework of LVGL's draw engine to use "masks" for more advanced and higher quality graphical effects. 
+A possible use-case of this system is to remove the overflowing content from the rounded edges.
+It also allows drawing perfectly anti-aliased circles, lines, and arcs.
+Internally, the drawings happen by defining masks (such as rounded rectangle, line, angle). 
+When something is drawn the currently active masks can make some pixels transparent. 
+For example, rectangle borders are drawn by using 2 rectangle masks: one mask removes the inner part and another the outer part. 
+
+The API in this regard remained the same but some new functions were added:
+- `lv_img_set_zoom`: set image object's zoom factor
+- `lv_img_set_angle`: set image object's angle without using canvas
+- `lv_img_set_pivot`: set the pivot point of rotation
+
+
+The new drawing engine brought new drawing features too. They are highlighted in the "style" section.
+
+### New style system
+The old style system is replaced with a new more flexible and lightweighted one. 
+It uses an approach similar to CSS: support cascading styles, inheriting properties and local style properties per object. 
+As part of these updates, a lot of objects were reworked and the APIs have been changed. 
+
+- more shadows options: *offset* and *spread*
+- gradient stop position to shift the gradient area and horizontal gradient 
+- `LV_BLEND_MODE_NORMAL/ADDITIVE/SUBTRACTIVE` blending modes
+- *clip corner*: crop the content on the rounded corners
+- *text underline* and *strikethrough*
+- dashed vertical and horizontal lines (*dash gap*, *dash_width*)
+- *outline*: a border-like part drawn out of the background. Can have spacing to the background.
+- *pattern*: display and image in the middle of the background or repeat it
+- *value* display a text which is stored in the style. It can be used e.g. as a lighweighted text on buttons too.
+- *margin*: similar to *padding* but used to keep space outside of the object
+
+Read the [Style](https://docs.littlevgl.com/v7/en/html/overview/style.html) section of the documentation to learn how the new styles system works.
+
+### GPU integration
+To better utilize GPUs, from this version GPU usage can be integrated into LVGL. In `lv_conf.h` any supported GPUs can be enabled with a single configuration option.
+
+Right now, only ST's DMA2D (Chrom-ART) is integrated. More will in the upcoming releases.
+
+### Renames
+The following object types are renamed:
+- sw -> switch
+- ta -> textarea
+- cb -> checkbox
+- lmeter -> linemeter
+- mbox -> msgbox
+- ddlist -> dropdown
+- btnm -> btnmatrix
+- kb -> keyboard
+- preload -> spinner
+- lv_objx folder -> lv_widgets
+- LV_FIT_FILL -> LV_FIT_PARENT
+- LV_FIT_FLOOD -> LV_FLOOD_MAX
+- LV_LAYOUT_COL_L/M/R -> LV_LAYOUT_COLUMN_LEFT/MID/RIGHT
+- LV_LAYOUT_ROW_T/M/B -> LV_LAYOUT_ROW_TOP/MID/BOTTOM
+
+### Reworked and improved object
+- `dropdown`: Completely reworked. Now creates a separate list when opened and can be dropped to down/up/left/right.
+- `label`: `body_draw` is removed, instead, if its style has a visible background/border/shadow etc it will be drawn. Padding really makes the object larger (not just virtually as before)
+- `arc`: can draw bacground too.
+- `btn`: doesn't store styles for each state because it's done naturally in the new style system.
+- `calendar`: highlight the pressed datum. The used styles are changed: use `LV_CALENDAR_PART_DATE` normal for normal dates, checked for highlighted, focused for today, pressed for the being pressed. (checked+pressed, focused+pressed also work)
+- `chart`: only has `LINE` and `COLUMN` types because with new styles all the others can be described. LV_CHART_PART_SERIES sets the style of the series. bg_opa > 0 draws an area in LINE mode. `LV_CHART_PART_SERIES_BG` also added to set a different style for the series area. Padding in `LV_CHART_PART_BG` makes the series area smaller, and it ensures space for axis labels/numbers.
+- `linemeter`, `gauge`: can have background if the related style properties are set. Padding makes the scale/lines smaller. scale_border_width and scale_end_border_width allow to draw an arc on the outer part of the scale lines.
+- `gauge`: `lv_gauge_set_needle_img` allows use image as needle
+- `canvas`: allow drawing to true color alpha and alpha only canvas, add `lv_canvas_blur_hor/ver` and rename `lv_canvas_rotate` to `lv_canvas_transform`
+- `textarea`: If available in the font use bullet (`U+2022`) character in text area password 
+
+### New object types
+- `lv_objmask`: masks can be added to it. The children will be masked accordingly. 
+
+### Others
+- Change the built-in fonts to [Montserrat](https://fonts.google.com/specimen/Montserrat) and add built-in fonts from 12 px to 48 px for every 2nd size.
+- Add example CJK and Arabic/Persian/Hebrew built-in font
+- Add ° and "bullet" to the built-in fonts
+- Add Arabic/Persian script support: change the character according to its position in the text. 
+- Add `playback_time` to animations.
+- Add `repeat_count` to animations instead of the current "repeat forever".
+- Replace `LV_LAYOUT_PRETTY` with `LV_LAYOUT_PRETTY_TOP/MID/BOTTOM`
+
+### Demos
+- [lv_examples](https://github.com/littlevgl/lv_examples) was reworked and new examples and demos were added
+
+### New release policy
+- Maintain this Changelog for every release
+- Save old major version in new branches. E.g. `release/v6`
+- Merge new features and fixes directly into `master` and release a patch or minor releases every 2 weeks.
+
+### Migrating from v6 to v7
+- First and foremost, create a new `lv_conf.h` based on `lv_conf_templ.h`.
+- To try the new version it suggested using a simulator project and see the examples.
+- If you have a running project, the most difficult part of the migration is updating to the new style system. Unfortunately, there is no better way than manually updating to the new format.
+- The other parts are mainly minor renames and refactoring as described above. 

LICENCE.txt

@@ -1,5 +1,5 @@
 MIT licence
-Copyright (c) 2016 Gábor Kiss-Vámosi
+Copyright (c) 2020 LVGL LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -1,235 +1,86 @@
-<h1 align="center"> LittlevGL - Open-source Embedded GUI Library</h1>
+<h1 align="center"> LVGL - Light and Versatile Graphics Library</h1>
 <p align="center">
-<a href="https://github.com/littlevgl/lvgl/blob/master/LICENCE.txt"><img src="https://img.shields.io/badge/licence-MIT-blue.svg"></a>
-<a href="https://github.com/littlevgl/lvgl/releases/tag/v6.1.2"><img src="https://img.shields.io/badge/version-6.1.2-blue.svg"></a>
+<a href="https://github.com/lvgl/lvgl/blob/master/LICENCE.txt"><img src="https://img.shields.io/badge/licence-MIT-blue.svg"></a>
+<a href="https://github.com/lvgl/lvgl/releases/tag/v7.0.0"><img src="https://img.shields.io/badge/version-7.0.0-blue.svg"></a>
 </p>
 
 <p align="center">
-<img src="https://littlevgl.com/github/cover_ori_reduced_2.gif">
+<img src="https://lvgl.io/assets/images/img_1.png">
 </p>
 
 <p align="center">
-LittlevGL provides everything you need to create a Graphical User Interface (GUI) on embedded systems with easy-to-use graphical elements, beautiful visual effects and low memory footprint. 
+LVGL provides everything you need to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint. 
 </p>
 
 <h4 align="center">
-<a href="https://littlevgl.com">Website </a> &middot; 
-<a href="https://littlevgl.com/live-demo">Live demo</a> &middot; 
-<a href="https://docs.littlevgl.com/en/html/get-started/pc-simulator.html">Simulator</a> &middot; 
-<a href="https://forum.littlevgl.com">Forum</a> &middot; 
-<a href="https://docs.littlevgl.com/">Docs</a> &middot;
-<a href="https://blog.littlevgl.com/">Blog</a>
+<a href="https://lvgl.io">Website </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;
 </h4>
 
 ---
 
-- [Features](#features)
-- [Supported devices](#supported-devices)
-- [Quick start in a simulator](#quick-start-in-a-simulator)
-- [Add LittlevGL to your project](#add-littlevgl-to-your-project)
-- [Learn the basics](#learn-the-basics)
-- [Examples](#examples)
-- [Contributing](#contributing)
-- [Donate](#donate)
-
-
 ## 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
-* **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
-* **Micropython Binding** exposes [LittlevGL API in Micropython](https://blog.littlevgl.com/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: buttons, charts, lists, sliders, images, etc.
+* Advanced graphics: animations, anti-aliasing, opacity, smooth scrolling
+* Simultaneously use various input devices: touchscreen, mouse, keyboard, encoder, buttons, etc.
+* Simultaneously use multiple displays: e.g. monochrome and color display
+* Multi-language support with UTF-8 encoding, Bidirectional support, and Arabic text handling
+* Fully customizable graphical elements via CSS-like styles
+* 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 are 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
 
 ## Supported devices
-Basically, every modern controller - which is able to drive a display - is suitable to run LittlevGL. The minimal requirements:
+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: ~8..16 kB depending on the used features and objects types
-  - Stack: &gt; 2kB (&gt; 4 kB is recommended)
-  - Dynamic data (heap): &gt; 4 KB (&gt; 16 kB is recommended if using several objects).
+  - 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
+- C99 or newer compiler
 
 *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.littlevgl.com/2017-07-15/stm32f429_disco_port), [STM32F7](https://github.com/littlevgl/stm32f746_disco_no_os_sw4stm32)
+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), STM32L4
 - Microchip dsPIC33, PIC24, PIC32MX, PIC32MZ
-- NXP Kinetis, LPC, iMX
-- [Linux frame buffer](https://blog.littlevgl.com/2018-01-03/linux_fb) (/dev/fb)
+- 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)
-- [Espressif ESP32](https://github.com/littlevgl/lv_port_esp32)
-- Nordic nrf52
+- [Espressif ESP32](https://github.com/lvgl/lv_port_esp32)
+- [Infineon aurix](https://github.com/lvgl/lv_port_aurix)
+- Nordic NRF52
 - Quectell M66
 
-## Quick start in a simulator
-The easiest way to get started with LittlevGL 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://littlevgl.com/logo/ide/eclipse.jpg)](https://github.com/littlevgl/pc_simulator_sdl_eclipse) | [![CodeBlocks](https://littlevgl.com/logo/ide/codeblocks.jpg)](https://github.com/littlevgl/pc_simulator_win_codeblocks) | [![VisualStudio](https://littlevgl.com/logo/ide/visualstudio.jpg)](https://github.com/littlevgl/visual_studio_2017_sdl_x64)   |   [![PlatformIO](https://littlevgl.com/logo/ide/platformio.jpg)](https://github.com/littlevgl/pc_simulator_sdl_platformio) | [![QtCreator](https://littlevgl.com/logo/ide/qtcreator.jpg)](https://blog.littlevgl.com/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 LittlevGL to your project
-
-The steps below show how to setup LittlevGL on an embedded system with a display and a touchpad. 
-You can use the [Simulators](https://docs.littlevgl.com/en/html/get-started/pc-simulator) to get ready to use projects which can be run on your PC. 
-
-1. [Download](https://littlevgl.com/download) or [Clone](https://github.com/littlevgl/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 LittlevGL 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 LittlevGL.
-6. Call `lv_init()`
-7. Create a display buffer for LittlevGL
-```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
-
-### Objects (Widgets)
-
-The graphical elements like Buttons, Labels, Sliders, Charts etc are called objects in LittelvGL. Go to [Object types](https://docs.littlevgl.com/en/html/object-types/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*, te second parameters can be an object to copy (`NULL` is 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
-Styles can be assigned to the objects to changed their appearance. A style describes the appearance of rectangle-like objects (like a button or slider), texts, images and lines at once. 
-
-You can create a new style like this:
-```c
-static lv_style_t style1;                       /*Declare a new style. Should be `static`*/
-lv_style_copy(&style1, &lv_style_plain);        /*Copy a built-in style*/
-style1.body.main_color = LV_COLOR_RED;          /*Main color*/
-style1.body.grad_color = lv_color_hex(0xffd83c) /*Gradient color (orange)*/
-style1.body.radius = 3;
-style1.text.color = lv_color_hex3(0x0F0)        /*Label color (green)*/
-style1.text.font = &lv_font_dejavu_22;          /*Change font*/
-...
-```
-
-To set a new style for an object use the `lv_<type>set_style(obj, LV_<TYPE>_STYLE_<NAME>, &my_style)` functions. For example:
-```c
-lv_slider_set_style(slider1, LV_SLIDER_STYLE_BG, &slider_bg_style);
-lv_slider_set_style(slider1, LV_SLIDER_STYLE_INDIC, &slider_indic_style);
-lv_slider_set_style(slider1, LV_SLIDER_STYLE_KNOB, &slider_knob_style);
-```
-
-If an object's style is `NULL` then it will inherit its parent's style. For example, the labels' style are `NULL` by default. If you place them on a button then they will use the `style.text` properties from the button's style.
-
-Learn more in [Style overview](https://docs.littlevgl.com/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.littlevgl.com/en/html/overview/event) section. 
-
+## Get started
+his 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. Read the [Quick overview](https://docs.lvgl.io/latest/en/html/get-started/quick-overview.html) page of the documentation (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 got 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*/
@@ -249,121 +100,10 @@ void btn_event_cb(lv_obj_t * btn, lv_event_t event)
     }
 }
 ```
-![LittlevGL button with label example](https://docs.littlevgl.com/en/misc/simple_button_example.gif)
+![LVGL button with label example](https://raw.githubusercontent.com/lvgl/docs/latest/misc/simple_button_example.gif)
 
-### Button with styles
-Add styles to the previously button from the previous example
-```c
-static lv_style_t style_btn_rel;                        /*A variable to store the released style*/
-lv_style_copy(&style_btn_rel, &lv_style_plain);         /*Initialize from a built-in style*/
-style_btn_rel.body.border.color = lv_color_hex3(0x269);
-style_btn_rel.body.border.width = 1;
-style_btn_rel.body.main_color = lv_color_hex3(0xADF);
-style_btn_rel.body.grad_color = lv_color_hex3(0x46B);
-style_btn_rel.body.shadow.width = 4;
-style_btn_rel.body.shadow.type = LV_SHADOW_BOTTOM;
-style_btn_rel.body.radius = LV_RADIUS_CIRCLE;
-style_btn_rel.text.color = lv_color_hex3(0xDEF);
-
-static lv_style_t style_btn_pr;                         /*A variable to store the pressed style*/
-lv_style_copy(&style_btn_pr, &style_btn_rel);           /*Initialize from the released style*/
-style_btn_pr.body.border.color = lv_color_hex3(0x46B);
-style_btn_pr.body.main_color = lv_color_hex3(0x8BD);
-style_btn_pr.body.grad_color = lv_color_hex3(0x24A);
-style_btn_pr.body.shadow.width = 2;
-style_btn_pr.text.color = lv_color_hex3(0xBCD);
-
-lv_btn_set_style(btn, LV_BTN_STYLE_REL, &style_btn_rel);    /*Set the button's released style*/
-lv_btn_set_style(btn, LV_BTN_STYLE_PR, &style_btn_pr);      /*Set the button's pressed style*/
-```
-
-![Stylsd button is LittelvGL](https://docs.littlevgl.com/en/misc/button_style_example.gif)
-
-### Slider and object alignment
-```c
-lv_obj_t * label;
-
-...
-
-/* Create a slider in the center of the display */
-lv_obj_t * slider = lv_slider_create(lv_scr_act(), NULL);
-lv_obj_set_width(slider, 200);                        /*Set the width*/
-lv_obj_align(slider, NULL, LV_ALIGN_CENTER, 0, 0);    /*Align to the center of the parent (screen)*/
-lv_obj_set_event_cb(slider, slider_event_cb);         /*Assign an event function*/
-
-/* Create a label below the slider */
-label = lv_label_create(lv_scr_act(), NULL);
-lv_label_set_text(label, "0");
-lv_obj_set_auto_realign(slider, true);
-lv_obj_align(label, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
-
-...
-
-void slider_event_cb(lv_obj_t * slider, lv_event_t event)
-{
-    if(event == LV_EVENT_VALUE_CHANGED) {
-        static char buf[4];                                 /* max 3 bytes  for number plus 1 null terminating byte */
-        snprintf(buf, 4, "%u", lv_slider_get_value(slider));
-        lv_label_set_text(slider_label, buf);               /*Refresh the text*/
-    }
-}
-```
-
-![Slider example with LittlevGL](https://docs.littlevgl.com/en/misc/slider_example.gif)
-
-### List and themes
-```c
-/*Texts of the list elements*/
-const char * txts[] = {"First", "Second", "Third", "Forth", "Fifth", "Sixth", NULL};
-
-/* Initialize and set a theme. `LV_THEME_NIGHT` needs to enabled in lv_conf.h. */
-lv_theme_t * th = lv_theme_night_init(20, NULL);
-lv_theme_set_current(th);
-
-/*Create a list*/
-lv_obj_t* list = lv_list_create(lv_scr_act(), NULL);
-lv_obj_set_size(list, 120, 180);
-lv_obj_set_pos(list, 10, 10);
-
-/*Add buttons*/
-uint8_t i;
-for(i = 0; txts[i]; i++) {
-    lv_obj_t * btn = lv_list_add_btn(list, LV_SYMBOL_FILE, txts[i]);
-    lv_obj_set_event_cb(btn, list_event);       /*Assign event function*/
-    lv_btn_set_toggle(btn, true);               /*Enable on/off states*/
-}
-
-/* Initialize and set an other theme. `LV_THEME_MATERIAL` needs to enabled in lv_conf.h.
- * If `LV_TEHE_LIVE_UPDATE  1` then the previous list's style will be updated too.*/
-th = lv_theme_material_init(210, NULL);
-lv_theme_set_current(th);
-
-/*Create an other list*/
-list = lv_list_create(lv_scr_act(), NULL);
-lv_obj_set_size(list, 120, 180);
-lv_obj_set_pos(list, 150, 10);
-
-/*Add buttons with the same texts*/
-for(i = 0; txts[i]; i++) {
-    lv_obj_t * btn = lv_list_add_btn(list, LV_SYMBOL_FILE, txts[i]);
-    lv_obj_set_event_cb(btn, list_event);
-    lv_btn_set_toggle(btn, true);
-}
-
-...
-
-static void list_event(lv_obj_t * btn, lv_event_t e)
-{
-    if(e == LV_EVENT_CLICKED) {
-        printf("%s\n", lv_list_get_btn_text(btn));
-    }
-
-}
-```
-![List and theme example with LittlevGL](https://docs.littlevgl.com/en/misc/list_theme_example.gif)
-
-### Use LittlevGL from Micropython
-Learn more about [Micropython](https://docs.littlevgl.com/en/html/get-started/micropython).
+### LVGL from Micropython
+Learn more about [Micropython](https://docs.lvgl.io/en/html/get-started/micropython).
 ```python
 # Create a Button and a Label
 scr = lv.obj()
@@ -377,22 +117,4 @@ lv.scr_load(scr)
 ```
 
 ## Contributing
-To ask questions please use the [Forum](https://forum.littlevgl.com).
-For development-related things (bug reports, feature suggestions) use [GitHub's Issue tracker](https://github.com/littlevgl/lvgl/issues). 
-
-If you are interested in contributing to LittlevGL you can
-- **Help others** in the [Forum](https://forum.littlevgl.com).
-- **Inspire people** by speaking about your project in [My project](https://forum.littlevgl.com/c/my-projects) category in the Forum or add it to the [References](https://blog.littlevgl.com/2018-12-26/references) post
-- **Improve and/or translate the documentation.** Go to the [Documentation](https://github.com/littlevgl/docs) repository to learn more
-- **Write a blog post** about your experiences. See how to do it in the [Blog](https://github.com/littlevgl/blog) repository
-- **Report and/or fix bugs** in [GitHub's issue tracker](https://github.com/littlevgl/lvgl/issues)
-- **Help in the developement**. Check the [Open issues](https://github.com/littlevgl/lvgl/issues) especially the ones with [Help wanted](https://github.com/littlevgl/lvgl/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) label and tell your ideas about a topic or implement a feature.
-
-It should be useful to read the
-- [Contributing guide](https://blog.littlevgl.com/2018-12-06/contributing)
-- [Coding style guide](https://github.com/littlevgl/lvgl/blob/master/docs/CODING_STYLE.md)
-
-## Donate
-If you are pleased with the library, found it useful, or you are happy with the support you got, please help its further development:
-
-[![Donate](https://littlevgl.com/donate_dir/donate_btn.png)](https://littlevgl.com/donate)
+For a detailed description of contribution opportunities visit the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) section of the documentation.

docs/CODING_STYLE.md

@@ -1,6 +1,7 @@
+# Coding style
 
 ## File format
-Use [lv_misc/lv_templ.c](https://github.com/littlevgl/lvgl/blob/master/src/lv_misc/lv_templ.c) and [lv_misc/lv_templ.h](https://github.com/littlevgl/lvgl/blob/master/src/lv_misc/lv_templ.h)
+Use [lv_misc/lv_templ.c](https://github.com/lvgl/lvgl/blob/master/src/lv_misc/lv_templ.c) and [lv_misc/lv_templ.h](https://github.com/lvgl/lvgl/blob/master/src/lv_misc/lv_templ.h)
 
 ## Naming conventions
 * Words are separated by '_'
@@ -15,17 +16,18 @@ Use [lv_misc/lv_templ.c](https://github.com/littlevgl/lvgl/blob/master/src/lv_mi
   * prefer `typedef struct` and `typedef enum` instead of  `struct name` and `enum name`
   * always end `typedef struct` and `typedef enum` type names with `_t`
 * Abbreviations:
-  * Use abbreviations on public names only if they become longer than 32 characters 
-  * Use only very straightforward (e.g. pos: position) or well-established (e.g. pr: press) abbreviations 
+  * Only words longer or equal than 6 characters can be abbreviated. 
+  * Abbreviate only if it makes the word at least half as long
+  * Use only very straightforward and well-known abbreviations (e.g. pos: position, def: default, btn: button) 
 
 ## Coding guide
 * Functions:
   * Try to write function shorter than is 50 lines 
-  * Always shorter than 100 lines (except very straightforwards) 
+  * Always shorter than 200 lines (except very straightforwards) 
 * Variables:
   * One line, one declaration (BAD: char x, y;)
   * Use `<stdint.h>` (*uint8_t*, *int32_t* etc)
-  * Declare variables when needed (not all at function start)
+  * Declare variables where needed (not all at function start)
   * Use the smallest required scope
   * Variables in a file (outside functions) are always *static*
   * Do not use global variables (use functions to set/get static variables)
@@ -84,11 +86,4 @@ void lv_label_set_text(lv_obj_t * label, const char * text)
 
 Use 4 spaces indentation instead of tab.
 
-You can use **astyle** to format the code. The required config flies are: `docs/astyle_c` and `docs/astyle_h`.
-To format the source files: 
- `$ find . -type f -name "*.c" | xargs astyle --options=docs/astyle_c`
- 
-To format the header files:
- `$ find . -type f -name "*.h" | xargs astyle --options=docs/astyle_h`
- 
-Append `-n` to the end to skip creation of backup file OR use `$ find . -type f -name "*.bak"  -delete` (for source file's backups) and `find . -type f -name "*.orig" -delete` (for header file's backups)
+You can use **astyle** to format the code. Run `code-formatter.sh` from the `scrips` folder.

docs/CONTRIBUTING.md

@@ -1,111 +1,5 @@
-# Contributing to Littlev Graphics Library
+# Contributing to LVGL
 
-**Do you have some free time to spend with programming?
-Are you working on an Embedded GUI project with LittlevGL?
-See how can you help to improve the graphics library!**
+Thank you for considering contributing to LVGL. 
 
-There are many ways to join the community. If you have some time to work with us I'm sure you will find something that fits you! You can:
-- help others in the [Forum](https://forum.littlevgl.com/)
-- improve and/or translate the documentation
-- write a blog post about your experiences
-- report and/or fix bugs
-- suggest and/or implement new features
-
-But first, start with the most Frequently Asked Questions.
-
-# FAQ about contributing
-
-## Where can I write my question and remarks?
-
-We use the [Forum](https://forum.littlevgl.com/) to ask and answer questions and [GitHub's issue tracker](https://github.com/littlevgl/lvgl/issues) for development-related discussion.
-
-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.
-- If possible send an absolute minimal code example in order to reproduce the issue
-- Use [Markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) to format your post.
-
-## How can I send fixes and improvements?
-
-Merging new code happens via Pull Requests. If you are still not familiar with the Pull Requests (PR for short) here is a quick guide:
-1. **Fork** the [lvgl repository](https://github.com/littlevgl/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 the actual `dev-x.y` branch. 
-5. **Describe** what is in the update. An example code is welcome if applicable.
-
-Some advice:
-- If you are not sure about your fix or feature it's better to open an issue first and discuss the details there.
-- 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/littlevgl/lvgl/blob/master/docs/CODING_STYLE.md)
-
-
-## Where is the documentation?
-
-You can read the documentation here: <https://docs.littlevgl.com/>  
-You can edit the documentation here: <https://github.com/littlevgl/doc>  
-
-## Where is the blog?
-
-You can read the blog here: <https://blog.littlevgl.com/>  
-You can edit the blog here: <https://github.com/littlevgl/blog>  
-
-# So how and where can you contribute?
-
-## 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.littlevgl.com/](https://forum.littlevgl.com/) 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.
-
-## Improving and/or translating the documentation
-
-If you would like to contribute to LittlevGL 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.littlevgl.com/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. 
-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 LittlevGL project here: [LittlevGL 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.littlevgl.com/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 at least the [Porting section](https://docs.littlevgl.com/en/html/porting/index.html) is translated.
-
-
-## Writing a blog post about your experiences
-
-Have you ported LittlevGL to a new platform? Have you created a fancy GUI? Do you know a great trick? 
-You can share your knowledge on LittlevGL's blog! It's super easy to add your own post:
-- Fork and clone the [blog repository](https://github.com/littlevgl/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
-
-## Reporting and/or fixing bugs
-For simple bugfixes (typos, missing error handling, fixing a warning) is 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 even add the minimal code snippet.
-
-## Suggesting and/or implementing 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 LittlevGL well enough. We will help you to get started. 
-
-During the implementation don't forget the [Code style guide](https://github.com/littlevgl/lvgl/blob/master/docs/CODING_STYLE.md).
-
-# Summary
-
-I hope you have taken a liking to contribute to LittlevGL. 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.

examples/arduino/ESP32_TFT_eSPI/ESP32_TFT_eSPI.ino

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

examples/arduino/ESP32_TFT_eSPI/README.md

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

examples/arduino/README.md

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

examples/porting/lv_port_disp_template.c

@@ -54,20 +54,20 @@ void lv_port_disp_init(void)
      * Create a buffer for drawing
      *----------------------------*/
 
-    /* LittlevGL requires a buffer where it draws the objects. The buffer's has to be greater than 1 display row
+    /* LVGL requires a buffer where it draws the objects. The buffer's has to be greater than 1 display row
      *
      * There are three buffering configurations:
      * 1. Create ONE buffer with some rows: 
-     *      LittlevGL will draw the display's content here and writes it to your display
+     *      LVGL will draw the display's content here and writes it to your display
      * 
      * 2. Create TWO buffer with some rows: 
-     *      LittlevGL will draw the display's content to a buffer and writes it your display.
+     *      LVGL will draw the display's content to a buffer and writes it your display.
      *      You should use DMA to write the buffer's content to the display.
-     *      It will enable LittlevGL to draw the next part of the screen to the other buffer while
+     *      It will enable LVGL to draw the next part of the screen to the other buffer while
      *      the data is being sent form the first buffer. It makes rendering and flushing parallel.
      * 
      * 3. Create TWO screen-sized buffer: 
-     *      Similar to 2) but the buffer have to be screen sized. When LittlevGL is ready it will give the
+     *      Similar to 2) but the buffer have to be screen sized. When LVGL is ready it will give the
      *      whole frame to display. This way you only need to change the frame buffer's address instead of
      *      copying the pixels.
      * */
@@ -91,7 +91,7 @@ void lv_port_disp_init(void)
 
 
     /*-----------------------------------
-     * Register the display in LittlevGL
+     * Register the display in LVGL
      *----------------------------------*/
 
     lv_disp_drv_t disp_drv;                         /*Descriptor of a display driver*/

examples/porting/lv_port_fs_template.c

@@ -81,7 +81,7 @@ void lv_port_fs_init(void)
     fs_init();
 
     /*---------------------------------------------------
-     * Register the file system interface  in LittlevGL
+     * Register the file system interface  in LVGL
      *--------------------------------------------------*/
 
     /* Add a simple drive to open images */

examples/porting/lv_port_indev_template.c

@@ -293,7 +293,7 @@ static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
     if(act_key != 0) {
         data->state = LV_INDEV_STATE_PR;
 
-        /*Translate the keys to LittlevGL control characters according to your key definitions*/
+        /*Translate the keys to LVGL control characters according to your key definitions*/
         switch(act_key) {
         case 1:
             act_key = LV_KEY_NEXT;

library.json

@@ -1,12 +1,12 @@
 {
     "name": "lvgl",
-    "version": "v6.1.2",
+    "version": "v7.1.0",
     "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/littlevgl/lvgl.git"
+        "url": "https://github.com/lvgl/lvgl.git"
     },
     "build": {
         "includeDir": "."

lv_conf_template.h

@@ -1,6 +1,6 @@
 /**
  * @file lv_conf.h
- *
+ * Configuration file for LVGL v7.1.0
  */
 
 /*
@@ -25,7 +25,7 @@
 
 /* Color depth:
  * - 1:  1 byte per pixel
- * - 8:  RGB233
+ * - 8:  RGB332
  * - 16: RGB565
  * - 32: ARGB8888
  */
@@ -43,9 +43,6 @@
 /*Images pixels with this color will not be drawn (with chroma keying)*/
 #define LV_COLOR_TRANSP    LV_COLOR_LIME         /*LV_COLOR_LIME: pure green*/
 
-/* Enable chroma keying for indexed images. */
-#define LV_INDEXED_CHROMA    1
-
 /* Enable anti-aliasing (lines, and radiuses will be smoothed) */
 #define LV_ANTIALIAS        1
 
@@ -56,7 +53,18 @@
 /* Dot Per Inch: used to initialize default sizes.
  * E.g. a button with width = LV_DPI / 2 -> half inch wide
  * (Not so important, you can adjust it to modify default sizes and spaces)*/
-#define LV_DPI              100     /*[px]*/
+#define LV_DPI              130     /*[px]*/
+
+/* The the real width of the display changes some default values:
+ * default object sizes, layout of examples, etc.
+ * According to the width of the display (hor. res. / dpi)
+ * the displays fall in 4 categories.
+ * The 4th is extra large which has no upper limit so not listed here
+ * The upper limit of the categories are set below in 0.1 inch unit.
+ */
+#define LV_DISP_SMALL_LIMIT  30
+#define LV_DISP_MEDIUM_LIMIT 50
+#define LV_DISP_LARGE_LIMIT  70
 
 /* Type of coordinates. Should be `int16_t` (or `int32_t` for extreme cases) */
 typedef int16_t lv_coord_t;
@@ -112,7 +120,7 @@ typedef int16_t lv_coord_t;
 #define LV_INDEV_DEF_DRAG_LIMIT           10
 
 /* Drag throw slow-down in [%]. Greater value -> faster slow-down */
-#define LV_INDEV_DEF_DRAG_THROW           20
+#define LV_INDEV_DEF_DRAG_THROW           10
 
 /* Long press time in milliseconds.
  * Time to send `LV_EVENT_LONG_PRESSSED`) */
@@ -122,6 +130,13 @@ typedef int16_t lv_coord_t;
  * Time between `LV_EVENT_LONG_PRESSED_REPEAT */
 #define LV_INDEV_DEF_LONG_PRESS_REP_TIME  100
 
+
+/* Gesture threshold in pixels */
+#define LV_INDEV_DEF_GESTURE_LIMIT        50
+
+/* Gesture min velocity at release before swipe (pixels)*/
+#define LV_INDEV_DEF_GESTURE_MIN_VELOCITY 3
+
 /*==================
  * Feature usage
  *==================*/
@@ -137,6 +152,22 @@ typedef void * lv_anim_user_data_t;
 
 /* 1: Enable shadow drawing*/
 #define LV_USE_SHADOW           1
+#if LV_USE_SHADOW
+/* Allow buffering some shadow calculation
+ * LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer,
+ * where shadow size is `shadow_width + radius`
+ * Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/
+#define LV_SHADOW_CACHE_SIZE    0
+#endif
+
+/* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
+#define LV_USE_BLEND_MODES      1
+
+/* 1: Use the `opa_scale` style property to set the opacity of an object and its children at once*/
+#define LV_USE_OPA_SCALE        1
+
+/* 1: Use image zoom and rotation*/
+#define LV_USE_IMG_TRANSFORM    1
 
 /* 1: Enable object groups (for keyboard/encoder navigation) */
 #define LV_USE_GROUP            1
@@ -145,7 +176,11 @@ typedef void * lv_group_user_data_t;
 #endif  /*LV_USE_GROUP*/
 
 /* 1: Enable GPU interface*/
-#define LV_USE_GPU              1
+#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
@@ -157,6 +192,12 @@ typedef void * lv_fs_drv_user_data_t;
 /*1: Add a `user_data` to drivers and objects*/
 #define LV_USE_USER_DATA        0
 
+/*1: Show CPU usage and FPS count in the right bottom corner*/
+#define LV_USE_PERF_MONITOR     0
+
+/*1: Use the functions and types from the older API if possible */
+#define LV_USE_API_EXTENSION_V6  1
+
 /*========================
  * Image decoder and cache
  *========================*/
@@ -181,12 +222,19 @@ 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
 
 /* Define a custom attribute to `lv_task_handler` function */
 #define LV_ATTRIBUTE_TASK_HANDLER
 
+/* Define a custom attribute to `lv_disp_flush_ready` function */
+#define LV_ATTRIBUTE_FLUSH_READY
+
 /* With size optimization (-Os) the compiler might not align data to
  * 4 or 8 byte boundary. This alignment will be explicitly applied where needed.
  * E.g. __attribute__((aligned(4))) */
@@ -196,6 +244,10 @@ typedef void * lv_img_decoder_user_data_t;
  * font's bitmaps */
 #define LV_ATTRIBUTE_LARGE_CONST
 
+/* Prefix performance critical functions to place them into a faster memory (e.g RAM)
+ * Uses 15-20 kB extra memory */
+#define LV_ATTRIBUTE_FAST_MEM
+
 /* Export integer constant to binding.
  * This macro is used with constants in the form of LV_<CONST> that
  * should also appear on lvgl binding API such as Micropython
@@ -204,6 +256,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
  *==================*/
@@ -212,8 +268,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*/
@@ -262,6 +318,9 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
 /*Checks is the memory is successfully allocated or no. (Quite fast)*/
 #define LV_USE_ASSERT_MEM       1
 
+/*Check the integrity of `lv_mem` after critical operations. (Slow)*/
+#define LV_USE_ASSERT_MEM_INTEGRITY       0
+
 /* Check the strings.
  * Search for NULL, very long strings, invalid characters, and unnatural repetitions. (Slow)
  * If disabled `LV_USE_ASSERT_NULL` will be performed instead (if it's enabled) */
@@ -272,44 +331,47 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
 #define LV_USE_ASSERT_OBJ       0
 
 /*Check if the styles are properly initialized. (Fast)*/
-#define LV_USE_ASSERT_STYLE     1
+#define LV_USE_ASSERT_STYLE     0
 
 #endif /*LV_USE_DEBUG*/
 
-/*================
- *  THEME USAGE
- *================*/
-#define LV_THEME_LIVE_UPDATE    0   /*1: Allow theme switching at run time. Uses 8..10 kB of RAM*/
-
-#define LV_USE_THEME_TEMPL      0   /*Just for test*/
-#define LV_USE_THEME_DEFAULT    0   /*Built mainly from the built-in styles. Consumes very few RAM*/
-#define LV_USE_THEME_ALIEN      0   /*Dark futuristic theme*/
-#define LV_USE_THEME_NIGHT      0   /*Dark elegant theme*/
-#define LV_USE_THEME_MONO       0   /*Mono color theme for monochrome displays*/
-#define LV_USE_THEME_MATERIAL   0   /*Flat theme with bold colors and light shadows*/
-#define LV_USE_THEME_ZEN        0   /*Peaceful, mainly light theme */
-#define LV_USE_THEME_NEMO       0   /*Water-like theme based on the movie "Finding Nemo"*/
-
 /*==================
  *    FONT USAGE
  *===================*/
 
 /* The built-in fonts contains the ASCII range and some Symbols with  4 bit-per-pixel.
  * The symbols are available via `LV_SYMBOL_...` defines
- * More info about fonts: https://docs.littlevgl.com/#Fonts
- * To create a new font go to: https://littlevgl.com/ttf-font-to-c-array
+ * More info about fonts: https://docs.lvgl.io/v7/en/html/overview/font.html
+ * To create a new font go to: https://lvgl.com/ttf-font-to-c-array
  */
 
-/* Robot fonts with bpp = 4
- * https://fonts.google.com/specimen/Roboto  */
-#define LV_FONT_ROBOTO_12    0
-#define LV_FONT_ROBOTO_16    1
-#define LV_FONT_ROBOTO_22    0
-#define LV_FONT_ROBOTO_28    0
+/* Montserrat fonts with bpp = 4
+ * https://fonts.google.com/specimen/Montserrat  */
+#define LV_FONT_MONTSERRAT_12    0
+#define LV_FONT_MONTSERRAT_14    0
+#define LV_FONT_MONTSERRAT_16    1
+#define LV_FONT_MONTSERRAT_18    0
+#define LV_FONT_MONTSERRAT_20    0
+#define LV_FONT_MONTSERRAT_22    0
+#define LV_FONT_MONTSERRAT_24    0
+#define LV_FONT_MONTSERRAT_26    0
+#define LV_FONT_MONTSERRAT_28    0
+#define LV_FONT_MONTSERRAT_30    0
+#define LV_FONT_MONTSERRAT_32    0
+#define LV_FONT_MONTSERRAT_34    0
+#define LV_FONT_MONTSERRAT_36    0
+#define LV_FONT_MONTSERRAT_38    0
+#define LV_FONT_MONTSERRAT_40    0
+#define LV_FONT_MONTSERRAT_42    0
+#define LV_FONT_MONTSERRAT_44    0
+#define LV_FONT_MONTSERRAT_46    0
+#define LV_FONT_MONTSERRAT_48    0
 
 /* Demonstrate special features */
-#define LV_FONT_ROBOTO_12_SUBPX 1
-#define LV_FONT_ROBOTO_28_COMPRESSED 1  /*bpp = 3*/
+#define LV_FONT_MONTSERRAT_12_SUBPX      0
+#define LV_FONT_MONTSERRAT_28_COMPRESSED 0  /*bpp = 3*/
+#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0  /*Hebrew, Arabic, PErisan letters and all their forms*/
+#define LV_FONT_SIMSUN_16_CJK            0  /*1000 most common CJK radicals*/
 
 /*Pixel perfect monospace font
  * http://pelulamu.net/unscii/ */
@@ -323,9 +385,6 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
  */
 #define LV_FONT_CUSTOM_DECLARE
 
-/*Always set a default font from the built-in fonts*/
-#define LV_FONT_DEFAULT        &lv_font_roboto_16
-
 /* Enable it if you have fonts with a lot of characters.
  * The limit depends on the font size, font face and bpp
  * but with > 10,000 characters if you see issues probably you need to enable it.*/
@@ -340,6 +399,43 @@ typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the i
 /*Declare the type of the user data of fonts (can be e.g. `void *`, `int`, `struct`)*/
 typedef void * lv_font_user_data_t;
 
+/*================
+ *  THEME USAGE
+ *================*/
+
+/*Always enable at least on theme*/
+
+/* No theme, you can apply your styles as you need
+ * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
+ #define LV_USE_THEME_EMPTY       1
+
+/*Simple to the create your theme based on it
+ * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
+ #define LV_USE_THEME_TEMPLATE    1
+
+/* A fast and impressive theme.
+ * Flags:
+ * LV_THEME_MATERIAL_FLAG_LIGHT: light theme
+ * LV_THEME_MATERIAL_FLAG_DARK: dark theme*/
+ #define LV_USE_THEME_MATERIAL    1
+
+/* Mono-color theme for monochrome displays.
+ * If LV_THEME_DEFAULT_COLOR_PRIMARY is LV_COLOR_BLACK the
+ * texts and borders will be black and the background will be
+ * white. Else the colors are inverted.
+ * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
+ #define LV_USE_THEME_MONO        1
+
+#define LV_THEME_DEFAULT_INCLUDE            <stdint.h>      /*Include a header for the init. function*/
+#define LV_THEME_DEFAULT_INIT               lv_theme_material_init
+#define LV_THEME_DEFAULT_COLOR_PRIMARY      lv_color_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
+
 /*=================
  *  Text settings
  *=================*/
@@ -356,7 +452,7 @@ typedef void * lv_font_user_data_t;
 
 /* If a word is at least this long, will break wherever "prettiest"
  * To disable, set to a value <= 0 */
-#define LV_TXT_LINE_BREAK_LONG_LEN          12
+#define LV_TXT_LINE_BREAK_LONG_LEN          0
 
 /* Minimum number of characters in a long word to put on a line before a break.
  * Depends on LV_TXT_LINE_BREAK_LONG_LEN. */
@@ -382,22 +478,38 @@ typedef void * lv_font_user_data_t;
 #define LV_BIDI_BASE_DIR_DEF  LV_BIDI_DIR_AUTO
 #endif
 
+/* Enable Arabic/Persian processing
+ * In these languages characters should be replaced with
+ * an other form based on their position in the text */
+#define LV_USE_ARABIC_PERSIAN_CHARS 0
+
 /*Change the built in (v)snprintf functions*/
 #define LV_SPRINTF_CUSTOM   0
 #if LV_SPRINTF_CUSTOM
 #  define LV_SPRINTF_INCLUDE <stdio.h>
 #  define lv_snprintf     snprintf
 #  define lv_vsnprintf    vsnprintf
+#else   /*!LV_SPRINTF_CUSTOM*/
+#  define LV_SPRINTF_DISABLE_FLOAT 1
 #endif  /*LV_SPRINTF_CUSTOM*/
 
 /*===================
  *  LV_OBJ SETTINGS
  *==================*/
 
+#if LV_USE_USER_DATA
 /*Declare the type of the user data of object (can be e.g. `void *`, `int`, `struct`)*/
 typedef void * lv_obj_user_data_t;
+/*Provide a function to free user data*/
+#define LV_USE_USER_DATA_FREE 0
+#if LV_USE_USER_DATA_FREE
+#  define LV_USER_DATA_FREE_INCLUDE  "something.h"  /*Header for user data free function*/
+/* Function prototype : void user_data_free(lv_obj_t * obj); */
+#  define LV_USER_DATA_FREE  (user_data_free)       /*Invoking for user data free function*/
+#endif
+#endif
 
-/*1: enable `lv_obj_realaign()` based on `lv_obj_align()` parameters*/
+/*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.
@@ -405,13 +517,13 @@ typedef void * lv_obj_user_data_t;
  * LV_EXT_CLICK_AREA_TINY: The extra area can be adjusted horizontally and vertically (0..255 px)
  * LV_EXT_CLICK_AREA_FULL: The extra area can be adjusted in all 4 directions (-32k..+32k px)
  */
-#define LV_USE_EXT_CLICK_AREA  LV_EXT_CLICK_AREA_OFF
+#define LV_USE_EXT_CLICK_AREA  LV_EXT_CLICK_AREA_TINY
 
 /*==================
  *  LV OBJ X USAGE
  *================*/
 /*
- * Documentation of the object types: https://docs.littlevgl.com/#Object-types
+ * Documentation of the object types: https://docs.lvgl.com/#Object-types
  */
 
 /*Arc (dependencies: -)*/
@@ -422,13 +534,9 @@ typedef void * lv_obj_user_data_t;
 
 /*Button (dependencies: lv_cont*/
 #define LV_USE_BTN      1
-#if LV_USE_BTN != 0
-/*Enable button-state animations - draw a circle on click (dependencies: LV_USE_ANIMATION)*/
-#  define LV_BTN_INK_EFFECT   0
-#endif
 
 /*Button matrix (dependencies: -)*/
-#define LV_USE_BTNM     1
+#define LV_USE_BTNMATRIX     1
 
 /*Calendar (dependencies: -)*/
 #define LV_USE_CALENDAR 1
@@ -437,7 +545,7 @@ typedef void * lv_obj_user_data_t;
 #define LV_USE_CANVAS   1
 
 /*Check box (dependencies: lv_btn, lv_label)*/
-#define LV_USE_CB       1
+#define LV_USE_CHECKBOX       1
 
 /*Chart (dependencies: -)*/
 #define LV_USE_CHART    1
@@ -452,13 +560,13 @@ typedef void * lv_obj_user_data_t;
 #define LV_USE_CPICKER   1
 
 /*Drop down list (dependencies: lv_page, lv_label, lv_symbol_def.h)*/
-#define LV_USE_DDLIST    1
-#if LV_USE_DDLIST != 0
+#define LV_USE_DROPDOWN    1
+#if LV_USE_DROPDOWN != 0
 /*Open and close default animation time [ms] (0: no animation)*/
-#  define LV_DDLIST_DEF_ANIM_TIME     200
+#  define LV_DROPDOWN_DEF_ANIM_TIME     200
 #endif
 
-/*Gauge (dependencies:lv_bar, lv_lmeter)*/
+/*Gauge (dependencies:lv_bar, lv_linemeter)*/
 #define LV_USE_GAUGE    1
 
 /*Image (dependencies: lv_label*/
@@ -472,7 +580,7 @@ typedef void * lv_obj_user_data_t;
 #endif
 
 /*Keyboard (dependencies: lv_btnm)*/
-#define LV_USE_KB       1
+#define LV_USE_KEYBOARD       1
 
 /*Label (dependencies: -*/
 #define LV_USE_LABEL    1
@@ -492,6 +600,10 @@ typedef void * lv_obj_user_data_t;
 
 /*LED (dependencies: -)*/
 #define LV_USE_LED      1
+#if LV_USE_LED
+#  define LV_LED_BRIGHT_MIN  120      /*Minimal brightness*/
+#  define LV_LED_BRIGHT_MAX  255     /*Maximal brightness*/
+#endif
 
 /*Line (dependencies: -*/
 #define LV_USE_LINE     1
@@ -504,10 +616,22 @@ typedef void * lv_obj_user_data_t;
 #endif
 
 /*Line meter (dependencies: *;)*/
-#define LV_USE_LMETER   1
+#define LV_USE_LINEMETER   1
+#if LV_USE_LINEMETER
+/* Draw line more precisely at cost of performance.
+ * Useful if there are lot of lines any minor are visible
+ * 0: No extra precision
+ * 1: Some extra precision
+ * 2: Best precision
+ */
+#  define LV_LINEMETER_PRECISE    0
+#endif
+
+/*Mask (dependencies: -)*/
+#define LV_USE_OBJMASK  1
 
 /*Message box (dependencies: lv_rect, lv_btnm, lv_label)*/
-#define LV_USE_MBOX     1
+#define LV_USE_MSGBOX     1
 
 /*Page (dependencies: lv_cont)*/
 #define LV_USE_PAGE     1
@@ -517,11 +641,11 @@ typedef void * lv_obj_user_data_t;
 #endif
 
 /*Preload (dependencies: lv_arc, lv_anim)*/
-#define LV_USE_PRELOAD      1
-#if LV_USE_PRELOAD != 0
-#  define LV_PRELOAD_DEF_ARC_LENGTH   60      /*[deg]*/
-#  define LV_PRELOAD_DEF_SPIN_TIME    1000    /*[ms]*/
-#  define LV_PRELOAD_DEF_ANIM         LV_PRELOAD_TYPE_SPINNING_ARC
+#define LV_USE_SPINNER      1
+#if LV_USE_SPINNER != 0
+#  define LV_SPINNER_DEF_ARC_LENGTH   60      /*[deg]*/
+#  define LV_SPINNER_DEF_SPIN_TIME    1000    /*[ms]*/
+#  define LV_SPINNER_DEF_ANIM         LV_SPINNER_TYPE_SPINNING_ARC
 #endif
 
 /*Roller (dependencies: lv_ddlist)*/
@@ -541,13 +665,13 @@ typedef void * lv_obj_user_data_t;
 #define LV_USE_SPINBOX       1
 
 /*Switch (dependencies: lv_slider)*/
-#define LV_USE_SW       1
+#define LV_USE_SWITCH       1
 
 /*Text area (dependencies: lv_label, lv_page)*/
-#define LV_USE_TA       1
-#if LV_USE_TA != 0
-#  define LV_TA_DEF_CURSOR_BLINK_TIME 400     /*ms*/
-#  define LV_TA_DEF_PWD_SHOW_TIME     1500    /*ms*/
+#define LV_USE_TEXTAREA       1
+#if LV_USE_TEXTAREA != 0
+#  define LV_TEXTAREA_DEF_CURSOR_BLINK_TIME 400     /*ms*/
+#  define LV_TEXTAREA_DEF_PWD_SHOW_TIME     1500    /*ms*/
 #endif
 
 /*Table (dependencies: lv_label)*/
@@ -583,9 +707,6 @@ typedef void * lv_obj_user_data_t;
 
 /*--END OF LV_CONF_H--*/
 
-/*Be sure every define has a default value*/
-#include "lvgl/src/lv_conf_checker.h"
-
 #endif /*LV_CONF_H*/
 
 #endif /*End of "Content enable"*/

lvgl.h

@@ -14,8 +14,6 @@ extern "C" {
  *      INCLUDES
  *********************/
 
-#include "src/lv_version.h"
-
 #include "src/lv_misc/lv_log.h"
 #include "src/lv_misc/lv_task.h"
 #include "src/lv_misc/lv_math.h"
@@ -29,54 +27,59 @@ extern "C" {
 
 #include "src/lv_core/lv_refr.h"
 #include "src/lv_core/lv_disp.h"
-#include "src/lv_core/lv_debug.h"
 
 #include "src/lv_themes/lv_theme.h"
 
 #include "src/lv_font/lv_font.h"
 #include "src/lv_font/lv_font_fmt_txt.h"
-#include "src/lv_misc/lv_bidi.h"
 #include "src/lv_misc/lv_printf.h"
 
-#include "src/lv_objx/lv_btn.h"
-#include "src/lv_objx/lv_imgbtn.h"
-#include "src/lv_objx/lv_img.h"
-#include "src/lv_objx/lv_label.h"
-#include "src/lv_objx/lv_line.h"
-#include "src/lv_objx/lv_page.h"
-#include "src/lv_objx/lv_cont.h"
-#include "src/lv_objx/lv_list.h"
-#include "src/lv_objx/lv_chart.h"
-#include "src/lv_objx/lv_table.h"
-#include "src/lv_objx/lv_cb.h"
-#include "src/lv_objx/lv_cpicker.h"
-#include "src/lv_objx/lv_bar.h"
-#include "src/lv_objx/lv_slider.h"
-#include "src/lv_objx/lv_led.h"
-#include "src/lv_objx/lv_btnm.h"
-#include "src/lv_objx/lv_kb.h"
-#include "src/lv_objx/lv_ddlist.h"
-#include "src/lv_objx/lv_roller.h"
-#include "src/lv_objx/lv_ta.h"
-#include "src/lv_objx/lv_canvas.h"
-#include "src/lv_objx/lv_win.h"
-#include "src/lv_objx/lv_tabview.h"
-#include "src/lv_objx/lv_tileview.h"
-#include "src/lv_objx/lv_mbox.h"
-#include "src/lv_objx/lv_gauge.h"
-#include "src/lv_objx/lv_lmeter.h"
-#include "src/lv_objx/lv_sw.h"
-#include "src/lv_objx/lv_kb.h"
-#include "src/lv_objx/lv_arc.h"
-#include "src/lv_objx/lv_preload.h"
-#include "src/lv_objx/lv_calendar.h"
-#include "src/lv_objx/lv_spinbox.h"
+#include "src/lv_widgets/lv_btn.h"
+#include "src/lv_widgets/lv_imgbtn.h"
+#include "src/lv_widgets/lv_img.h"
+#include "src/lv_widgets/lv_label.h"
+#include "src/lv_widgets/lv_line.h"
+#include "src/lv_widgets/lv_page.h"
+#include "src/lv_widgets/lv_cont.h"
+#include "src/lv_widgets/lv_list.h"
+#include "src/lv_widgets/lv_chart.h"
+#include "src/lv_widgets/lv_table.h"
+#include "src/lv_widgets/lv_checkbox.h"
+#include "src/lv_widgets/lv_cpicker.h"
+#include "src/lv_widgets/lv_bar.h"
+#include "src/lv_widgets/lv_slider.h"
+#include "src/lv_widgets/lv_led.h"
+#include "src/lv_widgets/lv_btnmatrix.h"
+#include "src/lv_widgets/lv_keyboard.h"
+#include "src/lv_widgets/lv_dropdown.h"
+#include "src/lv_widgets/lv_roller.h"
+#include "src/lv_widgets/lv_textarea.h"
+#include "src/lv_widgets/lv_canvas.h"
+#include "src/lv_widgets/lv_win.h"
+#include "src/lv_widgets/lv_tabview.h"
+#include "src/lv_widgets/lv_tileview.h"
+#include "src/lv_widgets/lv_msgbox.h"
+#include "src/lv_widgets/lv_objmask.h"
+#include "src/lv_widgets/lv_gauge.h"
+#include "src/lv_widgets/lv_linemeter.h"
+#include "src/lv_widgets/lv_switch.h"
+#include "src/lv_widgets/lv_arc.h"
+#include "src/lv_widgets/lv_spinner.h"
+#include "src/lv_widgets/lv_calendar.h"
+#include "src/lv_widgets/lv_spinbox.h"
 
 #include "src/lv_draw/lv_img_cache.h"
 
+#include "src/lv_api_map.h"
+
 /*********************
  *      DEFINES
  *********************/
+/*Current version of LVGL*/
+#define LVGL_VERSION_MAJOR   7
+#define LVGL_VERSION_MINOR   1
+#define LVGL_VERSION_PATCH   0
+#define LVGL_VERSION_INFO ""
 
 /**********************
  *      TYPEDEFS
@@ -90,6 +93,30 @@ extern "C" {
  *      MACROS
  **********************/
 
+/** Gives 1 if the x.y.z version is supported in the current version
+ * Usage:
+ *
+ * - Require v6
+ * #if LV_VERSION_CHECK(6,0,0)
+ *   new_func_in_v6();
+ * #endif
+ *
+ *
+ * - Require at least v5.3
+ * #if LV_VERSION_CHECK(5,3,0)
+ *   new_feature_from_v5_3();
+ * #endif
+ *
+ *
+ * - Require v5.3.2 bugfixes
+ * #if LV_VERSION_CHECK(5,3,2)
+ *   bugfix_in_v5_3_2();
+ * #endif
+ *
+ * */
+#define LV_VERSION_CHECK(x,y,z) (x == LVGL_VERSION_MAJOR && (y < LVGL_VERSION_MINOR || (y == LVGL_VERSION_MINOR && z <= LVGL_VERSION_PATCH)))
+
+
 #ifdef __cplusplus
 }
 #endif

lvgl.mk

@@ -1,8 +1,10 @@
-include $(LVGL_DIR)/lvgl/src/lv_core/lv_core.mk
-include $(LVGL_DIR)/lvgl/src/lv_hal/lv_hal.mk
-include $(LVGL_DIR)/lvgl/src/lv_objx/lv_objx.mk
-include $(LVGL_DIR)/lvgl/src/lv_font/lv_font.mk
-include $(LVGL_DIR)/lvgl/src/lv_misc/lv_misc.mk
-include $(LVGL_DIR)/lvgl/src/lv_themes/lv_themes.mk
-include $(LVGL_DIR)/lvgl/src/lv_draw/lv_draw.mk
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_core/lv_core.mk
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_hal/lv_hal.mk
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_widgets/lv_widgets.mk
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_font/lv_font.mk
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_misc/lv_misc.mk
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_themes/lv_themes.mk
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_draw/lv_draw.mk
+include $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_gpu/lv_gpu.mk
+
 

scripts/built_in_font/built_in_font_gen.py

@@ -1,3 +1,5 @@
+#!/usr/bin/env python3.6
+
 import argparse
 from argparse import RawTextHelpFormatter
 import os
@@ -18,12 +20,17 @@ parser.add_argument('--bpp',
 parser.add_argument('-r', '--range', 
 					nargs='+', 
 					metavar = 'start-end', 
-					default='0x20-0x7F', 
+					default=['0x20-0x7F,0xB0,0x2022'], 
 					help='Ranges and/or characters to include. Default is 0x20-7F (ASCII). E.g. -r 0x20-0x7F, 0x200, 324')
+parser.add_argument('--symbols', 
+					nargs='+', 
+					metavar = 'sym', 
+					default=[''],
+					help=u'Symbols to include. E.g. -s ÁÉŐ'.encode('utf-8'))
 parser.add_argument('--font', 
 					metavar = 'file', 
 					nargs='?', 
-					default='Roboto-Regular.woff', 
+					default='Montserrat-Medium.ttf', 
 					help='A TTF or WOFF file')
 parser.add_argument('-o', '--output', 
 					nargs='?', 
@@ -31,6 +38,8 @@ parser.add_argument('-o', '--output',
 					help='Output file name. E.g. my_font_20.c')
 parser.add_argument('--compressed', action='store_true',
                     help='Compress the bitmaps')
+parser.add_argument('--subpx', action='store_true',
+                    help='3 times wider letters for sub pixel rendering')
                     
 args = parser.parse_args()
 
@@ -39,9 +48,12 @@ if args.compressed == False:
 else:
 	compr = ""
 
+if len(args.symbols[0]) != 0:
+	 args.symbols[0] = "--symbols " +  args.symbols[0]
+
 #Built in symbols
 syms = "61441,61448,61451,61452,61452,61453,61457,61459,61461,61465,61468,61473,61478,61479,61480,61502,61512,61515,61516,61517,61521,61522,61523,61524,61543,61544,61550,61552,61553,61556,61559,61560,61561,61563,61587,61589,61636,61637,61639,61671,61674,61683,61724,61732,61787,61931,62016,62017,62018,62019,62020,62087,62099,62212,62189,62810,63426,63650"
 
-#Run the command
-cmd = "lv_font_conv {} --bpp {} --size {} --font Roboto-Regular.woff -r {} --font FontAwesome5-Solid+Brands+Regular.woff -r {} --format lvgl -o {} --force-fast-kern-format".format(compr, args.bpp, args.size, args.range[0], syms, args.output)
+#Run the command (Add degree and bbullet symbol)
+cmd = "lv_font_conv {} --bpp {} --size {} --font {} -r {} {} --font FontAwesome5-Solid+Brands+Regular.woff -r {} --format lvgl -o {} --force-fast-kern-format".format(compr, args.bpp, args.size, args.font, args.range[0], args.symbols[0], syms, args.output)
 os.system(cmd)

scripts/built_in_font/generate_all.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3.6
+
+import os
+
+print("\nGenerating 16 px CJK")
+os.system(u"./built_in_font_gen.py --size 16 -o lv_font_simsun_16_cjk.c --bpp 4 --font SimSun.woff -r 0x20-0x7f --symbols 一在有個我不這了他也就人都說而我們你了要會對及和與以很種的大能著她那上但年還可以最自己為來所他們兩各可為或好等又將因為於由從更被才已者每次把三什麼問題其讓此做再所以只與則台灣卻並位想去呢學生表示到公司將如果社會看小天因此新但是它中使工作全覺得使用這些裡並由於時候知道這樣一認為時間事過向可能中國美國到和幾系統政府大家國家許多生活跟已經大學研究因本二活動該世界應四希望方式內項啊下環境一些必須文化高孩子沒有不能如開始元不同仍網路日本用中心來對雖然重要地方進行關係市場太老師提供學校應該指出經濟其他家發展教育成為多非常便方面很多吃然後未發現電腦一樣而且心不過無法企業正服務較不會臺灣曾嗎空間看到五如何國內們無對於以及之後可是當人員比先產品資訊資料比較先生地除了大陸需要像在給歲請月些名另若亦地區技術至特別其實國際不要發生參加一定其中問台北包括講造成看像常即喜歡去沒出現政治話走單位一直吧是否當然整處理歷史了解那怎麼機會家聽所有只要朋友令甚至用真六呀情況還是錢方法點任何經驗藝術你們十主要媽媽增加提出為什麼以您計畫作利用東西在條設計找之間成長能夠決定學習誰見半時代完成帶相當同學件能力別人生命下來場會議容易開發民眾事情書事實有關自組織言多愛建立相關均產生多業者解決完全的話接受知約一般推動過程管理功能手打水要求小朋友教授難我國告訴內容結果調查家庭成立選擇經營然而父母寫人類至於買尤其配合進入例如得討論依作品情形資源原因啦妳運動觀念給軟體品質經過如此嗯精神影響之過好像成參與以後於是部分另外公園透過訓練努力研究具有共同所謂下行為合作經合作目標起來考慮長意見辦法音樂連受廠商隻受到一切或是中央某女性教學極獲得真的路來快國小部份工程女人舉行句只是段根據現象人民土地面對注意這裡新聞繼續相信政策變成計劃強調學人士前前存在制度意義代表課程該沒至需求人生那些成功爸爸產業負責民間雖影響直接幾乎分實際團體價值使得類形成科技這麼當七不但往本身標準似乎應用或者動物電話態度建設事業老那麼常常字坐舉辦自我有的具目的塊條件即使好十分多少放又電影科學執行邊委員會溝通開一起張針對員工引起自然那麼安全總統此外擁有並且事件設計研究所語言嚴重故事學術片設備之外車基本實在久套達到改善死結構住皆改變拿小組支持座醫院既僅值得學者八交通階段就是申請主管申請同感覺電視母親嘛香港記者壓力快樂喝敢院也許人們談生產怕就身體規定程度積極知識作為機構而是鼓勵角色狀況專家據清楚不僅比賽玩效果越保護共開放附近上父親專業經費曾經工作願意分別重視不少歡迎小孩小時中國人顯示中共出男人避免屬於實施聲音主義行動不可只有校園興趣山表現得回來主任裡面經常不再電子受思想頭終於謝謝協助除當地正式真正低性份因素推出上價格去認識方向責任說明工業大量做逐漸心理一點供須簡單運用觀察往往規劃減少重新業務報導仍然感到開放領域有效女要從事發揮人才反而行政銀行公共媒體提高代自然社區力量啊教育部愈超過維持家長結合校長通常缺乏委員特色結果有時教師之前遠控制本否則法少原則要臉通過建議工具作業達節目智慧來自而變化同樣形式站以為健康擔任人口規劃剛特殊原來道分傳統總是前往投資加強不斷對象追求加上比思考製作台北市取得出來加入台安排兒童國中範圍老人雙方牠北京年輕結束教程式婦女找到彼此全球成本回到部而已之下等變期間非小姐整體採用根本叫歐洲正在加以充滿系列隨著早等等頗不足總分析深報告不錯在於旁笑故消費者意識公尺民族為主大眾到底願度大概對方官員發表進一步自由正確豐富國民黨戰爭怎麼樣只好明顯改革表達肯定強高興哪樹適合茶別國外關心蘇聯成績人物聽到創造不必不論尚居民不管美麗伊拉克帶來有般永遠感情兒子這樣子起全部".encode('utf-8'))
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_simsun_16_cjk.c')
+
+exit()
+
+print("Generating 12 px")
+os.system("./built_in_font_gen.py --size 12 -o lv_font_montserrat_12.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_12.c')
+
+print("\nGenerating 14 px")
+os.system("./built_in_font_gen.py --size 14 -o lv_font_montserrat_14.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_14.c')
+
+print("\nGenerating 16 px")
+os.system("./built_in_font_gen.py --size 16 -o lv_font_montserrat_16.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_16.c')
+
+print("\nGenerating 18 px")
+os.system("./built_in_font_gen.py --size 18 -o lv_font_montserrat_18.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_18.c')
+
+print("\nGenerating 20 px")
+os.system("./built_in_font_gen.py --size 20 -o lv_font_montserrat_20.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_20.c')
+
+print("\nGenerating 22 px")
+os.system("./built_in_font_gen.py --size 22 -o lv_font_montserrat_22.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_22.c')
+
+print("\nGenerating 24 px")
+os.system("./built_in_font_gen.py --size 24 -o lv_font_montserrat_24.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_24.c')
+
+print("\nGenerating 26 px")
+os.system("./built_in_font_gen.py --size 26 -o lv_font_montserrat_26.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_26.c')
+
+print("\nGenerating 28 px")
+os.system("./built_in_font_gen.py --size 28 -o lv_font_montserrat_28.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_28.c')
+
+print("\nGenerating 30 px")
+os.system("./built_in_font_gen.py --size 30 -o lv_font_montserrat_30.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_30.c')
+
+print("\nGenerating 32 px")
+os.system("./built_in_font_gen.py --size 32 -o lv_font_montserrat_32.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_32.c')
+
+print("\nGenerating 34 px")
+os.system("./built_in_font_gen.py --size 34 -o lv_font_montserrat_34.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_34.c')
+
+print("\nGenerating 36 px")
+os.system("./built_in_font_gen.py --size 36 -o lv_font_montserrat_36.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_36.c')
+
+print("\nGenerating 38 px")
+os.system("./built_in_font_gen.py --size 38 -o lv_font_montserrat_38.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_38.c')
+
+print("\nGenerating 40 px")
+os.system("./built_in_font_gen.py --size 40 -o lv_font_montserrat_40.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_40.c')
+
+print("\nGenerating 42 px")
+os.system("./built_in_font_gen.py --size 42 -o lv_font_montserrat_42.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_42.c')
+
+print("\nGenerating 44 px")
+os.system("./built_in_font_gen.py --size 44 -o lv_font_montserrat_44.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_44.c')
+
+print("\nGenerating 46 px")
+os.system("./built_in_font_gen.py --size 46 -o lv_font_montserrat_46.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_46.c')
+
+print("\nGenerating 48 px")
+os.system("./built_in_font_gen.py --size 48 -o lv_font_montserrat_48.c --bpp 4")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_48.c')
+
+print("\nGenerating 12 px subpx")
+os.system("./built_in_font_gen.py --size 12 -o lv_font_montserrat_12_subpx.c --bpp 4 --subpx")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_12_subpx.c')
+
+print("\nGenerating 28 px compressed")
+os.system("./built_in_font_gen.py --size 28 -o lv_font_montserrat_28_compressed.c --bpp 4 --compressed")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_montserrat_28_compressed.c')
+
+print("\nGenerating 16 px CJK")
+os.system(u"./built_in_font_gen.py --size 16 -o lv_font_simsun_16_cjk.c --bpp 4 --font SimSun.woff -r 0x20-0x7f --symbols 一在有個我不這了他也就人都說而我們你了要會對及和與以很種的大能著她那上但年還可以最自己為來所他們兩各可為或好等又將因為於由從更被才已者每次把三什麼問題其讓此做再所以只與則台灣卻並位想去呢學生表示到公司將如果社會看小天因此新但是它中使工作全覺得使用這些裡並由於時候知道這樣一認為時間事過向可能中國美國到和幾系統政府大家國家許多生活跟已經大學研究因本二活動該世界應四希望方式內項啊下環境一些必須文化高孩子沒有不能如開始元不同仍網路日本用中心來對雖然重要地方進行關係市場太老師提供學校應該指出經濟其他家發展教育成為多非常便方面很多吃然後未發現電腦一樣而且心不過無法企業正服務較不會臺灣曾嗎空間看到五如何國內們無對於以及之後可是當人員比先產品資訊資料比較先生地除了大陸需要像在給歲請月些名另若亦地區技術至特別其實國際不要發生參加一定其中問台北包括講造成看像常即喜歡去沒出現政治話走單位一直吧是否當然整處理歷史了解那怎麼機會家聽所有只要朋友令甚至用真六呀情況還是錢方法點任何經驗藝術你們十主要媽媽增加提出為什麼以您計畫作利用東西在條設計找之間成長能夠決定學習誰見半時代完成帶相當同學件能力別人生命下來場會議容易開發民眾事情書事實有關自組織言多愛建立相關均產生多業者解決完全的話接受知約一般推動過程管理功能手打水要求小朋友教授難我國告訴內容結果調查家庭成立選擇經營然而父母寫人類至於買尤其配合進入例如得討論依作品情形資源原因啦妳運動觀念給軟體品質經過如此嗯精神影響之過好像成參與以後於是部分另外公園透過訓練努力研究具有共同所謂下行為合作經合作目標起來考慮長意見辦法音樂連受廠商隻受到一切或是中央某女性教學極獲得真的路來快國小部份工程女人舉行句只是段根據現象人民土地面對注意這裡新聞繼續相信政策變成計劃強調學人士前前存在制度意義代表課程該沒至需求人生那些成功爸爸產業負責民間雖影響直接幾乎分實際團體價值使得類形成科技這麼當七不但往本身標準似乎應用或者動物電話態度建設事業老那麼常常字坐舉辦自我有的具目的塊條件即使好十分多少放又電影科學執行邊委員會溝通開一起張針對員工引起自然那麼安全總統此外擁有並且事件設計研究所語言嚴重故事學術片設備之外車基本實在久套達到改善死結構住皆改變拿小組支持座醫院既僅值得學者八交通階段就是申請主管申請同感覺電視母親嘛香港記者壓力快樂喝敢院也許人們談生產怕就身體規定程度積極知識作為機構而是鼓勵角色狀況專家據清楚不僅比賽玩效果越保護共開放附近上父親專業經費曾經工作願意分別重視不少歡迎小孩小時中國人顯示中共出男人避免屬於實施聲音主義行動不可只有校園興趣山表現得回來主任裡面經常不再電子受思想頭終於謝謝協助除當地正式真正低性份因素推出上價格去認識方向責任說明工業大量做逐漸心理一點供須簡單運用觀察往往規劃減少重新業務報導仍然感到開放領域有效女要從事發揮人才反而行政銀行公共媒體提高代自然社區力量啊教育部愈超過維持家長結合校長通常缺乏委員特色結果有時教師之前遠控制本否則法少原則要臉通過建議工具作業達節目智慧來自而變化同樣形式站以為健康擔任人口規劃剛特殊原來道分傳統總是前往投資加強不斷對象追求加上比思考製作台北市取得出來加入台安排兒童國中範圍老人雙方牠北京年輕結束教程式婦女找到彼此全球成本回到部而已之下等變期間非小姐整體採用根本叫歐洲正在加以充滿系列隨著早等等頗不足總分析深報告不錯在於旁笑故消費者意識公尺民族為主大眾到底願度大概對方官員發表進一步自由正確豐富國民黨戰爭怎麼樣只好明顯改革表達肯定強高興哪樹適合茶別國外關心蘇聯成績人物聽到創造不必不論尚居民不管美麗伊拉克帶來有般永遠感情兒子這樣子起全部".encode('utf-8'))
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_simsun_16_cjk.c')
+
+print("Generating 16 px Hebrew, Persian")
+os.system("./built_in_font_gen.py --size 16 -o lv_font_dejavu_16_persian_hebrew.c --bpp 4 --font DejaVuSans.ttf -r 0x20-0x7f,0x5d0-0x5ea,0x600-0x6FF,0xFB50-0xFDFF,0xFE70-0xFEFF")
+os.system('sed -i \'s|#include "lvgl/lvgl.h"|#include "../../lvgl.h"|\' lv_font_dejavu_16_persian_hebrew.c')
+
+

scripts/clang-formatter.sh

@@ -1,13 +0,0 @@
-clang-format-7 -style=file ../src/lv_core/*.c -i
-clang-format-7 -style=file ../src/lv_draw/*.c -i
-clang-format-7 -style=file ../src/lv_hal/*.c -i
-clang-format-7 -style=file ../src/lv_misc/*.c -i
-clang-format-7 -style=file ../src/lv_objx/*.c -i
-clang-format-7 -style=file ../src/lv_themes/*.c -i
-
-clang-format-7 -style=file ../src/lv_core/*.h -i
-clang-format-7 -style=file ../src/lv_draw/*.h -i
-clang-format-7 -style=file ../src/lv_hal/*.h -i
-clang-format-7 -style=file ../src/lv_misc/*.h -i
-clang-format-7 -style=file ../src/lv_objx/*.h -i
-clang-format-7 -style=file ../src/lv_themes/*.h -i

scripts/code-format.cfg

@@ -0,0 +1,50 @@
+--style=kr
+--indent=spaces=4
+--indent-classes
+--indent-switches
+--indent-cases
+--indent-preproc-block
+--indent-preproc-define
+--indent-col1-comments
+--pad-oper
+--unpad-paren
+--align-pointer=middle
+--align-reference=middle
+--convert-tabs
+--max-code-length=120
+--break-after-logical
+--break-closing-braces
+--attach-closing-while
+--min-conditional-indent=0
+--max-continuation-indent=120
+--mode=c
+--lineend=linux
+--recursive
+--suffix=none
+--preserve-date
+--formatted
+--exclude=lv_conf_internal.h 
+--exclude=../src/lv_font/lv_font_montserrat_12.c
+--exclude=../src/lv_font/lv_font_montserrat_14.c
+--exclude=../src/lv_font/lv_font_montserrat_16.c
+--exclude=../src/lv_font/lv_font_montserrat_18.c
+--exclude=../src/lv_font/lv_font_montserrat_20.c
+--exclude=../src/lv_font/lv_font_montserrat_22.c
+--exclude=../src/lv_font/lv_font_montserrat_24.c
+--exclude=../src/lv_font/lv_font_montserrat_26.c
+--exclude=../src/lv_font/lv_font_montserrat_28.c
+--exclude=../src/lv_font/lv_font_montserrat_30.c
+--exclude=../src/lv_font/lv_font_montserrat_32.c
+--exclude=../src/lv_font/lv_font_montserrat_34.c
+--exclude=../src/lv_font/lv_font_montserrat_36.c
+--exclude=../src/lv_font/lv_font_montserrat_38.c
+--exclude=../src/lv_font/lv_font_montserrat_40.c
+--exclude=../src/lv_font/lv_font_montserrat_42.c
+--exclude=../src/lv_font/lv_font_montserrat_44.c
+--exclude=../src/lv_font/lv_font_montserrat_46.c
+--exclude=../src/lv_font/lv_font_montserrat_48.c
+--exclude=../src/lv_font/lv_font_montserrat_12_subpx.c
+--exclude=../src/lv_font/lv_font_montserrat_28_compressed.c
+--exclude=../src/lv_font/lv_font_simsun_16_cjk.c
+--exclude=../src/lv_font/lv_font_dejavu_16_persian_hebrew.c
+

scripts/code-format.sh

@@ -0,0 +1 @@
+astyle --options=code-format.cfg "../src/*.c,*.h"

scripts/cppcheck_run.sh

@@ -1,2 +1,2 @@
-cppcheck --template="{severity}\t{file}:{line}\t{id}: {message}" --enable=all ../src/ --output-file=cppcheck_res.txt --suppress=unusedFunction --suppress=preprocessorErrorDirective --force
+cppcheck -j8 --template="{severity}\t{file}:{line}\t{id}: {message}" --enable=all ../src/ --output-file=cppcheck_res.txt --suppress=unusedFunction --suppress=preprocessorErrorDirective --force
     

scripts/infer_run.sh

@@ -0,0 +1,10 @@
+# https://github.com/facebook/infer
+#
+# Install: 
+# VERSION=0.17.0; \
+# curl -sSL "https://github.com/facebook/infer/releases/download/v$VERSION/infer-linux64-v$VERSION.tar.xz" \
+# | sudo tar -C /opt -xJ && \
+# sudoln -s "/opt/infer-linux64-v$VERSION/bin/infer" /usr/local/bin/infer
+
+
+infer run -- make -j8

scripts/lv_conf_checker.py

@@ -1,25 +1,46 @@
-#!/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_checker.h", "w")
+fout = open("../src/lv_conf_internal.h", "w")
 
 
 fout.write(
 '''/**
  * GENERATED FILE, DO NOT EDIT IT!
- * @file lv_conf_checker.h
+ * @file lv_conf_internal.h
  * Make sure all the defines of lv_conf.h have a default value
 **/
 
-#ifndef LV_CONF_CHECKER_H
-#define LV_CONF_CHECKER_H
+#ifndef LV_CONF_INTERNAL_H
+#define LV_CONF_INTERNAL_H
+/* clang-format off */
+
+#include <stdint.h>
+
+#if defined(LV_CONF_PATH)
+#define __LV_TO_STR_AUX(x) #x
+#define __LV_TO_STR(x) __LV_TO_STR_AUX(x)
+#include __LV_TO_STR(LV_CONF_PATH)
+#undef __LV_TO_STR_AUX
+#undef __LV_TO_STR
+#elif defined(LV_CONF_INCLUDE_SIMPLE)
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
 '''
 )
 

scripts/release.py

@@ -11,29 +11,28 @@ def title(t):
    
 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)
-
+	r = os.system(c)		   
+  if r:
+    print("Exit due to previous error")
+    exit(r)
 
 def lvgl_clone():
 	title("lvgl: Clone")
-	cmd("git clone https://github.com/littlevgl/lvgl.git")
+	cmd("git clone https://github.com/lvgl/lvgl.git")
 	os.chdir("./lvgl")
 	cmd("git co master") 
 
+def lvgl_format():
+  title("lvgl: Run code formatter")
+  os.chdir("./scripts")
+  cmd("./code-format.sh")
+  cmd("git ci -am 'Run code formatter'")
+  os.chdir("..")
+
 def lvgl_update_version():
 	title("lvgl: Update version number")
 
-	f = open("./src/lv_version.h", "r")
+	f = open("./lvgl.h", "r")
 		  
 	outbuf = ""
 	major_ver = -1
@@ -53,7 +52,8 @@ def lvgl_update_version():
 		  
 		r = re.search(r'^#define LVGL_VERSION_PATCH ', i)
 		if r: 
-		  i, patch_ver = increment(i)
+		  m = lastNum.search(i)
+		  if m: patch_ver = m.group(1)
 		 
 		  
 		r = re.search(r'^#define LVGL_VERSION_INFO ', i)
@@ -64,7 +64,7 @@ def lvgl_update_version():
 	 
 	f.close()
 
-	f = open("./src/lv_version.h", "w")
+	f = open("./lvgl.h", "w")
 		  
 	f.write(outbuf)
 	f.close()
@@ -96,6 +96,11 @@ def lvgl_update_library_json(v):
 	f.write(outbuf)
 	f.close()
 
+def lvgl_update_lv_conf_templ(ver_str):
+	title("lvgl: Update version number in lv_conf_template.h")
+	cmd("sed -i -r 's/v[0-9]+\.[0-9]+\.[0-9]+/"+ ver_str +"/' lv_conf_template.h ")
+
+
 def lvgl_commit_push(v):
 	title("lvgl: commit and push release")
 
@@ -104,25 +109,78 @@ def lvgl_commit_push(v):
 	cmd('git push origin master')
 	cmd('git push origin ' + v)
 
+
+def lvgl_merge_to_release_branch(v):
+	title("lvgl: merge to release branch")
+	cmd('git co release/v7')
+	cmd('git merge master')
+	cmd('git push origin release/v7')
+	os.chdir("../")
+	
+	
 def lvgl_update_api_docs():
 	title("lvgl: Update API with Doxygen")
 
 	cmd("cd scripts; doxygen");
 
 
+def examples_clone():
+	title("examples: Clone")
+	cmd("git clone https://github.com/lvgl/lv_examples.git")
+	os.chdir("./lv_examples")
+	cmd("git co master") 
+
+def examples_commit_push(v):
+	title("examples: commit and push release")
+
+	cmd('git ci -am "Release ' + v + '"')
+	cmd('git tag -a ' + v + ' -m "Release ' + v +'"')
+	cmd('git push origin master')
+	cmd('git push origin ' + v)
+
+
+def examples_merge_to_release_branch(v):
+	title("examples: merge to release branch")
+	cmd('git co release/v7')
+	cmd('git merge master')
+	cmd('git push origin release/v7')
+	os.chdir("../")
+	
+	
+def drivers_clone():
+	title("drivers: Clone")
+	cmd("git clone https://github.com/lvgl/lv_drivers.git")
+	os.chdir("./lv_drivers")
+	cmd("git co master") 
+
+def drivers_commit_push(v):
+	title("drivers: commit and push release")
+
+	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 drivers_merge_to_release_branch(v):
+	title("drivers: merge to release branch")
+	cmd('git co release/v7')
+	cmd('git merge master')
+	cmd('git push origin release/v7')
+	os.chdir("../")
+
 def docs_clone():
 	title("docs: Clone")
-	os.chdir("../")
-	cmd("git clone --recursive https://github.com/littlevgl/docs.git")
+	cmd("git clone --recursive https://github.com/lvgl/docs.git")
 	os.chdir("./docs")
-	cmd("git co master") 
 
 def docs_get_api():
 	title("docs: Get API files")
 	
+	cmd("git co latest") 
 	cmd("rm -rf xml");	
-	cmd("cp -r ../lvgl/docs/api_doc/xml .");	
-
+	cmd("cp -r ../../lvgl/docs/api_doc/xml .");	
+	cmd("git add xml");
+	cmd('git commit -m "update API"')	
 
 def docs_update_version(v):
 	title("docs: Update version number")
@@ -148,6 +206,8 @@ def docs_update_version(v):
 		  
 	f.write(outbuf)
 	f.close()
+	cmd("git add conf.py")
+	cmd('git ci -m "update conf.py to ' + v '"')
 
 def docs_update_trans():
 	title("docs: Update translations")
@@ -155,35 +215,35 @@ def docs_update_trans():
 
 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)
+	cmd("git checkout master")
+	cmd("./update.py latest")
 	
 def clean_up():
 	title("Clean up repos")
-	os.chdir("..")
-	cmd("rm -rf lvgl docs")
+	os.chdir("../..")
+	cmd("rm -rf lvgl docs lv_examples lv_drivers")
 
 lvgl_clone()
+lvgl_format()
 lvgl_update_api_docs()
 ver_str = lvgl_update_version()    
 lvgl_update_library_json(ver_str)  
+lvgl_update_lv_conf_templ(ver_str)
 lvgl_commit_push(ver_str)
+lvgl_merge_to_release_branch(ver_str)
+
+examples_clone()
+examples_commit_push(ver_str)
+examples_merge_to_release_branch(ver_str)
+
+drivers_clone()
+drivers_commit_push(ver_str)
+drivers_merge_to_release_branch(ver_str)
 
 docs_clone()
 docs_get_api()
 docs_update_version(ver_str)
-docs_update_trans()
+#docs_update_trans() # Zanata is not working now
 docs_build()    
-docs_commit_push(ver_str)
 
 clean_up()
-    

src/lv_api_map.h

@@ -0,0 +1,198 @@
+/**
+ * @file lv_api_map.h
+ *
+ */
+
+#ifndef LV_API_MAP_H
+#define LV_API_MAP_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/*---------------------
+ * V6.0 COMPATIBILITY
+ *--------------------*/
+#if LV_USE_API_EXTENSION_V6
+
+static inline void lv_task_once(lv_task_t * task)
+{
+    lv_task_set_repeat_count(task, 1);
+}
+
+#if LV_USE_CHECKBOX
+
+#define lv_checkbox_set_static_text lv_checkbox_set_text_static
+
+#endif
+
+#if LV_USE_CHART
+
+#define lv_chart_get_point_cnt lv_chart_get_point_count
+
+#endif
+
+
+#if LV_USE_DROPDOWN
+
+static inline void lv_dropdown_set_draw_arrow(lv_obj_t * ddlist, bool en)
+{
+    if(en) lv_dropdown_set_symbol(ddlist, LV_SYMBOL_DOWN);
+    else lv_dropdown_set_symbol(ddlist, NULL);
+}
+
+static inline bool lv_dropdown_get_draw_arrow(lv_obj_t * ddlist)
+{
+    if(lv_dropdown_get_symbol(ddlist)) return true;
+    else return false;
+}
+
+#define lv_dropdown_set_static_options lv_dropdown_set_options_static
+
+#endif
+
+#if LV_USE_BAR
+
+/**
+ * Make the bar symmetric to zero. The indicator will grow from zero instead of the minimum
+ * position.
+ * @param bar pointer to a bar object
+ * @param en true: enable disable symmetric behavior; false: disable
+ * @deprecated As of v7.0, you should use `lv_bar_set_type` instead.
+ */
+static inline void lv_bar_set_sym(lv_obj_t * bar, bool en)
+{
+    if(en)
+        lv_bar_set_type(bar, LV_BAR_TYPE_SYMMETRICAL);
+    else
+        lv_bar_set_type(bar, LV_BAR_TYPE_NORMAL);
+}
+
+/**
+ * Get whether the bar is symmetric or not.
+ * @param bar pointer to a bar object
+ * @return true: symmetric is enabled; false: disable
+ * @deprecated As of v7.0, you should use `lv_bar_get_type` instead.
+ */
+static inline bool lv_bar_get_sym(lv_obj_t * bar)
+{
+    return lv_bar_get_type(bar) == LV_BAR_TYPE_SYMMETRICAL;
+}
+
+#endif
+
+#if LV_USE_LABEL
+
+#define lv_label_set_static_text lv_label_set_text_static
+
+#endif
+
+#if LV_USE_SLIDER
+
+/**
+ * Make the slider symmetric to zero. The indicator will grow from zero instead of the minimum
+ * position.
+ * @param slider pointer to a bar object
+ * @param en true: enable disable symmetric behavior; false: disable
+ * @deprecated As of v7.0, you should use `lv_slider_set_type` instead.
+ */
+static inline void lv_slider_set_sym(lv_obj_t * slider, bool en)
+{
+    lv_bar_set_sym(slider, en);
+}
+
+/**
+ * Get whether the slider is symmetric or not.
+ * @param slider pointer to a slider object
+ * @return true: symmetric is enabled; false: disable
+ * @deprecated As of v7.0, you should use `lv_slider_get_type` instead.
+ */
+static inline bool lv_slider_get_sym(lv_obj_t * slider)
+{
+    return lv_bar_get_sym(slider);
+}
+
+#endif
+
+#if LV_USE_ROLLER
+
+/**
+ * Set a fixed width for the roller.
+ * @param roller pointer to a roller object
+ * @param w width
+ * @deprecated As of v7.0, you should use `lv_roller_set_auto_fit` and set the width normally instead.
+ */
+static inline void lv_roller_set_fix_width(lv_obj_t * roller, lv_coord_t w)
+{
+    lv_roller_set_auto_fit(roller, false);
+    lv_obj_set_width(roller, w);
+}
+
+
+#endif
+
+
+#if LV_USE_PAGE
+#define lv_scrlbar_mode_t lv_scrollbar_mode_t
+
+#define LV_SCRLBAR_MODE_OFF    LV_SCROLLBAR_MODE_OFF
+#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
+#define LV_SCRLBAR_MODE_UNHIDE LV_SCROLLBAR_MODE_UNHIDE
+
+
+static inline void lv_page_set_scrlbar_mode(lv_obj_t * page, lv_scrlbar_mode_t sb_mode)
+{
+    lv_page_set_scrollbar_mode(page, sb_mode);
+}
+static inline lv_scrollbar_mode_t lv_page_get_scrlbar_mode(lv_obj_t * page)
+{
+    return lv_page_get_scrollbar_mode(page);
+}
+
+
+static inline lv_obj_t * lv_page_get_scrl(lv_obj_t * page)
+{
+    return lv_page_get_scrollable(page);
+}
+#endif
+
+#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
+
+#endif /*LV_USE_API_EXTENSION_V6*/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_API_MAP_H*/

src/lv_conf_internal.h

@@ -1,11 +1,27 @@
 /**
  * GENERATED FILE, DO NOT EDIT IT!
- * @file lv_conf_checker.h
+ * @file lv_conf_internal.h
  * Make sure all the defines of lv_conf.h have a default value
 **/
 
-#ifndef LV_CONF_CHECKER_H
-#define LV_CONF_CHECKER_H
+#ifndef LV_CONF_INTERNAL_H
+#define LV_CONF_INTERNAL_H
+/* clang-format off */
+
+#include <stdint.h>
+
+#if defined(LV_CONF_PATH)
+#define __LV_TO_STR_AUX(x) #x
+#define __LV_TO_STR(x) __LV_TO_STR_AUX(x)
+#include __LV_TO_STR(LV_CONF_PATH)
+#undef __LV_TO_STR_AUX
+#undef __LV_TO_STR
+#elif defined(LV_CONF_INCLUDE_SIMPLE)
+#include "lv_conf.h"
+#else
+#include "../../lv_conf.h"
+#endif
+
 /* clang-format off */
 
 #include <stdint.h>
@@ -24,7 +40,7 @@
 
 /* Color depth:
  * - 1:  1 byte per pixel
- * - 8:  RGB233
+ * - 8:  RGB332
  * - 16: RGB565
  * - 32: ARGB8888
  */
@@ -50,11 +66,6 @@
 #define LV_COLOR_TRANSP    LV_COLOR_LIME         /*LV_COLOR_LIME: pure green*/
 #endif
 
-/* Enable chroma keying for indexed images. */
-#ifndef LV_INDEXED_CHROMA
-#define LV_INDEXED_CHROMA    1
-#endif
-
 /* Enable anti-aliasing (lines, and radiuses will be smoothed) */
 #ifndef LV_ANTIALIAS
 #define LV_ANTIALIAS        1
@@ -70,7 +81,24 @@
  * E.g. a button with width = LV_DPI / 2 -> half inch wide
  * (Not so important, you can adjust it to modify default sizes and spaces)*/
 #ifndef LV_DPI
-#define LV_DPI              100     /*[px]*/
+#define LV_DPI              130     /*[px]*/
+#endif
+
+/* The the real width of the display changes some default values:
+ * default object sizes, layout of examples, etc.
+ * According to the width of the display (hor. res. / dpi)
+ * the displays fall in 4 categories.
+ * The 4th is extra large which has no upper limit so not listed here
+ * The upper limit of the categories are set below in 0.1 inch unit.
+ */
+#ifndef LV_DISP_SMALL_LIMIT
+#define LV_DISP_SMALL_LIMIT  30
+#endif
+#ifndef LV_DISP_MEDIUM_LIMIT
+#define LV_DISP_MEDIUM_LIMIT 50
+#endif
+#ifndef LV_DISP_LARGE_LIMIT
+#define LV_DISP_LARGE_LIMIT  70
 #endif
 
 /* Type of coordinates. Should be `int16_t` (or `int32_t` for extreme cases) */
@@ -155,7 +183,7 @@
 
 /* Drag throw slow-down in [%]. Greater value -> faster slow-down */
 #ifndef LV_INDEV_DEF_DRAG_THROW
-#define LV_INDEV_DEF_DRAG_THROW           20
+#define LV_INDEV_DEF_DRAG_THROW           10
 #endif
 
 /* Long press time in milliseconds.
@@ -170,6 +198,17 @@
 #define LV_INDEV_DEF_LONG_PRESS_REP_TIME  100
 #endif
 
+
+/* Gesture threshold in pixels */
+#ifndef LV_INDEV_DEF_GESTURE_LIMIT
+#define LV_INDEV_DEF_GESTURE_LIMIT        50
+#endif
+
+/* Gesture min velocity at release before swipe (pixels)*/
+#ifndef LV_INDEV_DEF_GESTURE_MIN_VELOCITY
+#define LV_INDEV_DEF_GESTURE_MIN_VELOCITY 3
+#endif
+
 /*==================
  * Feature usage
  *==================*/
@@ -188,6 +227,30 @@
 #ifndef LV_USE_SHADOW
 #define LV_USE_SHADOW           1
 #endif
+#if LV_USE_SHADOW
+/* Allow buffering some shadow calculation
+ * LV_SHADOW_CACHE_SIZE is the max. shadow size to buffer,
+ * where shadow size is `shadow_width + radius`
+ * Caching has LV_SHADOW_CACHE_SIZE^2 RAM cost*/
+#ifndef LV_SHADOW_CACHE_SIZE
+#define LV_SHADOW_CACHE_SIZE    0
+#endif
+#endif
+
+/* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
+#ifndef LV_USE_BLEND_MODES
+#define LV_USE_BLEND_MODES      1
+#endif
+
+/* 1: Use the `opa_scale` style property to set the opacity of an object and its children at once*/
+#ifndef LV_USE_OPA_SCALE
+#define LV_USE_OPA_SCALE        1
+#endif
+
+/* 1: Use image zoom and rotation*/
+#ifndef LV_USE_IMG_TRANSFORM
+#define LV_USE_IMG_TRANSFORM    1
+#endif
 
 /* 1: Enable object groups (for keyboard/encoder navigation) */
 #ifndef LV_USE_GROUP
@@ -198,7 +261,15 @@
 
 /* 1: Enable GPU interface*/
 #ifndef LV_USE_GPU
-#define LV_USE_GPU              1
+#define LV_USE_GPU              1   /*Only enables `gpu_fill_cb` and `gpu_blend_cb` in the disp. drv- */
+#endif
+#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 */
@@ -214,6 +285,16 @@
 #define LV_USE_USER_DATA        0
 #endif
 
+/*1: Show CPU usage and FPS count in the right bottom corner*/
+#ifndef LV_USE_PERF_MONITOR
+#define LV_USE_PERF_MONITOR     0
+#endif
+
+/*1: Use the functions and types from the older API if possible */
+#ifndef LV_USE_API_EXTENSION_V6
+#define LV_USE_API_EXTENSION_V6  1
+#endif
+
 /*========================
  * Image decoder and cache
  *========================*/
@@ -243,6 +324,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
@@ -253,6 +340,11 @@
 #define LV_ATTRIBUTE_TASK_HANDLER
 #endif
 
+/* Define a custom attribute to `lv_disp_flush_ready` function */
+#ifndef LV_ATTRIBUTE_FLUSH_READY
+#define LV_ATTRIBUTE_FLUSH_READY
+#endif
+
 /* With size optimization (-Os) the compiler might not align data to
  * 4 or 8 byte boundary. This alignment will be explicitly applied where needed.
  * E.g. __attribute__((aligned(4))) */
@@ -266,6 +358,12 @@
 #define LV_ATTRIBUTE_LARGE_CONST
 #endif
 
+/* Prefix performance critical functions to place them into a faster memory (e.g RAM)
+ * Uses 15-20 kB extra memory */
+#ifndef LV_ATTRIBUTE_FAST_MEM
+#define LV_ATTRIBUTE_FAST_MEM
+#endif
+
 /* Export integer constant to binding.
  * This macro is used with constants in the form of LV_<CONST> that
  * should also appear on lvgl binding API such as Micropython
@@ -276,6 +374,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
  *==================*/
@@ -287,10 +391,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*/
 
@@ -350,6 +454,11 @@
 #define LV_USE_ASSERT_MEM       1
 #endif
 
+/*Check the integrity of `lv_mem` after critical operations. (Slow)*/
+#ifndef LV_USE_ASSERT_MEM_INTEGRITY
+#define LV_USE_ASSERT_MEM_INTEGRITY       0
+#endif
+
 /* Check the strings.
  * Search for NULL, very long strings, invalid characters, and unnatural repetitions. (Slow)
  * If disabled `LV_USE_ASSERT_NULL` will be performed instead (if it's enabled) */
@@ -365,74 +474,93 @@
 
 /*Check if the styles are properly initialized. (Fast)*/
 #ifndef LV_USE_ASSERT_STYLE
-#define LV_USE_ASSERT_STYLE     1
+#define LV_USE_ASSERT_STYLE     0
 #endif
 
 #endif /*LV_USE_DEBUG*/
 
-/*================
- *  THEME USAGE
- *================*/
-#ifndef LV_THEME_LIVE_UPDATE
-#define LV_THEME_LIVE_UPDATE    0   /*1: Allow theme switching at run time. Uses 8..10 kB of RAM*/
-#endif
-
-#ifndef LV_USE_THEME_TEMPL
-#define LV_USE_THEME_TEMPL      0   /*Just for test*/
-#endif
-#ifndef LV_USE_THEME_DEFAULT
-#define LV_USE_THEME_DEFAULT    0   /*Built mainly from the built-in styles. Consumes very few RAM*/
-#endif
-#ifndef LV_USE_THEME_ALIEN
-#define LV_USE_THEME_ALIEN      0   /*Dark futuristic theme*/
-#endif
-#ifndef LV_USE_THEME_NIGHT
-#define LV_USE_THEME_NIGHT      0   /*Dark elegant theme*/
-#endif
-#ifndef LV_USE_THEME_MONO
-#define LV_USE_THEME_MONO       0   /*Mono color theme for monochrome displays*/
-#endif
-#ifndef LV_USE_THEME_MATERIAL
-#define LV_USE_THEME_MATERIAL   0   /*Flat theme with bold colors and light shadows*/
-#endif
-#ifndef LV_USE_THEME_ZEN
-#define LV_USE_THEME_ZEN        0   /*Peaceful, mainly light theme */
-#endif
-#ifndef LV_USE_THEME_NEMO
-#define LV_USE_THEME_NEMO       0   /*Water-like theme based on the movie "Finding Nemo"*/
-#endif
-
 /*==================
  *    FONT USAGE
  *===================*/
 
 /* The built-in fonts contains the ASCII range and some Symbols with  4 bit-per-pixel.
  * The symbols are available via `LV_SYMBOL_...` defines
- * More info about fonts: https://docs.littlevgl.com/#Fonts
- * To create a new font go to: https://littlevgl.com/ttf-font-to-c-array
+ * More info about fonts: https://docs.lvgl.io/v7/en/html/overview/font.html
+ * To create a new font go to: https://lvgl.com/ttf-font-to-c-array
  */
 
-/* Robot fonts with bpp = 4
- * https://fonts.google.com/specimen/Roboto  */
-#ifndef LV_FONT_ROBOTO_12
-#define LV_FONT_ROBOTO_12    0
+/* Montserrat fonts with bpp = 4
+ * https://fonts.google.com/specimen/Montserrat  */
+#ifndef LV_FONT_MONTSERRAT_12
+#define LV_FONT_MONTSERRAT_12    0
 #endif
-#ifndef LV_FONT_ROBOTO_16
-#define LV_FONT_ROBOTO_16    1
+#ifndef LV_FONT_MONTSERRAT_14
+#define LV_FONT_MONTSERRAT_14    0
 #endif
-#ifndef LV_FONT_ROBOTO_22
-#define LV_FONT_ROBOTO_22    0
+#ifndef LV_FONT_MONTSERRAT_16
+#define LV_FONT_MONTSERRAT_16    1
 #endif
-#ifndef LV_FONT_ROBOTO_28
-#define LV_FONT_ROBOTO_28    0
+#ifndef LV_FONT_MONTSERRAT_18
+#define LV_FONT_MONTSERRAT_18    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_20
+#define LV_FONT_MONTSERRAT_20    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_22
+#define LV_FONT_MONTSERRAT_22    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_24
+#define LV_FONT_MONTSERRAT_24    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_26
+#define LV_FONT_MONTSERRAT_26    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_28
+#define LV_FONT_MONTSERRAT_28    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_30
+#define LV_FONT_MONTSERRAT_30    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_32
+#define LV_FONT_MONTSERRAT_32    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_34
+#define LV_FONT_MONTSERRAT_34    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_36
+#define LV_FONT_MONTSERRAT_36    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_38
+#define LV_FONT_MONTSERRAT_38    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_40
+#define LV_FONT_MONTSERRAT_40    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_42
+#define LV_FONT_MONTSERRAT_42    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_44
+#define LV_FONT_MONTSERRAT_44    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_46
+#define LV_FONT_MONTSERRAT_46    0
+#endif
+#ifndef LV_FONT_MONTSERRAT_48
+#define LV_FONT_MONTSERRAT_48    0
 #endif
 
 /* Demonstrate special features */
-#ifndef LV_FONT_ROBOTO_12_SUBPX
-#define LV_FONT_ROBOTO_12_SUBPX 1
+#ifndef LV_FONT_MONTSERRAT_12_SUBPX
+#define LV_FONT_MONTSERRAT_12_SUBPX      0
 #endif
-#ifndef LV_FONT_ROBOTO_28_COMPRESSED
-#define LV_FONT_ROBOTO_28_COMPRESSED 1  /*bpp = 3*/
+#ifndef LV_FONT_MONTSERRAT_28_COMPRESSED
+#define LV_FONT_MONTSERRAT_28_COMPRESSED 0  /*bpp = 3*/
+#endif
+#ifndef LV_FONT_DEJAVU_16_PERSIAN_HEBREW
+#define LV_FONT_DEJAVU_16_PERSIAN_HEBREW 0  /*Hebrew, Arabic, PErisan letters and all their forms*/
+#endif
+#ifndef LV_FONT_SIMSUN_16_CJK
+#define LV_FONT_SIMSUN_16_CJK            0  /*1000 most common CJK radicals*/
 #endif
 
 /*Pixel perfect monospace font
@@ -451,11 +579,6 @@
 #define LV_FONT_CUSTOM_DECLARE
 #endif
 
-/*Always set a default font from the built-in fonts*/
-#ifndef LV_FONT_DEFAULT
-#define LV_FONT_DEFAULT        &lv_font_roboto_16
-#endif
-
 /* Enable it if you have fonts with a lot of characters.
  * The limit depends on the font size, font face and bpp
  * but with > 10,000 characters if you see issues probably you need to enable it.*/
@@ -473,6 +596,69 @@
 
 /*Declare the type of the user data of fonts (can be e.g. `void *`, `int`, `struct`)*/
 
+/*================
+ *  THEME USAGE
+ *================*/
+
+/*Always enable at least on theme*/
+
+/* No theme, you can apply your styles as you need
+ * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
+#ifndef LV_USE_THEME_EMPTY
+ #define LV_USE_THEME_EMPTY       1
+#endif
+
+/*Simple to the create your theme based on it
+ * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
+#ifndef LV_USE_THEME_TEMPLATE
+ #define LV_USE_THEME_TEMPLATE    1
+#endif
+
+/* A fast and impressive theme.
+ * Flags:
+ * LV_THEME_MATERIAL_FLAG_LIGHT: light theme
+ * LV_THEME_MATERIAL_FLAG_DARK: dark theme*/
+#ifndef LV_USE_THEME_MATERIAL
+ #define LV_USE_THEME_MATERIAL    1
+#endif
+
+/* Mono-color theme for monochrome displays.
+ * If LV_THEME_DEFAULT_COLOR_PRIMARY is LV_COLOR_BLACK the
+ * texts and borders will be black and the background will be
+ * white. Else the colors are inverted.
+ * No flags. Set LV_THEME_DEFAULT_FLAG 0 */
+#ifndef LV_USE_THEME_MONO
+ #define LV_USE_THEME_MONO        1
+#endif
+
+#ifndef LV_THEME_DEFAULT_INCLUDE
+#define LV_THEME_DEFAULT_INCLUDE            <stdint.h>      /*Include a header for the init. function*/
+#endif
+#ifndef LV_THEME_DEFAULT_INIT
+#define LV_THEME_DEFAULT_INIT               lv_theme_material_init
+#endif
+#ifndef LV_THEME_DEFAULT_COLOR_PRIMARY
+#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_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
+#endif
+#ifndef LV_THEME_DEFAULT_FONT_NORMAL
+#define LV_THEME_DEFAULT_FONT_NORMAL        &lv_font_montserrat_16
+#endif
+#ifndef LV_THEME_DEFAULT_FONT_SUBTITLE
+#define LV_THEME_DEFAULT_FONT_SUBTITLE      &lv_font_montserrat_16
+#endif
+#ifndef LV_THEME_DEFAULT_FONT_TITLE
+#define LV_THEME_DEFAULT_FONT_TITLE         &lv_font_montserrat_16
+#endif
+
 /*=================
  *  Text settings
  *=================*/
@@ -494,7 +680,7 @@
 /* If a word is at least this long, will break wherever "prettiest"
  * To disable, set to a value <= 0 */
 #ifndef LV_TXT_LINE_BREAK_LONG_LEN
-#define LV_TXT_LINE_BREAK_LONG_LEN          12
+#define LV_TXT_LINE_BREAK_LONG_LEN          0
 #endif
 
 /* Minimum number of characters in a long word to put on a line before a break.
@@ -531,6 +717,13 @@
 #endif
 #endif
 
+/* Enable Arabic/Persian processing
+ * In these languages characters should be replaced with
+ * an other form based on their position in the text */
+#ifndef LV_USE_ARABIC_PERSIAN_CHARS
+#define LV_USE_ARABIC_PERSIAN_CHARS 0
+#endif
+
 /*Change the built in (v)snprintf functions*/
 #ifndef LV_SPRINTF_CUSTOM
 #define LV_SPRINTF_CUSTOM   0
@@ -545,15 +738,34 @@
 #ifndef lv_vsnprintf
 #  define lv_vsnprintf    vsnprintf
 #endif
+#else   /*!LV_SPRINTF_CUSTOM*/
+#ifndef LV_SPRINTF_DISABLE_FLOAT
+#  define LV_SPRINTF_DISABLE_FLOAT 1
+#endif
 #endif  /*LV_SPRINTF_CUSTOM*/
 
 /*===================
  *  LV_OBJ SETTINGS
  *==================*/
 
+#if LV_USE_USER_DATA
 /*Declare the type of the user data of object (can be e.g. `void *`, `int`, `struct`)*/
+/*Provide a function to free user data*/
+#ifndef LV_USE_USER_DATA_FREE
+#define LV_USE_USER_DATA_FREE 0
+#endif
+#if LV_USE_USER_DATA_FREE
+#ifndef LV_USER_DATA_FREE_INCLUDE
+#  define LV_USER_DATA_FREE_INCLUDE  "something.h"  /*Header for user data free function*/
+#endif
+/* Function prototype : void user_data_free(lv_obj_t * obj); */
+#ifndef LV_USER_DATA_FREE
+#  define LV_USER_DATA_FREE  (user_data_free)       /*Invoking for user data free function*/
+#endif
+#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
@@ -564,14 +776,14 @@
  * LV_EXT_CLICK_AREA_FULL: The extra area can be adjusted in all 4 directions (-32k..+32k px)
  */
 #ifndef LV_USE_EXT_CLICK_AREA
-#define LV_USE_EXT_CLICK_AREA  LV_EXT_CLICK_AREA_OFF
+#define LV_USE_EXT_CLICK_AREA  LV_EXT_CLICK_AREA_TINY
 #endif
 
 /*==================
  *  LV OBJ X USAGE
  *================*/
 /*
- * Documentation of the object types: https://docs.littlevgl.com/#Object-types
+ * Documentation of the object types: https://docs.lvgl.com/#Object-types
  */
 
 /*Arc (dependencies: -)*/
@@ -588,16 +800,10 @@
 #ifndef LV_USE_BTN
 #define LV_USE_BTN      1
 #endif
-#if LV_USE_BTN != 0
-/*Enable button-state animations - draw a circle on click (dependencies: LV_USE_ANIMATION)*/
-#ifndef LV_BTN_INK_EFFECT
-#  define LV_BTN_INK_EFFECT   0
-#endif
-#endif
 
 /*Button matrix (dependencies: -)*/
-#ifndef LV_USE_BTNM
-#define LV_USE_BTNM     1
+#ifndef LV_USE_BTNMATRIX
+#define LV_USE_BTNMATRIX     1
 #endif
 
 /*Calendar (dependencies: -)*/
@@ -611,8 +817,8 @@
 #endif
 
 /*Check box (dependencies: lv_btn, lv_label)*/
-#ifndef LV_USE_CB
-#define LV_USE_CB       1
+#ifndef LV_USE_CHECKBOX
+#define LV_USE_CHECKBOX       1
 #endif
 
 /*Chart (dependencies: -)*/
@@ -636,17 +842,17 @@
 #endif
 
 /*Drop down list (dependencies: lv_page, lv_label, lv_symbol_def.h)*/
-#ifndef LV_USE_DDLIST
-#define LV_USE_DDLIST    1
+#ifndef LV_USE_DROPDOWN
+#define LV_USE_DROPDOWN    1
 #endif
-#if LV_USE_DDLIST != 0
+#if LV_USE_DROPDOWN != 0
 /*Open and close default animation time [ms] (0: no animation)*/
-#ifndef LV_DDLIST_DEF_ANIM_TIME
-#  define LV_DDLIST_DEF_ANIM_TIME     200
+#ifndef LV_DROPDOWN_DEF_ANIM_TIME
+#  define LV_DROPDOWN_DEF_ANIM_TIME     200
 #endif
 #endif
 
-/*Gauge (dependencies:lv_bar, lv_lmeter)*/
+/*Gauge (dependencies:lv_bar, lv_linemeter)*/
 #ifndef LV_USE_GAUGE
 #define LV_USE_GAUGE    1
 #endif
@@ -668,8 +874,8 @@
 #endif
 
 /*Keyboard (dependencies: lv_btnm)*/
-#ifndef LV_USE_KB
-#define LV_USE_KB       1
+#ifndef LV_USE_KEYBOARD
+#define LV_USE_KEYBOARD       1
 #endif
 
 /*Label (dependencies: -*/
@@ -702,6 +908,14 @@
 #ifndef LV_USE_LED
 #define LV_USE_LED      1
 #endif
+#if LV_USE_LED
+#ifndef LV_LED_BRIGHT_MIN
+#  define LV_LED_BRIGHT_MIN  120      /*Minimal brightness*/
+#endif
+#ifndef LV_LED_BRIGHT_MAX
+#  define LV_LED_BRIGHT_MAX  255     /*Maximal brightness*/
+#endif
+#endif
 
 /*Line (dependencies: -*/
 #ifndef LV_USE_LINE
@@ -720,13 +934,29 @@
 #endif
 
 /*Line meter (dependencies: *;)*/
-#ifndef LV_USE_LMETER
-#define LV_USE_LMETER   1
+#ifndef LV_USE_LINEMETER
+#define LV_USE_LINEMETER   1
+#endif
+#if LV_USE_LINEMETER
+/* Draw line more precisely at cost of performance.
+ * Useful if there are lot of lines any minor are visible
+ * 0: No extra precision
+ * 1: Some extra precision
+ * 2: Best precision
+ */
+#ifndef LV_LINEMETER_PRECISE
+#  define LV_LINEMETER_PRECISE    0
+#endif
+#endif
+
+/*Mask (dependencies: -)*/
+#ifndef LV_USE_OBJMASK
+#define LV_USE_OBJMASK  1
 #endif
 
 /*Message box (dependencies: lv_rect, lv_btnm, lv_label)*/
-#ifndef LV_USE_MBOX
-#define LV_USE_MBOX     1
+#ifndef LV_USE_MSGBOX
+#define LV_USE_MSGBOX     1
 #endif
 
 /*Page (dependencies: lv_cont)*/
@@ -741,18 +971,18 @@
 #endif
 
 /*Preload (dependencies: lv_arc, lv_anim)*/
-#ifndef LV_USE_PRELOAD
-#define LV_USE_PRELOAD      1
+#ifndef LV_USE_SPINNER
+#define LV_USE_SPINNER      1
 #endif
-#if LV_USE_PRELOAD != 0
-#ifndef LV_PRELOAD_DEF_ARC_LENGTH
-#  define LV_PRELOAD_DEF_ARC_LENGTH   60      /*[deg]*/
+#if LV_USE_SPINNER != 0
+#ifndef LV_SPINNER_DEF_ARC_LENGTH
+#  define LV_SPINNER_DEF_ARC_LENGTH   60      /*[deg]*/
 #endif
-#ifndef LV_PRELOAD_DEF_SPIN_TIME
-#  define LV_PRELOAD_DEF_SPIN_TIME    1000    /*[ms]*/
+#ifndef LV_SPINNER_DEF_SPIN_TIME
+#  define LV_SPINNER_DEF_SPIN_TIME    1000    /*[ms]*/
 #endif
-#ifndef LV_PRELOAD_DEF_ANIM
-#  define LV_PRELOAD_DEF_ANIM         LV_PRELOAD_TYPE_SPINNING_ARC
+#ifndef LV_SPINNER_DEF_ANIM
+#  define LV_SPINNER_DEF_ANIM         LV_SPINNER_TYPE_SPINNING_ARC
 #endif
 #endif
 
@@ -783,20 +1013,20 @@
 #endif
 
 /*Switch (dependencies: lv_slider)*/
-#ifndef LV_USE_SW
-#define LV_USE_SW       1
+#ifndef LV_USE_SWITCH
+#define LV_USE_SWITCH       1
 #endif
 
 /*Text area (dependencies: lv_label, lv_page)*/
-#ifndef LV_USE_TA
-#define LV_USE_TA       1
+#ifndef LV_USE_TEXTAREA
+#define LV_USE_TEXTAREA       1
 #endif
-#if LV_USE_TA != 0
-#ifndef LV_TA_DEF_CURSOR_BLINK_TIME
-#  define LV_TA_DEF_CURSOR_BLINK_TIME 400     /*ms*/
+#if LV_USE_TEXTAREA != 0
+#ifndef LV_TEXTAREA_DEF_CURSOR_BLINK_TIME
+#  define LV_TEXTAREA_DEF_CURSOR_BLINK_TIME 400     /*ms*/
 #endif
-#ifndef LV_TA_DEF_PWD_SHOW_TIME
-#  define LV_TA_DEF_PWD_SHOW_TIME     1500    /*ms*/
+#ifndef LV_TEXTAREA_DEF_PWD_SHOW_TIME
+#  define LV_TEXTAREA_DEF_PWD_SHOW_TIME     1500    /*ms*/
 #endif
 #endif
 

src/lv_core/lv_core.mk

@@ -4,9 +4,8 @@ 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/src/lv_core
-VPATH += :$(LVGL_DIR)/lvgl/src/lv_core
+DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_core
+VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_core
 
-CFLAGS += "-I$(LVGL_DIR)/lvgl/src/lv_core"
+CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_core"

src/lv_core/lv_disp.c

@@ -43,7 +43,7 @@ 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 top layer");
+        LV_LOG_WARN("lv_scr_act: no display registered to get its act. screen");
         return NULL;
     }
 
@@ -57,7 +57,7 @@ lv_obj_t * lv_disp_get_scr_act(lv_disp_t * disp)
 void lv_disp_load_scr(lv_obj_t * scr)
 {
     lv_disp_t * d = lv_obj_get_disp(scr);
-
+    if(!d) return;  /*Shouldn't happen, just to be sure*/
     d->act_scr = scr;
 
     lv_obj_invalidate(scr);
@@ -89,7 +89,7 @@ lv_obj_t * lv_disp_get_layer_sys(lv_disp_t * disp)
 {
     if(!disp) disp = lv_disp_get_default();
     if(!disp) {
-        LV_LOG_WARN("lv_layer_sys: no display registered to get its top layer");
+        LV_LOG_WARN("lv_layer_sys: no display registered to get its sys. layer");
         return NULL;
     }
 
@@ -112,24 +112,7 @@ void lv_disp_assign_screen(lv_disp_t * disp, lv_obj_t * scr)
 
     if(old_disp == disp) return;
 
-    lv_ll_chg_list(&old_disp->scr_ll, &disp->scr_ll, scr, true);
-}
-
-/**
- * Get a pointer to the screen refresher task to
- * modify its parameters with `lv_task_...` functions.
- * @param disp pointer to a display
- * @return pointer to the display refresher task. (NULL on error)
- */
-lv_task_t * lv_disp_get_refr_task(lv_disp_t * disp)
-{
-    if(!disp) disp = lv_disp_get_default();
-    if(!disp) {
-        LV_LOG_WARN("lv_disp_get_refr_task: no display registered");
-        return NULL;
-    }
-
-    return disp->refr_task;
+    _lv_ll_chg_list(&old_disp->scr_ll, &disp->scr_ll, scr, true);
 }
 
 /**
@@ -151,7 +134,8 @@ uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp)
     uint32_t t = UINT32_MAX;
     d          = lv_disp_get_next(NULL);
     while(d) {
-        t = LV_MATH_MIN(t, lv_tick_elaps(d->last_activity_time));
+        uint32_t elaps = lv_tick_elaps(d->last_activity_time);
+        t = LV_MATH_MIN(t, elaps);
         d = lv_disp_get_next(d);
     }
 
@@ -173,6 +157,24 @@ void lv_disp_trig_activity(lv_disp_t * disp)
     disp->last_activity_time = lv_tick_get();
 }
 
+
+/**
+ * Get a pointer to the screen refresher task to
+ * modify its parameters with `lv_task_...` functions.
+ * @param disp pointer to a display
+ * @return pointer to the display refresher task. (NULL on error)
+ */
+lv_task_t * _lv_disp_get_refr_task(lv_disp_t * disp)
+{
+    if(!disp) disp = lv_disp_get_default();
+    if(!disp) {
+        LV_LOG_WARN("lv_disp_get_refr_task: no display registered");
+        return NULL;
+    }
+
+    return disp->refr_task;
+}
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/

src/lv_core/lv_disp.h

@@ -64,14 +64,6 @@ 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);
 
-/**
- * Get a pointer to the screen refresher task to
- * modify its parameters with `lv_task_...` functions.
- * @param disp pointer to a display
- * @return pointer to the display refresher task. (NULL on error)
- */
-lv_task_t * lv_disp_get_refr_task(lv_disp_t * disp);
-
 /**
  * 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)
@@ -85,6 +77,14 @@ uint32_t lv_disp_get_inactive_time(const lv_disp_t * disp);
  */
 void lv_disp_trig_activity(lv_disp_t * disp);
 
+/**
+ * Get a pointer to the screen refresher task to
+ * modify its parameters with `lv_task_...` functions.
+ * @param disp pointer to a display
+ * @return pointer to the display refresher task. (NULL on error)
+ */
+lv_task_t * _lv_disp_get_refr_task(lv_disp_t * disp);
+
 /*------------------------------------------------
  * To improve backward compatibility
  * Recommended only if you have one display
@@ -145,6 +145,15 @@ static inline void lv_scr_load(lv_obj_t * scr)
 #define LV_VER_RES lv_disp_get_ver_res(lv_disp_get_default())
 #endif
 
+
+/**
+ * Same as Android's DIP. (Different name is chosen to avoid mistype between LV_DPI and LV_DIP)
+ * 1 dip is 1 px on a 160 DPI screen
+ * 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*/
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

src/lv_core/lv_group.c

@@ -9,12 +9,12 @@
 #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"
 
 #if defined(LV_GC_INCLUDE)
-#include LV_GC_INCLUDE
+    #include LV_GC_INCLUDE
 #endif /* LV_ENABLE_GC */
 
 /*********************
@@ -28,9 +28,6 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void style_mod_def(lv_group_t * group, lv_style_t * style);
-static void style_mod_edit_def(lv_group_t * group, lv_style_t * style);
-static void refresh_theme(lv_group_t * g, lv_theme_t * th);
 static void focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *),
                             void * (*move)(const lv_ll_t *, const void *));
 static void lv_group_refocus(lv_group_t * g);
@@ -51,9 +48,9 @@ static void obj_to_foreground(lv_obj_t * obj);
 /**
  * Init. the group module
  */
-void lv_group_init(void)
+void _lv_group_init(void)
 {
-    lv_ll_init(&LV_GC_ROOT(_lv_group_ll), sizeof(lv_group_t));
+    _lv_ll_init(&LV_GC_ROOT(_lv_group_ll), sizeof(lv_group_t));
 }
 
 /**
@@ -62,10 +59,10 @@ void lv_group_init(void)
  */
 lv_group_t * lv_group_create(void)
 {
-    lv_group_t * group = lv_ll_ins_head(&LV_GC_ROOT(_lv_group_ll));
+    lv_group_t * group = _lv_ll_ins_head(&LV_GC_ROOT(_lv_group_ll));
     LV_ASSERT_MEM(group);
     if(group == NULL) return NULL;
-    lv_ll_init(&group->obj_ll, sizeof(lv_obj_t *));
+    _lv_ll_init(&group->obj_ll, sizeof(lv_obj_t *));
 
     group->obj_focus      = NULL;
     group->frozen         = 0;
@@ -76,12 +73,9 @@ lv_group_t * lv_group_create(void)
     group->wrap           = 1;
 
 #if LV_USE_USER_DATA
-    memset(&group->user_data, 0, sizeof(lv_group_user_data_t));
+    _lv_memset_00(&group->user_data, sizeof(lv_group_user_data_t));
 #endif
 
-    /*Initialize style modification callbacks from current theme*/
-    refresh_theme(group, lv_theme_get_current());
-
     return group;
 }
 
@@ -99,13 +93,12 @@ void lv_group_del(lv_group_t * group)
 
     /*Remove the objects from the group*/
     lv_obj_t ** obj;
-    LV_LL_READ(group->obj_ll, obj)
-    {
+    _LV_LL_READ(group->obj_ll, obj) {
         (*obj)->group_p = NULL;
     }
 
-    lv_ll_clear(&(group->obj_ll));
-    lv_ll_rem(&LV_GC_ROOT(_lv_group_ll), group);
+    _lv_ll_clear(&(group->obj_ll));
+    _lv_ll_remove(&LV_GC_ROOT(_lv_group_ll), group);
     lv_mem_free(group);
 }
 
@@ -117,11 +110,9 @@ void lv_group_del(lv_group_t * group)
 void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
 {
     if(group == NULL) return;
-
     /*Do not add the object twice*/
     lv_obj_t ** obj_i;
-    LV_LL_READ(group->obj_ll, obj_i)
-    {
+    _LV_LL_READ(group->obj_ll, obj_i) {
         if((*obj_i) == obj) {
             LV_LOG_INFO("lv_group_add_obj: the object is already added to this group");
             return;
@@ -138,14 +129,14 @@ void lv_group_add_obj(lv_group_t * group, lv_obj_t * obj)
     }
 
     obj->group_p     = group;
-    lv_obj_t ** next = lv_ll_ins_tail(&group->obj_ll);
+    lv_obj_t ** next = _lv_ll_ins_tail(&group->obj_ll);
     LV_ASSERT_MEM(next);
     if(next == NULL) return;
     *next = obj;
 
     /* If the head and the tail is equal then there is only one object in the linked list.
      * In this case automatically activate it*/
-    if(lv_ll_get_head(&group->obj_ll) == next) {
+    if(_lv_ll_get_head(&group->obj_ll) == next) {
         lv_group_refocus(group);
     }
 }
@@ -162,8 +153,10 @@ void lv_group_remove_obj(lv_obj_t * obj)
 
     /*Focus on the next object*/
     if(*g->obj_focus == obj) {
+        if(g->frozen) g->frozen = 0;
+
         /*If this is the only object in the group then focus to nothing.*/
-        if(lv_ll_get_head(&g->obj_ll) == g->obj_focus && lv_ll_get_tail(&g->obj_ll) == g->obj_focus) {
+        if(_lv_ll_get_head(&g->obj_ll) == g->obj_focus && _lv_ll_get_tail(&g->obj_ll) == g->obj_focus) {
             (*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
         }
         /*If there more objects in the group then focus to the next/prev object*/
@@ -181,10 +174,9 @@ void lv_group_remove_obj(lv_obj_t * obj)
 
     /*Search the object and remove it from its group */
     lv_obj_t ** i;
-    LV_LL_READ(g->obj_ll, i)
-    {
+    _LV_LL_READ(g->obj_ll, i) {
         if(*i == obj) {
-            lv_ll_rem(&g->obj_ll, i);
+            _lv_ll_remove(&g->obj_ll, i);
             lv_mem_free(i);
             obj->group_p = NULL;
             break;
@@ -207,12 +199,11 @@ void lv_group_remove_all_objs(lv_group_t * group)
 
     /*Remove the objects from the group*/
     lv_obj_t ** obj;
-    LV_LL_READ(group->obj_ll, obj)
-    {
+    _LV_LL_READ(group->obj_ll, obj) {
         (*obj)->group_p = NULL;
     }
 
-    lv_ll_clear(&(group->obj_ll));
+    _lv_ll_clear(&(group->obj_ll));
 }
 
 /**
@@ -227,12 +218,13 @@ void lv_group_focus_obj(lv_obj_t * obj)
 
     if(g->frozen != 0) return;
 
+    if(obj == *g->obj_focus) return;
+
     /*On defocus edit mode must be leaved*/
     lv_group_set_editing(g, false);
 
     lv_obj_t ** i;
-    LV_LL_READ(g->obj_ll, i)
-    {
+    _LV_LL_READ(g->obj_ll, i) {
         if(*i == obj) {
             if(g->obj_focus != NULL) {
                 (*g->obj_focus)->signal_cb(*g->obj_focus, LV_SIGNAL_DEFOCUS, NULL);
@@ -250,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;
@@ -264,7 +256,7 @@ void lv_group_focus_obj(lv_obj_t * obj)
  */
 void lv_group_focus_next(lv_group_t * group)
 {
-    focus_next_core(group, lv_ll_get_head, lv_ll_get_next);
+    focus_next_core(group, _lv_ll_get_head, _lv_ll_get_next);
 }
 
 /**
@@ -273,7 +265,7 @@ void lv_group_focus_next(lv_group_t * group)
  */
 void lv_group_focus_prev(lv_group_t * group)
 {
-    focus_next_core(group, lv_ll_get_tail, lv_ll_get_prev);
+    focus_next_core(group, _lv_ll_get_tail, _lv_ll_get_prev);
 }
 
 /**
@@ -311,28 +303,6 @@ lv_res_t lv_group_send_data(lv_group_t * group, uint32_t c)
     return res;
 }
 
-/**
- * Set a function for a group which will modify the object's style if it is in focus
- * @param group pointer to a group
- * @param style_mod_cb the style modifier function pointer
- */
-void lv_group_set_style_mod_cb(lv_group_t * group, lv_group_style_mod_cb_t style_mod_cb)
-{
-    group->style_mod_cb = style_mod_cb;
-    if(group->obj_focus != NULL) lv_obj_invalidate(*group->obj_focus);
-}
-
-/**
- * Set a function for a group which will modify the object's style if it is in focus in edit mode
- * @param group pointer to a group
- * @param style_mod_func the style modifier function pointer
- */
-void lv_group_set_style_mod_edit_cb(lv_group_t * group, lv_group_style_mod_cb_t style_mod_edit_cb)
-{
-    group->style_mod_edit_cb = style_mod_edit_cb;
-    if(group->obj_focus != NULL) lv_obj_invalidate(*group->obj_focus);
-}
-
 /**
  * Set a function for a group which will be called when a new object is focused
  * @param group pointer to a group
@@ -350,6 +320,7 @@ void lv_group_set_focus_cb(lv_group_t * group, lv_group_focus_cb_t focus_cb)
  */
 void lv_group_set_editing(lv_group_t * group, bool edit)
 {
+    if(group == NULL) return;
     uint8_t en_val = edit ? 1 : 0;
 
     if(en_val == group->editing) return; /*Do not set the same mode again*/
@@ -391,25 +362,6 @@ void lv_group_set_wrap(lv_group_t * group, bool en)
     group->wrap = en ? 1 : 0;
 }
 
-/**
- * Modify a style with the set 'style_mod' function. The input style remains unchanged.
- * @param group pointer to group
- * @param style pointer to a style to modify
- * @return a copy of the input style but modified with the 'style_mod' function
- */
-lv_style_t * lv_group_mod_style(lv_group_t * group, const lv_style_t * style)
-{
-    /*Load the current style. It will be modified by the callback*/
-    lv_style_copy(&group->style_tmp, style);
-
-    if(group->editing) {
-        if(group->style_mod_edit_cb) group->style_mod_edit_cb(group, &group->style_tmp);
-    } else {
-        if(group->style_mod_cb) group->style_mod_cb(group, &group->style_tmp);
-    }
-    return &group->style_tmp;
-}
-
 /**
  * Get the focused object or NULL if there isn't one
  * @param group pointer to a group
@@ -435,28 +387,6 @@ lv_group_user_data_t * lv_group_get_user_data(lv_group_t * group)
 }
 #endif
 
-/**
- * Get a the style modifier function of a group
- * @param group pointer to a group
- * @return pointer to the style modifier function
- */
-lv_group_style_mod_cb_t lv_group_get_style_mod_cb(const lv_group_t * group)
-{
-    if(!group) return false;
-    return group->style_mod_cb;
-}
-
-/**
- * Get a the style modifier function of a group in edit mode
- * @param group pointer to a group
- * @return pointer to the style modifier function
- */
-lv_group_style_mod_cb_t lv_group_get_style_mod_edit_cb(const lv_group_t * group)
-{
-    if(!group) return false;
-    return group->style_mod_edit_cb;
-}
-
 /**
  * Get the focus callback function of a group
  * @param group pointer to a group
@@ -464,7 +394,7 @@ lv_group_style_mod_cb_t lv_group_get_style_mod_edit_cb(const lv_group_t * group)
  */
 lv_group_focus_cb_t lv_group_get_focus_cb(const lv_group_t * group)
 {
-    if(!group) return false;
+    if(!group) return NULL;
     return group->focus_cb;
 }
 
@@ -501,27 +431,6 @@ bool lv_group_get_wrap(lv_group_t * group)
     return group->wrap ? true : false;
 }
 
-/**
- * Notify the group that current theme changed and style modification callbacks need to be
- * refreshed.
- * @param group pointer to group. If NULL then all groups are notified.
- */
-void lv_group_report_style_mod(lv_group_t * group)
-{
-    lv_theme_t * th = lv_theme_get_current();
-
-    if(group != NULL) {
-        refresh_theme(group, th);
-        return;
-    }
-
-    lv_group_t * i;
-    LV_LL_READ(LV_GC_ROOT(_lv_group_ll), i)
-    {
-        refresh_theme(i, th);
-    }
-}
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -540,89 +449,6 @@ static void lv_group_refocus(lv_group_t * g)
     g->wrap = temp_wrap;
 }
 
-/**
- * Default style modifier function
- * @param group pointer to the caller group
- * @param style pointer to a style to modify. (Typically group.style_tmp) It will be OVERWRITTEN.
- */
-static void style_mod_def(lv_group_t * group, lv_style_t * style)
-{
-    (void)group; /*Unused*/
-#if LV_COLOR_DEPTH != 1
-
-    /*Make the style to be a little bit orange*/
-    style->body.border.opa   = LV_OPA_COVER;
-    style->body.border.color = LV_COLOR_ORANGE;
-
-    /*If not transparent or has border then emphasis the border*/
-    if(style->body.opa != LV_OPA_TRANSP || style->body.border.width != 0) style->body.border.width = LV_DPI / 20;
-
-    style->body.main_color   = lv_color_mix(style->body.main_color, LV_COLOR_ORANGE, LV_OPA_70);
-    style->body.grad_color   = lv_color_mix(style->body.grad_color, LV_COLOR_ORANGE, LV_OPA_70);
-    style->body.shadow.color = lv_color_mix(style->body.shadow.color, LV_COLOR_ORANGE, LV_OPA_60);
-
-    style->text.color = lv_color_mix(style->text.color, LV_COLOR_ORANGE, LV_OPA_70);
-
-    /*Add some recolor to the images*/
-    if(style->image.intense < LV_OPA_MIN) {
-        style->image.color   = LV_COLOR_ORANGE;
-        style->image.intense = LV_OPA_40;
-    }
-#else
-    style->body.border.opa   = LV_OPA_COVER;
-    style->body.border.color = LV_COLOR_BLACK;
-    style->body.border.width = 2;
-
-#endif
-}
-
-/**
- * Default style modifier function
- * @param group pointer to the caller group
- * @param style pointer to a style to modify. (Typically group.style_tmp) It will be OVERWRITTEN.
- */
-static void style_mod_edit_def(lv_group_t * group, lv_style_t * style)
-{
-    (void)group; /*Unused*/
-#if LV_COLOR_DEPTH != 1
-
-    /*Make the style to be a little bit orange*/
-    style->body.border.opa   = LV_OPA_COVER;
-    style->body.border.color = LV_COLOR_GREEN;
-
-    /*If not empty or has border then emphasis the border*/
-    if(style->body.opa != LV_OPA_TRANSP || style->body.border.width != 0) style->body.border.width = LV_DPI / 20;
-
-    style->body.main_color   = lv_color_mix(style->body.main_color, LV_COLOR_GREEN, LV_OPA_70);
-    style->body.grad_color   = lv_color_mix(style->body.grad_color, LV_COLOR_GREEN, LV_OPA_70);
-    style->body.shadow.color = lv_color_mix(style->body.shadow.color, LV_COLOR_GREEN, LV_OPA_60);
-
-    style->text.color = lv_color_mix(style->text.color, LV_COLOR_GREEN, LV_OPA_70);
-
-    /*Add some recolor to the images*/
-    if(style->image.intense < LV_OPA_MIN) {
-        style->image.color   = LV_COLOR_GREEN;
-        style->image.intense = LV_OPA_40;
-    }
-
-#else
-    style->body.border.opa   = LV_OPA_COVER;
-    style->body.border.color = LV_COLOR_BLACK;
-    style->body.border.width = 3;
-
-#endif
-}
-
-static void refresh_theme(lv_group_t * g, lv_theme_t * th)
-{
-    g->style_mod_cb      = style_mod_def;
-    g->style_mod_edit_cb = style_mod_edit_def;
-    if(th) {
-        if(th->group.style_mod_xcb) g->style_mod_cb = th->group.style_mod_xcb;
-        if(th->group.style_mod_edit_xcb) g->style_mod_edit_cb = th->group.style_mod_edit_xcb;
-    }
-}
-
 static void focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *),
                             void * (*move)(const lv_ll_t *, const void *))
 {
@@ -640,7 +466,8 @@ static void focus_next_core(lv_group_t * group, void * (*begin)(const lv_ll_t *)
                 obj_next  = begin(&group->obj_ll);
                 can_move  = false;
                 can_begin = false;
-            } else {
+            }
+            else {
                 /*Currently focused object is the last/first in the group, keep it that way*/
                 return;
             }
@@ -681,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

@@ -13,11 +13,6 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#ifdef LV_CONF_INCLUDE_SIMPLE
-#include "lv_conf.h"
-#else
-#include "../../../lv_conf.h"
-#endif
 
 #include "lv_obj.h"
 
@@ -56,15 +51,11 @@ typedef void (*lv_group_focus_cb_t)(struct _lv_group_t *);
  * Groups can be used to logically hold objects so that they can be individually focused.
  * They are NOT for laying out objects on a screen (try `lv_cont` for that).
  */
-typedef struct _lv_group_t
-{
+typedef struct _lv_group_t {
     lv_ll_t obj_ll;        /**< Linked list to store the objects in the group */
     lv_obj_t ** obj_focus; /**< The object in focus*/
 
-    lv_group_style_mod_cb_t style_mod_cb;      /**< A function to modifies the style of the focused object*/
-    lv_group_style_mod_cb_t style_mod_edit_cb; /**< A function which modifies the style of the edited object*/
     lv_group_focus_cb_t focus_cb;              /**< A function to call when a new object is focused (optional)*/
-    lv_style_t style_tmp;                      /**< Stores the modified style of the focused object */
 #if LV_USE_USER_DATA
     lv_group_user_data_t user_data;
 #endif
@@ -90,7 +81,7 @@ typedef uint8_t lv_group_refocus_policy_t;
  * Init. the group module
  * @remarks Internal function, do not call directly.
  */
-void lv_group_init(void);
+void _lv_group_init(void);
 
 /**
  * Create a new object group
@@ -156,20 +147,6 @@ void lv_group_focus_freeze(lv_group_t * group, bool en);
  */
 lv_res_t lv_group_send_data(lv_group_t * group, uint32_t c);
 
-/**
- * Set a function for a group which will modify the object's style if it is in focus
- * @param group pointer to a group
- * @param style_mod_cb the style modifier function pointer
- */
-void lv_group_set_style_mod_cb(lv_group_t * group, lv_group_style_mod_cb_t style_mod_cb);
-
-/**
- * Set a function for a group which will modify the object's style if it is in focus in edit mode
- * @param group pointer to a group
- * @param style_mod_edit_cb the style modifier function pointer
- */
-void lv_group_set_style_mod_edit_cb(lv_group_t * group, lv_group_style_mod_cb_t style_mod_edit_cb);
-
 /**
  * Set a function for a group which will be called when a new object is focused
  * @param group pointer to a group
@@ -178,7 +155,7 @@ void lv_group_set_style_mod_edit_cb(lv_group_t * group, lv_group_style_mod_cb_t
 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
@@ -206,14 +183,6 @@ void lv_group_set_click_focus(lv_group_t * group, bool en);
  */
 void lv_group_set_wrap(lv_group_t * group, bool en);
 
-/**
- * Modify a style with the set 'style_mod' function. The input style remains unchanged.
- * @param group pointer to group
- * @param style pointer to a style to modify
- * @return a copy of the input style but modified with the 'style_mod' function
- */
-lv_style_t * lv_group_mod_style(lv_group_t * group, const lv_style_t * style);
-
 /**
  * Get the focused object or NULL if there isn't one
  * @param group pointer to a group
@@ -231,20 +200,6 @@ lv_group_user_data_t * lv_group_get_user_data(lv_group_t * group);
 
 #endif
 
-/**
- * Get a the style modifier function of a group
- * @param group pointer to a group
- * @return pointer to the style modifier function
- */
-lv_group_style_mod_cb_t lv_group_get_style_mod_cb(const lv_group_t * group);
-
-/**
- * Get a the style modifier function of a group in edit mode
- * @param group pointer to a group
- * @return pointer to the style modifier function
- */
-lv_group_style_mod_cb_t lv_group_get_style_mod_edit_cb(const lv_group_t * group);
-
 /**
  * Get the focus callback function of a group
  * @param group pointer to a group
@@ -273,13 +228,6 @@ bool lv_group_get_click_focus(const lv_group_t * group);
  */
 bool lv_group_get_wrap(lv_group_t * group);
 
-/**
- * Notify the group that current theme changed and style modification callbacks need to be
- * refreshed.
- * @param group pointer to group. If NULL then all groups are notified.
- */
-void lv_group_report_style_mod(lv_group_t * group);
-
 /**********************
  *      MACROS
  **********************/

src/lv_core/lv_indev.h

@@ -32,13 +32,13 @@ extern "C" {
 /**
  * Initialize the display input device subsystem
  */
-void lv_indev_init(void);
+void _lv_indev_init(void);
 
 /**
  * Called periodically to read the input devices
  * @param task pointer to the task itself
  */
-void lv_indev_read_task(lv_task_t * task);
+void _lv_indev_read_task(lv_task_t * task);
 
 /**
  * Get the currently processed input device. Can be used in action functions too.
@@ -57,8 +57,9 @@ lv_indev_type_t lv_indev_get_type(const lv_indev_t * indev);
 /**
  * Reset one or all input devices
  * @param indev pointer to an input device to reset or NULL to reset all of them
+ * @param obj pointer to an object which triggers the reset.
  */
-void lv_indev_reset(lv_indev_t * indev);
+void lv_indev_reset(lv_indev_t * indev, lv_obj_t * obj);
 
 /**
  * Reset the long press state of an input device
@@ -104,6 +105,13 @@ void lv_indev_set_button_points(lv_indev_t * indev, const lv_point_t points[]);
  */
 void lv_indev_get_point(const lv_indev_t * indev, lv_point_t * point);
 
+/**
+* Get the current gesture direct
+* @param indev pointer to an input device
+* @return current gesture direct
+*/
+lv_gesture_dir_t lv_indev_get_gesture_dir(const lv_indev_t * indev);
+
 /**
  * Get the last pressed key of an input device (for LV_INDEV_TYPE_KEYPAD)
  * @param indev pointer to an input device
@@ -127,12 +135,36 @@ bool lv_indev_is_dragging(const lv_indev_t * indev);
  */
 void lv_indev_get_vect(const lv_indev_t * indev, lv_point_t * point);
 
+/**
+ * Manually finish dragging.
+ * `LV_SIGNAL_DRAG_END` and `LV_EVENT_DRAG_END` will be sent.
+ * @param indev pointer to an input device
+ * @return `LV_RES_INV` if the object being dragged was deleted. Else `LV_RES_OK`.
+ */
+lv_res_t lv_indev_finish_drag(lv_indev_t * indev);
+
 /**
  * Do nothing until the next release
  * @param indev pointer to an input device
  */
 void lv_indev_wait_release(lv_indev_t * indev);
 
+
+/**
+ * Gets a pointer to the currently active object in indev proc functions.
+ * NULL if no object is currently being handled or if groups aren't used.
+ * @return pointer to currently active object
+ */
+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 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);
+
 /**
  * Get a pointer to the indev read task to
  * modify its parameters with `lv_task_...` functions.
@@ -141,13 +173,6 @@ void lv_indev_wait_release(lv_indev_t * indev);
  */
 lv_task_t * lv_indev_get_read_task(lv_disp_t * indev);
 
-/**
- * Gets a pointer to the currently active object in indev proc functions.
- * NULL if no object is currently being handled or if groups aren't used.
- * @return pointer to currently active object
- */
-lv_obj_t * lv_indev_get_obj_act(void);
-
 /**********************
  *      MACROS
  **********************/

src/lv_core/lv_obj_style_dec.h

@@ -0,0 +1,302 @@
+
+/**
+ * @file lv_obj_style_dec.h
+ *
+ */
+
+#ifndef LV_OBJ_STYLE_DEC_H
+#define LV_OBJ_STYLE_DEC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**
+ * Macro to declare the most important style set/get API functions.
+ *
+ * Get the value of a style property from an object in the object's current state
+ * -----------------------------------------------------------------------------
+ *  - Get the value of a style property from an object in the object's current state.
+ *  - Transition animation is taken into account.
+ *  - If the property is not set in the object's styles check the parent(s) if the property can be inherited
+ *  - If still not found return a default value.
+ *  - For example:
+ *      `lv_style_int_t w = lv_obj_get_style_border_width(btn1, LV_BTN_PART_MAIN);`
+ *
+ * Set a local style property for an object in a given state
+ * ---------------------------------------------------------
+ *  - For example:
+ *      `lv_obj_set_style_local_border_width(btn1, LV_BTN_PART_MAIN, LV_STATE_PRESSED, 2);`
+ *
+ * Get a local style property's value of an object in a given state
+ * ----------------------------------------------------------------
+ *  - Return the best matching property in the given state.
+ *  - E.g. if `state` parameter is LV_STATE_PRESSED | LV_STATE_CHECKED` but the property defined only in
+ *    `LV_STATE_PRESSED` and `LV_STATE_DEFAULT` the best matching state is `LV_STATE_PRESSED`
+ *    (because it has higher precedence) and it will be returned.
+ *  - If the property is not found even in `LV_STATE_DEFAULT` `-1` is returned.
+ *  - For example:
+ *      `//Type of result should be lv_style_int_t/lv_opa_t/lv_color_t/const void * according to the type of the property`
+ *      `lv_style_int_t result;`
+ *      `lv_obj_get_style_local_border_width(btn1, LV_BTN_PART_MAIN, LV_STATE_PRESSED, &result);`
+ *      `if(weight > 0) ...the property is found and loaded into result...`
+ *
+ * Get the value from a style in a given state
+ * -------------------------------------------
+ * - The same rules applies to the return value then for "lv_obj_get_style_local_...()" above
+ * - For example
+ *      `int16_t weight = lv_style_get_border_width(&style1, LV_STATE_PRESSED, &result);`
+ *      `if(weight > 0) ...the property is found and loaded into result...`
+
+ * Set a value in a style in a given state
+ * ---------------------------------------
+ * - For example
+ *      `lv_style_set_border_width(&style1, LV_STATE_PRESSED, 2);`
+ */
+
+#define _OBJ_GET_STYLE_scalar(prop_name, func_name, value_type, style_type)                         \
+    static inline value_type lv_obj_get_style_##func_name (const lv_obj_t * obj, uint8_t part)      \
+    {                                                                                               \
+        return (value_type) _lv_obj_get_style##style_type (obj, part, LV_STYLE_##prop_name);        \
+    }
+
+#define _OBJ_GET_STYLE_nonscalar(prop_name, func_name, value_type, style_type)                      \
+    static inline value_type lv_obj_get_style_##func_name (const lv_obj_t * obj, uint8_t part)      \
+    {                                                                                               \
+        return _lv_obj_get_style##style_type (obj, part, LV_STYLE_##prop_name);                     \
+    }
+
+#define _OBJ_SET_STYLE_LOCAL_scalar(prop_name, func_name, value_type, style_type)                                               \
+    static inline void lv_obj_set_style_local_##func_name (lv_obj_t * obj, uint8_t part, lv_state_t state, value_type value)    \
+    {                                                                                                                           \
+        _lv_obj_set_style_local##style_type (obj, part, LV_STYLE_##prop_name | (state << LV_STYLE_STATE_POS), value);           \
+    }
+
+#define _OBJ_SET_STYLE_LOCAL_nonscalar(prop_name, func_name, value_type, style_type)                                            \
+    static inline void lv_obj_set_style_local_##func_name (lv_obj_t * obj, uint8_t part, lv_state_t state, value_type value)    \
+    {                                                                                                                           \
+        _lv_obj_set_style_local##style_type (obj, part, LV_STYLE_##prop_name | (state << LV_STYLE_STATE_POS), value);           \
+    }
+
+#define _OBJ_SET_STYLE_scalar(prop_name, func_name, value_type, style_type)                                             \
+    static inline void lv_style_set_##func_name (lv_style_t * style, lv_state_t state, value_type value)                 \
+    {                                                                                                                    \
+        _lv_style_set##style_type (style, LV_STYLE_##prop_name | (state << LV_STYLE_STATE_POS), value);                  \
+    }
+
+#define _OBJ_SET_STYLE_nonscalar(prop_name, func_name, value_type, style_type)                                          \
+    static inline void lv_style_set_##func_name (lv_style_t * style, lv_state_t state, value_type value)                 \
+    {                                                                                                                    \
+        _lv_style_set##style_type (style, LV_STYLE_##prop_name | (state << LV_STYLE_STATE_POS), value);                  \
+    }
+
+#define _LV_OBJ_STYLE_SET_GET_DECLARE(prop_name, func_name, value_type, style_type, scalar)                             \
+    _OBJ_GET_STYLE_##scalar(prop_name, func_name, value_type, style_type)                                               \
+    _OBJ_SET_STYLE_LOCAL_##scalar(prop_name, func_name, value_type, style_type)                                         \
+    _OBJ_SET_STYLE_##scalar(prop_name, func_name, value_type, style_type)
+
+_LV_OBJ_STYLE_SET_GET_DECLARE(RADIUS, radius, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(CLIP_CORNER, clip_corner, bool, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SIZE, size, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSFORM_WIDTH, transform_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSFORM_HEIGHT, transform_height, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSFORM_ANGLE, transform_angle, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSFORM_ZOOM, transform_zoom, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(OPA_SCALE, opa_scale, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PAD_TOP, pad_top, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PAD_BOTTOM, pad_bottom, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PAD_LEFT, pad_left, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PAD_RIGHT, pad_right, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PAD_INNER, pad_inner, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(MARGIN_TOP, margin_top, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(MARGIN_BOTTOM, margin_bottom, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(MARGIN_LEFT, margin_left, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(MARGIN_RIGHT, margin_right, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BG_BLEND_MODE, bg_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BG_MAIN_STOP, bg_main_stop, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BG_GRAD_STOP, bg_grad_stop, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BG_GRAD_DIR, bg_grad_dir, lv_grad_dir_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BG_COLOR, bg_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BG_GRAD_COLOR, bg_grad_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BG_OPA, bg_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BORDER_WIDTH, border_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BORDER_SIDE, border_side, lv_border_side_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BORDER_BLEND_MODE, border_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BORDER_POST, border_post, bool, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BORDER_COLOR, border_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(BORDER_OPA, border_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(OUTLINE_WIDTH, outline_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(OUTLINE_PAD, outline_pad, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(OUTLINE_BLEND_MODE, outline_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(OUTLINE_COLOR, outline_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(OUTLINE_OPA, outline_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SHADOW_WIDTH, shadow_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SHADOW_OFS_X, shadow_ofs_x, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SHADOW_OFS_Y, shadow_ofs_y, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SHADOW_SPREAD, shadow_spread, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SHADOW_BLEND_MODE, shadow_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SHADOW_COLOR, shadow_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SHADOW_OPA, shadow_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PATTERN_REPEAT, pattern_repeat, bool, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PATTERN_BLEND_MODE, pattern_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PATTERN_RECOLOR, pattern_recolor, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PATTERN_OPA, pattern_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PATTERN_RECOLOR_OPA, pattern_recolor_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(PATTERN_IMAGE, pattern_image, const void *, _ptr, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_LETTER_SPACE, value_letter_space, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_LINE_SPACE, value_line_space, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_BLEND_MODE, value_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_OFS_X, value_ofs_x, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_OFS_Y, value_ofs_y, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_ALIGN, value_align, lv_align_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_COLOR, value_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_OPA, value_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_FONT, value_font, const lv_font_t *, _ptr, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(VALUE_STR, value_str, const char *, _ptr, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TEXT_LETTER_SPACE, text_letter_space, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TEXT_LINE_SPACE, text_line_space, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TEXT_DECOR, text_decor, lv_text_decor_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TEXT_BLEND_MODE, text_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TEXT_COLOR, text_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TEXT_SEL_COLOR, text_sel_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TEXT_OPA, text_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TEXT_FONT, text_font, const lv_font_t *, _ptr, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(LINE_WIDTH, line_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(LINE_BLEND_MODE, line_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(LINE_DASH_WIDTH, line_dash_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(LINE_DASH_GAP, line_dash_gap, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(LINE_ROUNDED, line_rounded, bool, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(LINE_COLOR, line_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(LINE_OPA, line_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(IMAGE_BLEND_MODE, image_blend_mode, lv_blend_mode_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(IMAGE_RECOLOR, image_recolor, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(IMAGE_OPA, image_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(IMAGE_RECOLOR_OPA, image_recolor_opa, lv_opa_t, _opa, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_TIME, transition_time, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_DELAY, transition_delay, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_PROP_1, transition_prop_1, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_PROP_2, transition_prop_2, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_PROP_3, transition_prop_3, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_PROP_4, transition_prop_4, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_PROP_5, transition_prop_5, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_PROP_6, transition_prop_6, lv_style_int_t, _int, scalar)
+#if LV_USE_ANIMATION
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_PATH, transition_path, lv_anim_path_t *, _ptr, scalar)
+#else
+/*For compatibility*/
+_LV_OBJ_STYLE_SET_GET_DECLARE(TRANSITION_PATH, transition_path, const void *, _ptr, scalar)
+#endif
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_WIDTH, scale_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_BORDER_WIDTH, scale_border_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_END_BORDER_WIDTH, scale_end_border_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_END_LINE_WIDTH, scale_end_line_width, lv_style_int_t, _int, scalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_GRAD_COLOR, scale_grad_color, lv_color_t, _color, nonscalar)
+_LV_OBJ_STYLE_SET_GET_DECLARE(SCALE_END_COLOR, scale_end_color, lv_color_t, _color, nonscalar)
+
+#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
+
+#endif /*LV_OBJ_H*/

src/lv_core/lv_refr.c

@@ -13,11 +13,18 @@
 #include "../lv_hal/lv_hal_disp.h"
 #include "../lv_misc/lv_task.h"
 #include "../lv_misc/lv_mem.h"
+#include "../lv_misc/lv_math.h"
 #include "../lv_misc/lv_gc.h"
 #include "../lv_draw/lv_draw.h"
+#include "../lv_font/lv_font_fmt_txt.h"
+#include "../lv_gpu/lv_gpu_stm32_dma2d.h"
+
+#if LV_USE_PERF_MONITOR
+    #include "../lv_widgets/lv_label.h"
+#endif
 
 #if defined(LV_GC_INCLUDE)
-#include LV_GC_INCLUDE
+    #include LV_GC_INCLUDE
 #endif /* LV_ENABLE_GC */
 
 /*********************
@@ -59,7 +66,7 @@ static lv_disp_t * disp_refr; /*Display being refreshed*/
 /**
  * Initialize the screen refresh subsystem
  */
-void lv_refr_init(void)
+void _lv_refr_init(void)
 {
     /*Nothing to do*/
 }
@@ -73,13 +80,18 @@ void lv_refr_init(void)
  */
 void lv_refr_now(lv_disp_t * disp)
 {
+#if LV_USE_ANIMATION
+    lv_anim_refr_now();
+#endif
+
     if(disp) {
-        lv_disp_refr_task(disp->refr_task);
-    } else {
+        _lv_disp_refr_task(disp->refr_task);
+    }
+    else {
         lv_disp_t * d;
         d = lv_disp_get_next(NULL);
         while(d) {
-            lv_disp_refr_task(d->refr_task);
+            _lv_disp_refr_task(d->refr_task);
             d = lv_disp_get_next(d);
         }
     }
@@ -91,7 +103,7 @@ void lv_refr_now(lv_disp_t * disp)
  * @param disp pointer to display where the area should be invalidated (NULL can be used if there is
  * only one display)
  */
-void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
+void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
 {
     if(!disp) disp = lv_disp_get_default();
     if(!disp) return;
@@ -111,7 +123,7 @@ void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
     lv_area_t com_area;
     bool suc;
 
-    suc = lv_area_intersect(&com_area, area_p, &scr_area);
+    suc = _lv_area_intersect(&com_area, area_p, &scr_area);
 
     /*The area is truncated to the screen*/
     if(suc != false) {
@@ -120,17 +132,19 @@ void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
         /*Save only if this area is not in one of the saved areas*/
         uint16_t i;
         for(i = 0; i < disp->inv_p; i++) {
-            if(lv_area_is_in(&com_area, &disp->inv_areas[i]) != false) return;
+            if(_lv_area_is_in(&com_area, &disp->inv_areas[i], 0) != false) return;
         }
 
         /*Save the area*/
         if(disp->inv_p < LV_INV_BUF_SIZE) {
             lv_area_copy(&disp->inv_areas[disp->inv_p], &com_area);
-        } else { /*If no place for the area add the screen*/
+        }
+        else {   /*If no place for the area add the screen*/
             disp->inv_p = 0;
             lv_area_copy(&disp->inv_areas[disp->inv_p], &scr_area);
         }
         disp->inv_p++;
+        lv_task_set_prio(disp->refr_task, LV_REFR_TASK_PRIO);
     }
 }
 
@@ -138,18 +152,18 @@ void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p)
  * Get the display which is being refreshed
  * @return the display being refreshed
  */
-lv_disp_t * lv_refr_get_disp_refreshing(void)
+lv_disp_t * _lv_refr_get_disp_refreshing(void)
 {
     return disp_refr;
 }
 
 /**
  * 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
  */
-void lv_refr_set_disp_refreshing(lv_disp_t * disp)
+void _lv_refr_set_disp_refreshing(lv_disp_t * disp)
 {
     disp_refr = disp;
 }
@@ -158,14 +172,28 @@ void lv_refr_set_disp_refreshing(lv_disp_t * disp)
  * Called periodically to handle the refreshing
  * @param task pointer to the task itself
  */
-void lv_disp_refr_task(lv_task_t * task)
+void _lv_disp_refr_task(lv_task_t * task)
 {
     LV_LOG_TRACE("lv_refr_task: started");
 
     uint32_t start = lv_tick_get();
+    uint32_t elaps = 0;
 
     disp_refr = task->user_data;
 
+#if LV_USE_PERF_MONITOR == 0
+    /* Ensure the task does not run again automatically.
+     * This is done before refreshing in case refreshing invalidates something else.
+     */
+    lv_task_set_prio(task, LV_TASK_PRIO_OFF);
+#endif
+
+    /*Do nothing if there is no active screen*/
+    if(disp_refr->act_scr == NULL) {
+        disp_refr->inv_p = 0;
+        return;
+    }
+
     lv_refr_join_area();
 
     lv_refr_areas();
@@ -174,50 +202,110 @@ 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);
+        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);
 
-            /*Flush the content of the VDB*/
-            lv_refr_vdb_flush();
+                /*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)
-                ;
+                /* 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);
 
-            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_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
 
-            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) {
-                    lv_coord_t y;
-                    uint32_t start_offs =
-                        (hres * disp_refr->inv_areas[a].y1 + disp_refr->inv_areas[a].x1) * sizeof(lv_color_t);
-                    uint32_t line_length = lv_area_get_width(&disp_refr->inv_areas[a]) * sizeof(lv_color_t);
+                uint8_t * buf_act = (uint8_t *)vdb->buf_act;
+                uint8_t * buf_ina = (uint8_t *)vdb->buf_act == vdb->buf1 ? vdb->buf2 : vdb->buf1;
 
-                    for(y = disp_refr->inv_areas[a].y1; y <= disp_refr->inv_areas[a].y2; y++) {
-                        memcpy(buf_act + start_offs, buf_ina + start_offs, line_length);
-                        start_offs += hres * sizeof(lv_color_t);
+                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*/
-        memset(disp_refr->inv_areas, 0, sizeof(disp_refr->inv_areas));
-        memset(disp_refr->inv_area_joined, 0, sizeof(disp_refr->inv_area_joined));
+        _lv_memset_00(disp_refr->inv_areas, sizeof(disp_refr->inv_areas));
+        _lv_memset_00(disp_refr->inv_area_joined, sizeof(disp_refr->inv_area_joined));
         disp_refr->inv_p = 0;
 
+        elaps = lv_tick_elaps(start);
         /*Call monitor cb if present*/
         if(disp_refr->driver.monitor_cb) {
-            disp_refr->driver.monitor_cb(&disp_refr->driver, lv_tick_elaps(start), px_num);
+            disp_refr->driver.monitor_cb(&disp_refr->driver, elaps, px_num);
         }
     }
 
-    lv_draw_free_buf();
+    _lv_mem_buf_free_all();
+    _lv_font_clean_up_fmt_txt();
+
+#if LV_USE_PERF_MONITOR && LV_USE_LABEL
+    static lv_obj_t * perf_label = NULL;
+    if(perf_label == NULL) {
+        perf_label = lv_label_create(lv_layer_sys(), NULL);
+        lv_label_set_align(perf_label, LV_LABEL_ALIGN_RIGHT);
+        lv_obj_set_style_local_bg_opa(perf_label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_OPA_COVER);
+        lv_obj_set_style_local_bg_color(perf_label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_BLACK);
+        lv_obj_set_style_local_text_color(perf_label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, LV_COLOR_WHITE);
+        lv_obj_set_style_local_pad_top(perf_label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, 3);
+        lv_obj_set_style_local_pad_bottom(perf_label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, 3);
+        lv_obj_set_style_local_pad_left(perf_label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, 3);
+        lv_obj_set_style_local_pad_right(perf_label, LV_LABEL_PART_MAIN, LV_STATE_DEFAULT, 3);
+        lv_label_set_text(perf_label, "?");
+        lv_obj_align(perf_label, NULL, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
+    }
+
+    static uint32_t perf_last_time = 0;
+    static uint32_t elaps_max = 1;
+    if(lv_tick_elaps(perf_last_time) < 300) {
+        elaps_max = LV_MATH_MAX(elaps, elaps_max);
+    }
+    else {
+        perf_last_time = lv_tick_get();
+        uint32_t fps = 1000 / (elaps_max == 0 ? 1 : elaps_max);
+        elaps_max = 1;
+        uint32_t fps_limit = 1000 / disp_refr->refr_task->period;
+        if(fps > fps_limit) fps = fps_limit;
+
+        uint32_t cpu = 100 - lv_task_get_idle();
+        lv_label_set_text_fmt(perf_label, "%d FPS\n%d%% CPU", fps, cpu);
+        lv_obj_align(perf_label, NULL, LV_ALIGN_IN_BOTTOM_RIGHT, 0, 0);
+    }
+#endif
 
     LV_LOG_TRACE("lv_refr_task: ready");
 }
@@ -245,11 +333,11 @@ static void lv_refr_join_area(void)
             }
 
             /*Check if the areas are on each other*/
-            if(lv_area_is_on(&disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]) == false) {
+            if(_lv_area_is_on(&disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]) == false) {
                 continue;
             }
 
-            lv_area_join(&joined_area, &disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]);
+            _lv_area_join(&joined_area, &disp_refr->inv_areas[join_in], &disp_refr->inv_areas[join_from]);
 
             /*Join two area only if the joined area size is smaller*/
             if(lv_area_get_size(&joined_area) < (lv_area_get_size(&disp_refr->inv_areas[join_in]) +
@@ -269,12 +357,28 @@ static void lv_refr_join_area(void)
 static void lv_refr_areas(void)
 {
     px_num = 0;
-    uint32_t i;
+
+    if(disp_refr->inv_p == 0) return;
+
+    /*Find the last area which will be drawn*/
+    int32_t i;
+    int32_t last_i = 0;
+    for(i = disp_refr->inv_p - 1; i >= 0; i--) {
+        if(disp_refr->inv_area_joined[i] == 0) {
+            last_i = i;
+            break;
+        }
+    }
+
+    disp_refr->driver.buffer->last_area = 0;
+    disp_refr->driver.buffer->last_part = 0;
 
     for(i = 0; i < disp_refr->inv_p; i++) {
         /*Refresh the unjoined areas*/
         if(disp_refr->inv_area_joined[i] == 0) {
 
+            if(i == last_i) disp_refr->driver.buffer->last_area = 1;
+            disp_refr->driver.buffer->last_part = 0;
             lv_refr_area(&disp_refr->inv_areas[i]);
 
             if(disp_refr->driver.monitor_cb) px_num += lv_area_get_size(&disp_refr->inv_areas[i]);
@@ -296,6 +400,7 @@ static void lv_refr_area(const lv_area_t * area_p)
         vdb->area.x2        = lv_disp_get_hor_res(disp_refr) - 1;
         vdb->area.y1        = 0;
         vdb->area.y2        = lv_disp_get_ver_res(disp_refr) - 1;
+        disp_refr->driver.buffer->last_part = 1;
         lv_refr_area_part(area_p);
     }
     /*The buffer is smaller: refresh the area in parts*/
@@ -334,7 +439,8 @@ static void lv_refr_area(const lv_area_t * area_p)
                 LV_LOG_WARN("Can't set VDB height using the round function. (Wrong round_cb or to "
                             "small VDB)");
                 return;
-            } else {
+            }
+            else {
                 max_row = tmp.y2 + 1;
             }
         }
@@ -350,6 +456,7 @@ static void lv_refr_area(const lv_area_t * area_p)
             vdb->area.y2 = row + max_row - 1;
             if(vdb->area.y2 > y2) vdb->area.y2 = y2;
             row_last = vdb->area.y2;
+            if(y2 == row_last) disp_refr->driver.buffer->last_part = 1;
             lv_refr_area_part(area_p);
         }
 
@@ -361,7 +468,7 @@ static void lv_refr_area(const lv_area_t * area_p)
             vdb->area.y1 = row;
             vdb->area.y2 = y2;
 
-            /*Refresh this part too*/
+            disp_refr->driver.buffer->last_part = 1;
             lv_refr_area_part(area_p);
         }
     }
@@ -373,14 +480,14 @@ static void lv_refr_area(const lv_area_t * area_p)
  */
 static void lv_refr_area_part(const lv_area_t * area_p)
 {
-
     lv_disp_buf_t * vdb = lv_disp_get_buf(disp_refr);
 
     /*In non double buffered mode, before rendering the next part wait until the previous image is
      * flushed*/
     if(lv_disp_is_double_buf(disp_refr) == false) {
-        while(vdb->flushing)
-            ;
+        while(vdb->flushing) {
+            if(disp_refr->driver.wait_cb) disp_refr->driver.wait_cb(&disp_refr->driver);
+        }
     }
 
     lv_obj_t * top_p;
@@ -388,7 +495,7 @@ static void lv_refr_area_part(const lv_area_t * area_p)
     /*Get the new mask from the original area and the act. VDB
      It will be a part of 'area_p'*/
     lv_area_t start_mask;
-    lv_area_intersect(&start_mask, area_p, &vdb->area);
+    _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));
@@ -418,10 +525,13 @@ static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
     lv_obj_t * found_p = NULL;
 
     /*If this object is fully cover the draw area check the children too */
-    if(lv_area_is_in(area_p, &obj->coords) && obj->hidden == 0) {
+    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;
+        if(design_res == LV_DESIGN_RES_MASKED) return NULL;
+
         lv_obj_t * i;
-        LV_LL_READ(obj->child_ll, i)
-        {
+        _LV_LL_READ(obj->child_ll, i) {
             found_p = lv_refr_get_top_obj(area_p, i);
 
             /*If a children is ok then break*/
@@ -430,11 +540,9 @@ static lv_obj_t * lv_refr_get_top_obj(const lv_area_t * area_p, lv_obj_t * obj)
             }
         }
 
-        /*If no better children check this object*/
+        /*If no better children use this object*/
         if(found_p == NULL) {
-            const lv_style_t * style = lv_obj_get_style(obj);
-            if(style->body.opa == LV_OPA_COVER && obj->design_cb(obj, area_p, LV_DESIGN_COVER_CHK) != false &&
-               lv_obj_get_opa_scale(obj) == LV_OPA_COVER) {
+            if(design_res == LV_DESIGN_RES_COVER) {
                 found_p = obj;
             }
         }
@@ -454,6 +562,7 @@ static void lv_refr_obj_and_children(lv_obj_t * top_p, const lv_area_t * mask_p)
      * but in special cases (e.g. if the screen has alpha) it won't.
      * In this case use the screen directly */
     if(top_p == NULL) top_p = lv_disp_get_scr_act(disp_refr);
+    if(top_p == NULL) return;  /*Shouldn't happen*/
 
     /*Refresh the top object and its children*/
     lv_refr_obj(top_p, mask_p);
@@ -467,16 +576,16 @@ static void lv_refr_obj_and_children(lv_obj_t * top_p, const lv_area_t * mask_p)
     /*Do until not reach the screen*/
     while(par != NULL) {
         /*object before border_p has to be redrawn*/
-        lv_obj_t * i = lv_ll_get_prev(&(par->child_ll), border_p);
+        lv_obj_t * i = _lv_ll_get_prev(&(par->child_ll), border_p);
 
         while(i != NULL) {
             /*Refresh the objects*/
             lv_refr_obj(i, mask_p);
-            i = lv_ll_get_prev(&(par->child_ll), i);
+            i = _lv_ll_get_prev(&(par->child_ll), i);
         }
 
         /*Call the post draw design function of the parents of the to object*/
-        par->design_cb(par, mask_p, LV_DESIGN_DRAW_POST);
+        if(par->design_cb) par->design_cb(par, mask_p, LV_DESIGN_DRAW_POST);
 
         /*The new border will be there last parents,
          *so the 'younger' brothers of parent will be refreshed*/
@@ -508,29 +617,39 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
     obj_area.y1 -= ext_size;
     obj_area.x2 += ext_size;
     obj_area.y2 += ext_size;
-    union_ok = lv_area_intersect(&obj_ext_mask, mask_ori_p, &obj_area);
+    union_ok = _lv_area_intersect(&obj_ext_mask, mask_ori_p, &obj_area);
 
     /*Draw the parent and its children only if they ore on 'mask_parent'*/
     if(union_ok != false) {
 
         /* Redraw the object */
-        obj->design_cb(obj, &obj_ext_mask, LV_DESIGN_DRAW_MAIN);
+        if(obj->design_cb) obj->design_cb(obj, &obj_ext_mask, LV_DESIGN_DRAW_MAIN);
 
 #if MASK_AREA_DEBUG
         static lv_color_t debug_color = LV_COLOR_RED;
-        lv_draw_fill(&obj_ext_mask, &obj_ext_mask, debug_color, LV_OPA_50);
+        lv_draw_rect_dsc_t draw_dsc;
+        lv_draw_rect_dsc_init(&draw_dsc);
+        draw_dsc.bg_color.full = debug_color.full;
+        draw_dsc.bg_opa = LV_OPA_20;
+        draw_dsc.border_width = 2;
+        draw_dsc.border_opa = LV_OPA_50;
+        draw_dsc.border_color.full = (debug_color.full + 0x13) * 9;
+
+        lv_draw_rect(&obj_ext_mask, &obj_ext_mask, &draw_dsc);
         debug_color.full *= 17;
         debug_color.full += 0xA1;
+#if LV_COLOR_DEPTH == 32
+        debug_color.ch.alpha = 0xff;
+#endif
 #endif
         /*Create a new 'obj_mask' without 'ext_size' because the children can't be visible there*/
         lv_obj_get_coords(obj, &obj_area);
-        union_ok = lv_area_intersect(&obj_mask, mask_ori_p, &obj_area);
+        union_ok = _lv_area_intersect(&obj_mask, mask_ori_p, &obj_area);
         if(union_ok != false) {
             lv_area_t mask_child; /*Mask from obj and its child*/
             lv_obj_t * child_p;
             lv_area_t child_area;
-            LV_LL_READ_BACK(obj->child_ll, child_p)
-            {
+            _LV_LL_READ_BACK(obj->child_ll, child_p) {
                 lv_obj_get_coords(child_p, &child_area);
                 ext_size = child_p->ext_draw_pad;
                 child_area.x1 -= ext_size;
@@ -539,7 +658,7 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
                 child_area.y2 += ext_size;
                 /* Get the union (common parts) of original mask (from obj)
                  * and its child */
-                union_ok = lv_area_intersect(&mask_child, &obj_mask, &child_area);
+                union_ok = _lv_area_intersect(&mask_child, &obj_mask, &child_area);
 
                 /*If the parent and the child has common area then refresh the child */
                 if(union_ok) {
@@ -550,7 +669,7 @@ static void lv_refr_obj(lv_obj_t * obj, const lv_area_t * mask_ori_p)
         }
 
         /* If all the children are redrawn make 'post draw' design */
-        obj->design_cb(obj, &obj_ext_mask, LV_DESIGN_DRAW_POST);
+        if(obj->design_cb) obj->design_cb(obj, &obj_ext_mask, LV_DESIGN_DRAW_POST);
     }
 }
 
@@ -564,14 +683,18 @@ static void lv_refr_vdb_flush(void)
     /*In double buffered mode wait until the other buffer is flushed before flushing the current
      * one*/
     if(lv_disp_is_double_buf(disp_refr)) {
-        while(vdb->flushing)
-            ;
+        while(vdb->flushing) {
+            if(disp_refr->driver.wait_cb) disp_refr->driver.wait_cb(&disp_refr->driver);
+        }
     }
 
     vdb->flushing = 1;
 
+    if(disp_refr->driver.buffer->last_area && disp_refr->driver.buffer->last_part) vdb->flushing_last = 1;
+    else vdb->flushing_last = 0;
+
     /*Flush the rendered content to the display*/
-    lv_disp_t * disp = lv_refr_get_disp_refreshing();
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
     if(disp->driver.flush_cb) disp->driver.flush_cb(&disp->driver, &vdb->area, vdb->buf_act);
 
     if(vdb->buf1 && vdb->buf2) {

src/lv_core/lv_refr.h

@@ -20,6 +20,8 @@ extern "C" {
  *      DEFINES
  *********************/
 
+#define LV_REFR_TASK_PRIO LV_TASK_PRIO_MID
+
 /**********************
  *      TYPEDEFS
  **********************/
@@ -43,7 +45,7 @@ extern "C" {
 /**
  * Initialize the screen refresh subsystem
  */
-void lv_refr_init(void);
+void _lv_refr_init(void);
 
 /**
  * Redraw the invalidated areas now.
@@ -60,27 +62,27 @@ void lv_refr_now(lv_disp_t * disp);
  * @param disp pointer to display where the area should be invalidated (NULL can be used if there is
  * only one display)
  */
-void lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p);
+void _lv_inv_area(lv_disp_t * disp, const lv_area_t * area_p);
 
 /**
  * Get the display which is being refreshed
  * @return the display being refreshed
  */
-lv_disp_t * lv_refr_get_disp_refreshing(void);
+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
  */
-void lv_refr_set_disp_refreshing(lv_disp_t * disp);
+void _lv_refr_set_disp_refreshing(lv_disp_t * disp);
 
 /**
  * Called periodically to handle the refreshing
  * @param task pointer to the task itself
  */
-void lv_disp_refr_task(lv_task_t * task);
+void _lv_disp_refr_task(lv_task_t * task);
 
 /**********************
  *   STATIC FUNCTIONS

src/lv_core/lv_style.h

@@ -18,139 +18,288 @@ extern "C" {
 #include "../lv_misc/lv_color.h"
 #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"
 
 /*********************
  *      DEFINES
  *********************/
-#define LV_RADIUS_CIRCLE (LV_COORD_MAX) /**< A very big radius to always draw as circle*/
-#define LV_STYLE_DEGUG_SENTINEL_VALUE 0x12345678
 
+#define LV_RADIUS_CIRCLE (0x7FFF) /**< A very big radius to always draw as circle*/
 LV_EXPORT_CONST_INT(LV_RADIUS_CIRCLE);
 
+#define LV_DEBUG_STYLE_SENTINEL_VALUE       0x2288AAEE
+#define LV_DEBUG_STYLE_LIST_SENTINEL_VALUE  0x9977CCBB
+
+#define LV_STYLE_PROP_INIT(name, group, id, attr)  name = (((group << 4) + id) | ((attr) << 8))
+
+#define LV_STYLE_ID_MASK 0x00FF
+
+#define LV_STYLE_ATTR_NONE          0
+#define LV_STYLE_ATTR_INHERIT       (1 << 7)
+
+#define _LV_STYLE_CLOSEING_PROP     0xFF
+
+#define LV_STYLE_TRANS_NUM_MAX      6
+
+#define LV_STYLE_PROP_ALL 0xFF
+
 /**********************
  *      TYPEDEFS
  **********************/
 
 /*Border types (Use 'OR'ed values)*/
 enum {
-    LV_BORDER_NONE     = 0x00,
-    LV_BORDER_BOTTOM   = 0x01,
-    LV_BORDER_TOP      = 0x02,
-    LV_BORDER_LEFT     = 0x04,
-    LV_BORDER_RIGHT    = 0x08,
-    LV_BORDER_FULL     = 0x0F,
-    LV_BORDER_INTERNAL = 0x10, /**< FOR matrix-like objects (e.g. Button matrix)*/
+    LV_BORDER_SIDE_NONE     = 0x00,
+    LV_BORDER_SIDE_BOTTOM   = 0x01,
+    LV_BORDER_SIDE_TOP      = 0x02,
+    LV_BORDER_SIDE_LEFT     = 0x04,
+    LV_BORDER_SIDE_RIGHT    = 0x08,
+    LV_BORDER_SIDE_FULL     = 0x0F,
+    LV_BORDER_SIDE_INTERNAL = 0x10, /**< FOR matrix-like objects (e.g. Button matrix)*/
+    _LV_BORDER_SIDE_LAST
 };
-typedef uint8_t lv_border_part_t;
+typedef uint8_t lv_border_side_t;
 
-/*Shadow types*/
 enum {
-    LV_SHADOW_BOTTOM = 0, /**< Only draw bottom shadow */
-    LV_SHADOW_FULL,       /**< Draw shadow on all sides */
+    LV_GRAD_DIR_NONE,
+    LV_GRAD_DIR_VER,
+    LV_GRAD_DIR_HOR,
+    _LV_GRAD_DIR_LAST
 };
-typedef uint8_t lv_shadow_type_t;
 
-/**
- * Objects in LittlevGL can be assigned a style - which holds information about
- * how the object should be drawn.
- * 
- * This allows for easy customization without having to modify the object's design
- * function.
- */
-typedef struct
-{
-    uint8_t glass : 1; /**< 1: Do not inherit this style*/
+typedef uint8_t lv_grad_dir_t;
 
-    /** Object background. */
-    struct
-    {
-        lv_color_t main_color; /**< Object's main background color. */
-        lv_color_t grad_color; /**< Second color. If not equal to `main_color` a gradient will be drawn for the background. */
-        lv_coord_t radius; /**< Object's corner radius. You can use #LV_RADIUS_CIRCLE if you want to draw a circle. */
-        lv_opa_t opa; /**< Object's opacity (0-255). */
+/*Text decorations (Use 'OR'ed values)*/
+enum {
+    LV_TEXT_DECOR_NONE          = 0x00,
+    LV_TEXT_DECOR_UNDERLINE     = 0x01,
+    LV_TEXT_DECOR_STRIKETHROUGH = 0x02,
+    _LV_TEXT_DECOR_LAST
+};
 
-        struct
-        {
-            lv_color_t color; /**< Border color */
-            lv_coord_t width; /**< Border width */
-            lv_border_part_t part; /**< Which borders to draw */
-            lv_opa_t opa; /**< Border opacity. */
-        } border;
+typedef uint8_t lv_text_decor_t;
 
+typedef uint8_t lv_style_attr_t;
 
-        struct
-        {
-            lv_color_t color;
-            lv_coord_t width;
-            lv_shadow_type_t type; /**< Which parts of the shadow to draw */
-        } shadow;
+#define LV_STYLE_ATTR_GET_INHERIT(f) ((f)&0x80)
+#define LV_STYLE_ATTR_GET_STATE(f) ((f)&0x7F)
 
-        struct
-        {
-            lv_coord_t top;
-            lv_coord_t bottom;
-            lv_coord_t left;
-            lv_coord_t right;
-            lv_coord_t inner;
-        } padding;
-    } body;
+#define LV_STYLE_ID_VALUE 0x0   /*max 9 pcs*/
+#define LV_STYLE_ID_COLOR 0x9   /*max 3 pcs*/
+#define LV_STYLE_ID_OPA   0xC   /*max 2 pcs*/
+#define LV_STYLE_ID_PTR   0xE   /*max 2 pcs*/
 
-    /** Style for text drawn by this object. */
-    struct
-    {
-        lv_color_t color; /**< Text color */
-        lv_color_t sel_color; /**< Text selection background color. */
-        const lv_font_t * font;
-        lv_coord_t letter_space; /**< Space between letters */
-        lv_coord_t line_space; /**< Space between lines (vertical) */
-        lv_opa_t opa; /**< Text opacity */
-    } text;
+enum {
+    /*Skip 0th property*/
+    LV_STYLE_PROP_INIT(LV_STYLE_RADIUS,             0x0, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_CLIP_CORNER,        0x0, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_SIZE,               0x0, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    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_OPA_SCALE,          0x0, LV_STYLE_ID_OPA + 0,   LV_STYLE_ATTR_INHERIT),
 
-    /**< Style of images. */
-    struct
-    {
-        lv_color_t color; /**< Color to recolor the image with */
-        lv_opa_t intense; /**< Opacity of recoloring (0 means no recoloring) */
-        lv_opa_t opa; /**< Opacity of whole image */
-    } image;
+    LV_STYLE_PROP_INIT(LV_STYLE_PAD_TOP,            0x1, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PAD_BOTTOM,         0x1, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PAD_LEFT,           0x1, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PAD_RIGHT,          0x1, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PAD_INNER,          0x1, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_TOP,         0x1, LV_STYLE_ID_VALUE + 5, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_BOTTOM,      0x1, LV_STYLE_ID_VALUE + 6, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_LEFT,        0x1, LV_STYLE_ID_VALUE + 7, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_MARGIN_RIGHT,       0x1, LV_STYLE_ID_VALUE + 8, LV_STYLE_ATTR_NONE),
 
-    /**< Style of lines (not borders). */
-    struct
-    {
-        lv_color_t color;
-        lv_coord_t width;
-        lv_opa_t opa;
-        uint8_t rounded : 1; /**< 1: rounded line endings*/
-    } line;
+    LV_STYLE_PROP_INIT(LV_STYLE_BG_BLEND_MODE,      0x2, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BG_MAIN_STOP,       0x2, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BG_GRAD_STOP,       0x2, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BG_GRAD_DIR,        0x2, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BG_COLOR,           0x2, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BG_GRAD_COLOR,      0x2, LV_STYLE_ID_COLOR + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BG_OPA,             0x2, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_NONE),
 
-#if LV_USE_DEBUG
+    LV_STYLE_PROP_INIT(LV_STYLE_BORDER_WIDTH,       0x3, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BORDER_SIDE,        0x3, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BORDER_BLEND_MODE,  0x3, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BORDER_POST,        0x3, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BORDER_COLOR,       0x3, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_BORDER_OPA,         0x3, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_NONE),
+
+    LV_STYLE_PROP_INIT(LV_STYLE_OUTLINE_WIDTH,       0x4, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_OUTLINE_PAD,         0x4, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_OUTLINE_BLEND_MODE,  0x4, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_OUTLINE_COLOR,       0x4, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
+    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_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),
+    LV_STYLE_PROP_INIT(LV_STYLE_SHADOW_OPA,         0x5, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_NONE),
+
+    LV_STYLE_PROP_INIT(LV_STYLE_PATTERN_BLEND_MODE,    0x6, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PATTERN_REPEAT,        0x6, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PATTERN_RECOLOR,       0x6, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PATTERN_OPA,           0x6, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PATTERN_RECOLOR_OPA,   0x6, LV_STYLE_ID_OPA   + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_PATTERN_IMAGE,         0x6, LV_STYLE_ID_PTR   + 0, LV_STYLE_ATTR_NONE),
+
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_LETTER_SPACE,  0x7, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_LINE_SPACE,    0x7, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_BLEND_MODE,    0x7, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_OFS_X,         0x7, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_OFS_Y,         0x7, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_ALIGN,         0x7, LV_STYLE_ID_VALUE + 5, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_COLOR,         0x7, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_OPA,           0x7, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_FONT,          0x7, LV_STYLE_ID_PTR   + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_VALUE_STR,           0x7, LV_STYLE_ID_PTR   + 1, LV_STYLE_ATTR_NONE),
+
+    LV_STYLE_PROP_INIT(LV_STYLE_TEXT_LETTER_SPACE,  0x8, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_TEXT_LINE_SPACE,    0x8, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_TEXT_DECOR,         0x8, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_TEXT_BLEND_MODE,    0x8, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_TEXT_COLOR,         0x8, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_TEXT_SEL_COLOR,     0x8, LV_STYLE_ID_COLOR + 1, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_TEXT_OPA,           0x8, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_TEXT_FONT,          0x8, LV_STYLE_ID_PTR   + 0, LV_STYLE_ATTR_INHERIT),
+
+    LV_STYLE_PROP_INIT(LV_STYLE_LINE_WIDTH,         0x9, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_LINE_BLEND_MODE,    0x9, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_LINE_DASH_WIDTH,    0x9, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_LINE_DASH_GAP,      0x9, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_LINE_ROUNDED,       0x9, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_LINE_COLOR,         0x9, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_LINE_OPA,           0x9, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_NONE),
+
+    LV_STYLE_PROP_INIT(LV_STYLE_IMAGE_BLEND_MODE,   0xA, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_IMAGE_RECOLOR,      0xA, LV_STYLE_ID_COLOR + 0, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_IMAGE_OPA,          0xA, LV_STYLE_ID_OPA   + 0, LV_STYLE_ATTR_INHERIT),
+    LV_STYLE_PROP_INIT(LV_STYLE_IMAGE_RECOLOR_OPA,  0xA, LV_STYLE_ID_OPA   + 1, LV_STYLE_ATTR_INHERIT),
+
+    LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_TIME,    0xB, LV_STYLE_ID_VALUE + 0, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_DELAY,   0xB, LV_STYLE_ID_VALUE + 1, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_PROP_1,  0xB, LV_STYLE_ID_VALUE + 2, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_PROP_2,  0xB, LV_STYLE_ID_VALUE + 3, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_PROP_3,  0xB, LV_STYLE_ID_VALUE + 4, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_PROP_4,  0xB, LV_STYLE_ID_VALUE + 5, LV_STYLE_ATTR_NONE),
+    LV_STYLE_PROP_INIT(LV_STYLE_TRANSITION_PROP_5,  0xB, LV_STYLE_ID_VALUE + 6, LV_STYLE_ATTR_NONE),
+    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_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),
+};
+
+typedef uint16_t lv_style_property_t;
+
+#define LV_STYLE_STATE_POS       8
+#define LV_STYLE_STATE_MASK      0x7F00
+#define LV_STYLE_INHERIT_MASK    0x8000
+
+typedef uint16_t lv_style_state_t;
+
+typedef struct {
+    uint8_t * map;
 #if LV_USE_ASSERT_STYLE
-    uint32_t debug_sentinel; /**<Should `LV_STYLE_DEGUG_SENTINEL_VALUE` to indicate that the style is valid*/
+    uint32_t sentinel;
 #endif
-#endif
-
 } lv_style_t;
 
-#if LV_USE_ANIMATION
-/** Data structure for style animations. */
-typedef struct
-{
-    lv_style_t style_start; /*Save not only pointers because can be same as 'style_anim' then it
-                               will be modified too*/
-    lv_style_t style_end;
-    lv_style_t * style_anim;
-    lv_anim_ready_cb_t ready_cb;
-} lv_style_anim_dsc_t;
+typedef int16_t lv_style_int_t;
+
+typedef struct {
+    lv_style_t ** style_list;
+#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*/
+} lv_style_list_t;
 
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
 /**
- *  Init the basic styles
+ * Initialize a style
+ * @param style pointer to a style to initialize
  */
-void lv_style_init(void);
+void lv_style_init(lv_style_t * style);
+
+/**
+ * Copy a style with all its properties
+ * @param style_dest pointer to the destination style. (Should be initialized with `lv_style_init()`)
+ * @param style_src pointer to the source (to copy )style
+ */
+void lv_style_copy(lv_style_t * style_dest, const lv_style_t * style_src);
+
+/**
+ * Initialize a style list
+ * @param list a style list to initialize
+ */
+void lv_style_list_init(lv_style_list_t * list);
+
+/**
+ * Copy a style list with all its styles and local style properties
+ * @param list_dest pointer to the destination style list. (should be initialized with `lv_style_list_init()`)
+ * @param list_src pointer to the source (to copy) style list.
+ */
+void lv_style_list_copy(lv_style_list_t * list_dest, const lv_style_list_t * list_src);
+
+/**
+ * Add a style to a style list.
+ * Only the the style pointer will be saved so the shouldn't be a local variable.
+ * (It should be static, global or dynamically allocated)
+ * @param list pointer to a style list
+ * @param style pointer to a style to add
+ */
+void _lv_style_list_add_style(lv_style_list_t * list, lv_style_t * style);
+
+/**
+ * Remove a style from a style list
+ * @param style_list pointer to a style list
+ * @param style pointer to a style to remove
+ */
+void _lv_style_list_remove_style(lv_style_list_t * list, lv_style_t * style);
+
+/**
+ * Remove all styles added from style list, clear the local style, transition style and free all allocated memories.
+ * Leave `ignore_trans` flag as it is.
+ * @param list pointer to a style list.
+ */
+void _lv_style_list_reset(lv_style_list_t * style_list);
+
+static inline lv_style_t * lv_style_list_get_style(lv_style_list_t * list, uint8_t id)
+{
+    if(list->has_trans && list->skip_trans) id++;
+    if(list->style_cnt == 0 || id >= list->style_cnt) return NULL;
+    return list->style_list[id];
+}
+
+/**
+ * Clear all properties from a style and all allocated memories.
+ * @param style pointer to a style
+ */
+void lv_style_reset(lv_style_t * style);
+
+/**
+ * Get the size of the properties in a style in bytes
+ * @param style pointer to a style
+ * @return size of the properties in bytes
+ */
+uint16_t _lv_style_get_mem_size(const lv_style_t * style);
 
 /**
  * Copy a style to an other
@@ -160,123 +309,253 @@ void lv_style_init(void);
 void lv_style_copy(lv_style_t * dest, const lv_style_t * src);
 
 /**
- * Mix two styles according to a given ratio
- * @param start start style
- * @param end end style
- * @param res store the result style here
- * @param ratio the ratio of mix [0..256]; 0: `start` style; 256: `end` style
+ * Remove a property from a style
+ * @param style pointer to a style
+ * @param prop  a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @return true: the property was found and removed; false: the property wasn't found
  */
-void lv_style_mix(const lv_style_t * start, const lv_style_t * end, lv_style_t * res, uint16_t ratio);
-
-#if LV_USE_ANIMATION
+bool lv_style_remove_prop(lv_style_t * style, lv_style_property_t prop);
 
 /**
- * Initialize an animation variable.
- * E.g.:
- * lv_anim_t a;
- * lv_style_anim__init(&a);
- * lv_style_anim_set_...(&a);
- * lv_style_anim_create(&a);
- * @param a pointer to an `lv_anim_t` variable to initialize
+ * Set an integer typed property in a style.
+ * @param style pointer to a style where the property should be set
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note shouldn't be used directly. Use the specific property set functions instead.
+ *       For example: `lv_style_set_border_width()`
+ * @note for performance reasons it's not checked if the property really has integer type
  */
-void lv_style_anim_init(lv_anim_t * a);
+void _lv_style_set_int(lv_style_t * style, lv_style_property_t prop, lv_style_int_t value);
 
 /**
- *
- * @param a pointer to an initialized `lv_anim_t` variable
- * @param to_anim pointer to the style to animate
- * @param start pointer to a style to animate from (start value)
- * @param end pointer to a style to animate to (end value)
+ * Set a color typed property in a style.
+ * @param style pointer to a style where the property should be set
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_COLOR | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note shouldn't be used directly. Use the specific property set functions instead.
+ *       For example: `lv_style_set_border_color()`
+ * @note for performance reasons it's not checked if the property really has color type
  */
-void lv_style_anim_set_styles(lv_anim_t * a, lv_style_t * to_anim, const lv_style_t * start, const lv_style_t * end);
+void _lv_style_set_color(lv_style_t * style, lv_style_property_t prop, lv_color_t color);
 
 /**
- * Set the duration and delay of an animation
- * @param a pointer to an initialized `lv_anim_t` variable
- * @param duration duration of the animation in milliseconds
- * @param delay delay before the animation in milliseconds
+ * Set an opacity typed property in a style.
+ * @param style pointer to a style where the property should be set
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_OPA | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note shouldn't be used directly. Use the specific property set functions instead.
+ *       For example: `lv_style_set_border_opa()`
+ * @note for performance reasons it's not checked if the property really has opacity type
  */
-static inline void lv_style_anim_set_time(lv_anim_t * a, uint16_t duration, int16_t delay)
-{
-    lv_anim_set_time(a, duration, delay);
-}
+void _lv_style_set_opa(lv_style_t * style, lv_style_property_t prop, lv_opa_t opa);
 
 /**
- * Set a function call when the animation is ready
- * @param a pointer to an initialized `lv_anim_t` variable
- * @param ready_cb a function call when the animation is ready
+ * Set a pointer typed property in a style.
+ * @param style pointer to a style where the property should be set
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_TEXT_POINTER | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note shouldn't be used directly. Use the specific property set functions instead.
+ *       For example: `lv_style_set_border_width()`
+ * @note for performance reasons it's not checked if the property really has pointer type
  */
-static inline void lv_style_anim_set_ready_cb(lv_anim_t * a, lv_anim_ready_cb_t ready_cb)
-{
-    lv_style_anim_dsc_t * dsc = (lv_style_anim_dsc_t *)a->var;
-    dsc->ready_cb             = ready_cb;
-}
+void _lv_style_set_ptr(lv_style_t * style, lv_style_property_t prop, const void * p);
 
 /**
- * Make the animation to play back to when the forward direction is ready
- * @param a pointer to an initialized `lv_anim_t` variable
- * @param wait_time time in milliseconds to wait before starting the back direction
+ * Get an integer typed property from a style.
+ * @param style pointer to a style from where the property should be get
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param res pointer to a buffer to store the result value
+ * @return -1: the property wasn't found in the style.
+ *         The matching state bits of the desired state (in `prop`) and the best matching property's state
+ *         Higher value means match in higher precedence state.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_style_get_border_width()`
+ * @note for performance reasons it's not checked if the property really has integer type
  */
-static inline void lv_style_anim_set_playback(lv_anim_t * a, uint16_t wait_time)
-{
-    lv_anim_set_playback(a, wait_time);
-}
+int16_t _lv_style_get_int(const lv_style_t * style, lv_style_property_t prop, void * res);
 
 /**
- * Disable playback. (Disabled after `lv_anim_init()`)
- * @param a pointer to an initialized `lv_anim_t` variable
+ * Get a color typed property from a style.
+ * @param style pointer to a style from where the property should be get
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_COLOR | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param res pointer to a buffer to store the result value
+ * @return -1: the property wasn't found in the style.
+ *         The matching state bits of the desired state (in `prop`) and the best matching property's state
+ *         Higher value means match in higher precedence state.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_style_get_border_color()`
+ * @note for performance reasons it's not checked if the property really has color type
  */
-static inline void lv_style_anim_clear_playback(lv_anim_t * a)
-{
-    lv_anim_clear_playback(a);
-}
+int16_t _lv_style_get_color(const lv_style_t * style, lv_style_property_t prop, void * res);
 
 /**
- * Make the animation to start again when ready.
- * @param a pointer to an initialized `lv_anim_t` variable
- * @param wait_time time in milliseconds to wait before starting the animation again
+ * Get an opacity typed property from a style.
+ * @param style pointer to a style from where the property should be get
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_OPA | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param res pointer to a buffer to store the result value
+ * @return -1: the property wasn't found in the style.
+ *         The matching state bits of the desired state (in `prop`) and the best matching property's state
+ *         Higher value means match in higher precedence state.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_style_get_border_opa()`
+ * @note for performance reasons it's not checked if the property really has opacity type
  */
-static inline void lv_style_anim_set_repeat(lv_anim_t * a, uint16_t wait_time)
-{
-    lv_anim_set_repeat(a, wait_time);
-}
+int16_t _lv_style_get_opa(const lv_style_t * style, lv_style_property_t prop, void * res);
 
 /**
- * Disable repeat. (Disabled after `lv_anim_init()`)
- * @param a pointer to an initialized `lv_anim_t` variable
+ * Get a pointer typed property from a style.
+ * @param style pointer to a style from where the property should be get
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param res pointer to a buffer to store the result value
+ * @return -1: the property wasn't found in the style.
+ *         The matching state bits of the desired state (in `prop`) and the best matching property's state
+ *         Higher value means match in higher precedence state.
+ * @note shouldn't be used directly. Use the specific property get functions instead.
+ *       For example: `lv_style_get_text_font()`
+ * @note for performance reasons it's not checked if the property really has pointer type
  */
-static inline void lv_style_anim_clear_repeat(lv_anim_t * a)
-{
-    lv_anim_clear_repeat(a);
-}
+int16_t _lv_style_get_ptr(const lv_style_t * style, lv_style_property_t prop, void * res);
 
 /**
- * Create an animation
- * @param a an initialized 'anim_t' variable. Not required after call.
+ * Get the local style of a style list
+ * @param list pointer to a style list where the local property should be set
+ * @return pointer to the local style if exists else `NULL`.
  */
-static inline void lv_style_anim_create(lv_anim_t * a)
-{
-    lv_anim_create(a);
-}
+lv_style_t * lv_style_list_get_local_style(lv_style_list_t * list);
 
-#endif
+/**
+ * Get the transition style of a style list
+ * @param list pointer to a style list where the local property should be set
+ * @return pointer to the transition style if exists else `NULL`.
+ */
+lv_style_t * _lv_style_list_get_transition_style(lv_style_list_t * list);
+
+/**
+ * Allocate the transition style in a style list. If already exists simply return it.
+ * @param list pointer to a style list
+ * @return the transition style of a style list
+ */
+lv_style_t * _lv_style_list_add_trans_style(lv_style_list_t * list);
+
+/**
+ * Set a local integer typed property in a style list.
+ * @param list pointer to a style list where the local property should be set
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note for performance reasons it's not checked if the property really has integer type
+ */
+void _lv_style_list_set_local_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t value);
+
+/**
+ * Set a local color typed property in a style list.
+ * @param list pointer to a style list where the local property should be set
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_COLOR | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note for performance reasons it's not checked if the property really has color type
+ */
+void _lv_style_list_set_local_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t value);
+
+/**
+ * Set a local opacity typed property in a style list.
+ * @param list pointer to a style list where the local property should be set
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_OPA | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note for performance reasons it's not checked if the property really has opacity type
+ */
+void _lv_style_list_set_local_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t value);
+
+/**
+ * Set a local pointer typed property in a style list.
+ * @param list pointer to a style list where the local property should be set
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param value the value to set
+ * @note for performance reasons it's not checked if the property really has pointer type
+ */
+void _lv_style_list_set_local_ptr(lv_style_list_t * list, lv_style_property_t prop, const void * value);
+
+/**
+ * Get an integer typed property from a style list.
+ * It will return the property which match best with given state.
+ * @param list pointer to a style list from where the property should be get
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_WIDTH | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param res pointer to a buffer to store the result
+ * @return LV_RES_OK: there was a matching property in the list
+ *         LV_RES_INV: there was NO matching property in the list
+ * @note for performance reasons it's not checked if the property really has integer type
+ */
+lv_res_t _lv_style_list_get_int(lv_style_list_t * list, lv_style_property_t prop, lv_style_int_t * res);
+
+/**
+ * Get a color typed property from a style list.
+ * It will return the property which match best with given state.
+ * @param list pointer to a style list from where the property should be get
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_COLOR | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param res pointer to a buffer to store the result
+ * @return LV_RES_OK: there was a matching property in the list
+ *         LV_RES_INV: there was NO matching property in the list
+ * @note for performance reasons it's not checked if the property really has color type
+ */
+lv_res_t _lv_style_list_get_color(lv_style_list_t * list, lv_style_property_t prop, lv_color_t * res);
+
+
+/**
+ * Get an opacity typed property from a style list.
+ * It will return the property which match best with given state.
+ * @param list pointer to a style list from where the property should be get
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_BORDER_OPA | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param res pointer to a buffer to store the result
+ * @return LV_RES_OK: there was a matching property in the list
+ *         LV_RES_INV: there was NO matching property in the list
+ * @note for performance reasons it's not checked if the property really has opacity type
+ */
+lv_res_t _lv_style_list_get_opa(lv_style_list_t * list, lv_style_property_t prop, lv_opa_t * res);
+
+/**
+ * Get a pointer typed property from a style list.
+ * It will return the property which match best with given state.
+ * @param list pointer to a style list from where the property should be get
+ * @param prop a style property ORed with a state.
+ * E.g. `LV_STYLE_TEXT_FONT | (LV_STATE_PRESSED << LV_STYLE_STATE_POS)`
+ * @param res pointer to a buffer to store the result
+ * @return LV_RES_OK: there was a matching property in the list
+ *         LV_RES_INV: there was NO matching property in the list
+ * @note for performance reasons it's not checked if the property really has pointer type
+ */
+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
  *************************/
-extern lv_style_t lv_style_scr;
-extern lv_style_t lv_style_transp;
-extern lv_style_t lv_style_transp_fit;
-extern lv_style_t lv_style_transp_tight;
-extern lv_style_t lv_style_plain;
-extern lv_style_t lv_style_plain_color;
-extern lv_style_t lv_style_pretty;
-extern lv_style_t lv_style_pretty_color;
-extern lv_style_t lv_style_btn_rel;
-extern lv_style_t lv_style_btn_pr;
-extern lv_style_t lv_style_btn_tgl_rel;
-extern lv_style_t lv_style_btn_tgl_pr;
-extern lv_style_t lv_style_btn_ina;
 
 /**********************
  *      MACROS
@@ -285,14 +564,42 @@ extern lv_style_t lv_style_btn_ina;
 /**
  * Create and initialize a `static` style
  * Example:
- *     LV_STYLE_CREATE(my_style, &lv_style_plain);
+ *     LV_STYLE_CREATE(my_style, &style_to_copy);
  *   is equivalent to
  *     static lv_style_t my_style;
- *     lv_style_copy(my_style, &lv_style_plain);
- *
- * If the style to copy is `NULL` `lv_style_plain` will be used.
+ *     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_copy(&name, copy_p == NULL ? &lv_style_plain : copy_p);
+#define LV_STYLE_CREATE(name, copy_p) static lv_style_t name; lv_style_init(&name); lv_style_copy(&name, copy);
+
+
+
+#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" */

src/lv_draw/lv_draw.c

@@ -1,191 +0,0 @@
-/**
- * @file lv_draw.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include <stdio.h>
-#include <stdbool.h>
-#include "lv_draw.h"
-#include "../lv_core/lv_debug.h"
-#include "../lv_misc/lv_math.h"
-#include "../lv_misc/lv_log.h"
-#include "../lv_misc/lv_math.h"
-#include "../lv_misc/lv_mem.h"
-#include "../lv_misc/lv_gc.h"
-
-#if defined(LV_GC_INCLUDE)
-#include LV_GC_INCLUDE
-#endif /* LV_ENABLE_GC */
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static uint32_t draw_buf_size = 0;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Give a buffer with the given to use during drawing.
- * Be careful to not use the buffer while other processes are using it.
- * @param size the required size
- */
-void * lv_draw_get_buf(uint32_t size)
-{
-    if(size <= draw_buf_size) return LV_GC_ROOT(_lv_draw_buf);
-
-    LV_LOG_TRACE("lv_draw_get_buf: allocate");
-
-    draw_buf_size = size;
-
-    if(LV_GC_ROOT(_lv_draw_buf) == NULL) {
-        LV_GC_ROOT(_lv_draw_buf) = lv_mem_alloc(size);
-        LV_ASSERT_MEM(LV_GC_ROOT(_lv_draw_buf));
-        return LV_GC_ROOT(_lv_draw_buf);
-    }
-
-    LV_GC_ROOT(_lv_draw_buf) = lv_mem_realloc(LV_GC_ROOT(_lv_draw_buf), size);
-    LV_ASSERT_MEM(LV_GC_ROOT(_lv_draw_buf));
-    return LV_GC_ROOT(_lv_draw_buf);
-}
-
-/**
- * Free the draw buffer
- */
-void lv_draw_free_buf(void)
-{
-    if(LV_GC_ROOT(_lv_draw_buf)) {
-        lv_mem_free(LV_GC_ROOT(_lv_draw_buf));
-        LV_GC_ROOT(_lv_draw_buf) = NULL;
-        draw_buf_size = 0;
-    }
-}
-
-#if LV_ANTIALIAS
-
-/**
- * Get the opacity of a pixel based it's position in a line segment
- * @param seg segment length
- * @param px_id position of  of a pixel which opacity should be get [0..seg-1]
- * @param base_opa the base opacity
- * @return the opacity of the given pixel
- */
-lv_opa_t lv_draw_aa_get_opa(lv_coord_t seg, lv_coord_t px_id, lv_opa_t base_opa)
-{
-    /* How to calculate the opacity of pixels on the edges which makes the anti-aliasing?
-     * For example we have a line like this (y = -0.5 * x):
-     *
-     *  | _ _
-     *    * * |
-     *
-     * Anti-aliased pixels come to the '*' characters
-     * Calculate what percentage of the pixels should be covered if real line (not rasterized) would
-     * be drawn:
-     * 1. A real line should start on (0;0) and end on (2;1)
-     * 2. So the line intersection coordinates on the first pixel: (0;0) (1;0.5) -> 25% covered
-     * pixel in average
-     * 3. For the second pixel: (1;0.5) (2;1) -> 75% covered pixel in average
-     * 4. The equation: (px_id * 2 + 1) / (segment_width * 2)
-     *                   segment_width: the line segment which is being anti-aliased (was 2 in the
-     * example) px_id: pixel ID from 0 to  (segment_width - 1) result: [0..1] coverage of the pixel
-     */
-
-    /*Accelerate the common segment sizes to avoid division*/
-    static const lv_opa_t seg1[1] = {128};
-    static const lv_opa_t seg2[2] = {64, 192};
-    static const lv_opa_t seg3[3] = {42, 128, 212};
-    static const lv_opa_t seg4[4] = {32, 96, 159, 223};
-    static const lv_opa_t seg5[5] = {26, 76, 128, 178, 230};
-    static const lv_opa_t seg6[6] = {21, 64, 106, 148, 191, 234};
-    static const lv_opa_t seg7[7] = {18, 55, 91, 128, 164, 200, 237};
-    static const lv_opa_t seg8[8] = {16, 48, 80, 112, 143, 175, 207, 239};
-
-    static const lv_opa_t * seg_map[] = {seg1, seg2, seg3, seg4, seg5, seg6, seg7, seg8};
-
-    if(seg == 0)
-        return LV_OPA_TRANSP;
-    else if(seg < 8)
-        return (uint32_t)((uint32_t)seg_map[seg - 1][px_id] * base_opa) >> 8;
-    else {
-        return ((px_id * 2 + 1) * base_opa) / (2 * seg);
-    }
-}
-
-/**
- * Add a vertical  anti-aliasing segment (pixels with decreasing opacity)
- * @param x start point x coordinate
- * @param y start point y coordinate
- * @param length length of segment (negative value to start from 0 opacity)
- * @param mask draw only in this area
- * @param color color of pixels
- * @param opa maximum opacity
- */
-void lv_draw_aa_ver_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t * mask, lv_color_t color,
-                        lv_opa_t opa)
-{
-    bool aa_inv = false;
-    if(length < 0) {
-        aa_inv = true;
-        length = -length;
-    }
-
-    lv_coord_t i;
-    for(i = 0; i < length; i++) {
-        lv_opa_t px_opa = lv_draw_aa_get_opa(length, i, opa);
-        if(aa_inv) px_opa = opa - px_opa;
-        lv_draw_px(x, y + i, mask, color, px_opa);
-    }
-}
-
-/**
- * Add a horizontal anti-aliasing segment (pixels with decreasing opacity)
- * @param x start point x coordinate
- * @param y start point y coordinate
- * @param length length of segment (negative value to start from 0 opacity)
- * @param mask draw only in this area
- * @param color color of pixels
- * @param opa maximum opacity
- */
-void lv_draw_aa_hor_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t * mask, lv_color_t color,
-                        lv_opa_t opa)
-{
-    bool aa_inv = false;
-    if(length < 0) {
-        aa_inv = true;
-        length = -length;
-    }
-
-    lv_coord_t i;
-    for(i = 0; i < length; i++) {
-        lv_opa_t px_opa = lv_draw_aa_get_opa(length, i, opa);
-        if(aa_inv) px_opa = opa - px_opa;
-        lv_draw_px(x + i, y, mask, color, px_opa);
-    }
-}
-
-#endif
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/

src/lv_draw/lv_draw.h

@@ -13,16 +13,21 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#ifdef LV_CONF_INCLUDE_SIMPLE
-#include "lv_conf.h"
-#else
-#include "../../../lv_conf.h"
-#endif
+#include "../lv_conf_internal.h"
 
 #include "../lv_core/lv_style.h"
 #include "../lv_misc/lv_txt.h"
 #include "lv_img_decoder.h"
 
+#include "lv_draw_rect.h"
+#include "lv_draw_label.h"
+#include "lv_draw_img.h"
+#include "lv_draw_line.h"
+#include "lv_draw_triangle.h"
+#include "lv_draw_arc.h"
+#include "lv_draw_blend.h"
+#include "lv_draw_mask.h"
+
 /*********************
  *      DEFINES
  *********************/
@@ -35,54 +40,6 @@ extern "C" {
  * GLOBAL PROTOTYPES
  **********************/
 
-/**
- * Give a buffer with the given to use during drawing.
- * Be careful to not use the buffer while other processes are using it.
- * @param size the required size
- */
-void * lv_draw_get_buf(uint32_t size);
-
-/**
- * Free the draw buffer
- */
-void lv_draw_free_buf(void);
-
-#if LV_ANTIALIAS
-
-/**
- * Get the opacity of a pixel based it's position in a line segment
- * @param seg segment length
- * @param px_id position of  of a pixel which opacity should be get [0..seg-1]
- * @param base_opa the base opacity
- * @return the opacity of the given pixel
- */
-lv_opa_t lv_draw_aa_get_opa(lv_coord_t seg, lv_coord_t px_id, lv_opa_t base_opa);
-
-/**
- * Add a vertical  anti-aliasing segment (pixels with decreasing opacity)
- * @param x start point x coordinate
- * @param y start point y coordinate
- * @param length length of segment (negative value to start from 0 opacity)
- * @param mask draw only in this area
- * @param color color of pixels
- * @param opa maximum opacity
- */
-void lv_draw_aa_ver_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t * mask, lv_color_t color,
-                        lv_opa_t opa);
-
-/**
- * Add a horizontal anti-aliasing segment (pixels with decreasing opacity)
- * @param x start point x coordinate
- * @param y start point y coordinate
- * @param length length of segment (negative value to start from 0 opacity)
- * @param mask draw only in this area
- * @param color color of pixels
- * @param opa maximum opacity
- */
-void lv_draw_aa_hor_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_area_t * mask, lv_color_t color,
-                        lv_opa_t opa);
-#endif
-
 /**********************
  *  GLOBAL VARIABLES
  **********************/
@@ -94,13 +51,6 @@ void lv_draw_aa_hor_seg(lv_coord_t x, lv_coord_t y, lv_coord_t length, const lv_
 /**********************
  *   POST INCLUDES
  *********************/
-#include "lv_draw_basic.h"
-#include "lv_draw_rect.h"
-#include "lv_draw_label.h"
-#include "lv_draw_img.h"
-#include "lv_draw_line.h"
-#include "lv_draw_triangle.h"
-#include "lv_draw_arc.h"
 
 #ifdef __cplusplus
 } /* extern "C" */

src/lv_draw/lv_draw.mk

@@ -1,5 +1,5 @@
-CSRCS += lv_draw_basic.c
-CSRCS += lv_draw.c
+CSRCS += lv_draw_mask.c
+CSRCS += lv_draw_blend.c
 CSRCS += lv_draw_rect.c
 CSRCS += lv_draw_label.c
 CSRCS += lv_draw_line.c
@@ -8,8 +8,9 @@ CSRCS += lv_draw_arc.c
 CSRCS += lv_draw_triangle.c
 CSRCS += lv_img_decoder.c
 CSRCS += lv_img_cache.c
+CSRCS += lv_img_buf.c
 
-DEPPATH += --dep-path $(LVGL_DIR)/lvgl/src/lv_draw
-VPATH += :$(LVGL_DIR)/lvgl/src/lv_draw
+DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_draw
+VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_draw
 
-CFLAGS += "-I$(LVGL_DIR)lvgl/src/lv_draw"
+CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_draw"

src/lv_draw/lv_draw_arc.c

@@ -7,25 +7,43 @@
  *      INCLUDES
  *********************/
 #include "lv_draw_arc.h"
+#include "lv_draw_rect.h"
+#include "lv_draw_mask.h"
 #include "../lv_misc/lv_math.h"
 
 /*********************
  *      DEFINES
  *********************/
+#define SPLIT_RADIUS_LIMIT 10  /*With radius greater then this the arc will drawn in quarters. A quarter is drawn only if there is arc in it */
+#define SPLIT_ANGLE_GAP_LIMIT 60  /*With small gaps in the arc don't bother with splitting because there is nothing to skip.*/
 
 /**********************
  *      TYPEDEFS
  **********************/
+typedef struct {
+    lv_coord_t center_x;
+    lv_coord_t center_y;
+    lv_coord_t radius;
+    uint16_t start_angle;
+    uint16_t end_angle;
+    uint16_t start_quarter;
+    uint16_t end_quarter;
+    lv_coord_t width;
+    lv_draw_rect_dsc_t * draw_dsc;
+    const lv_area_t * draw_area;
+    const lv_area_t * clip_area;
+} quarter_draw_dsc_t;
+
 
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static void ver_line(lv_coord_t x, lv_coord_t y, const lv_area_t * mask, lv_coord_t len, lv_color_t color,
-                     lv_opa_t opa);
-static void hor_line(lv_coord_t x, lv_coord_t y, const lv_area_t * mask, lv_coord_t len, lv_color_t color,
-                     lv_opa_t opa);
-static bool deg_test_norm(uint16_t deg, uint16_t start, uint16_t end);
-static bool deg_test_inv(uint16_t deg, uint16_t start, uint16_t end);
+static void draw_quarter_0(quarter_draw_dsc_t * q);
+static void draw_quarter_1(quarter_draw_dsc_t * q);
+static void draw_quarter_2(quarter_draw_dsc_t * q);
+static void draw_quarter_3(quarter_draw_dsc_t * q);
+static void get_rounded_area(int16_t angle, lv_coord_t radius, uint8_t tickness, lv_area_t * res_area);
+
 
 /**********************
  *  STATIC VARIABLES
@@ -50,167 +68,101 @@ static bool deg_test_inv(uint16_t deg, uint16_t start, uint16_t end);
  * @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
  */
-void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius, const lv_area_t * mask,
-                 uint16_t start_angle, uint16_t end_angle, const lv_style_t * style, lv_opa_t opa_scale)
+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)
 {
-    lv_coord_t thickness = style->line.width;
-    if(thickness > radius) thickness = radius;
+    if(dsc->opa <= LV_OPA_MIN) return;
+    if(dsc->width == 0) return;
+    if(start_angle == end_angle) return;
 
-#if LV_ANTIALIAS
-    thickness--;
-    radius--;
-#endif
+    if(dsc->width > radius) dsc->width = radius;
 
-    lv_coord_t r_out = radius;
-    lv_coord_t r_in  = r_out - thickness;
-    int16_t deg_base;
-    int16_t deg;
-    lv_coord_t x_start[4];
-    lv_coord_t x_end[4];
+    lv_draw_rect_dsc_t cir_dsc;
+    lv_draw_rect_dsc_init(&cir_dsc);
+    cir_dsc.radius = LV_RADIUS_CIRCLE;
+    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_blend_mode = dsc->blend_mode;
 
-    lv_color_t color = style->line.color;
-    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->body.opa : (uint16_t)((uint16_t)style->body.opa * opa_scale) >> 8;
+    lv_area_t area;
+    area.x1 = center_x - radius;
+    area.y1 = center_y - radius;
+    area.x2 = center_x + radius - 1;  /*-1 because the center already belongs to the left/bottom part*/
+    area.y2 = center_y + radius - 1;
 
-    bool (*deg_test)(uint16_t, uint16_t, uint16_t);
-    if(start_angle <= end_angle)
-        deg_test = deg_test_norm;
-    else
-        deg_test = deg_test_inv;
+    /*Draw a full ring*/
+    if(start_angle + 360 == end_angle || start_angle == end_angle + 360) {
+        lv_draw_rect(&area, clip_area, &cir_dsc);
+        return;
+    }
 
-    int middle_r_out = r_out;
-#if !LV_ANTIALIAS
-    thickness--;
-    middle_r_out = r_out - 1;
-#endif
-    if(deg_test(270, start_angle, end_angle))
-        hor_line(center_x - middle_r_out, center_y, mask, thickness, color, opa); /*Left Middle*/
-    if(deg_test(90, start_angle, end_angle))
-        hor_line(center_x + r_in, center_y, mask, thickness, color, opa); /*Right Middle*/
-    if(deg_test(180, start_angle, end_angle))
-        ver_line(center_x, center_y - middle_r_out, mask, thickness, color, opa); /*Top Middle*/
-    if(deg_test(0, start_angle, end_angle))
-        ver_line(center_x, center_y + r_in, mask, thickness, color, opa); /*Bottom middle*/
+    if(start_angle >= 360) start_angle -= 360;
+    if(end_angle >= 360) end_angle -= 360;
 
-    uint32_t r_out_sqr = r_out * r_out;
-    uint32_t r_in_sqr  = r_in * r_in;
-#if LV_ANTIALIAS
-    uint32_t r_out_aa_sqr = (r_out + 1) * (r_out + 1);
-    uint32_t r_in_aa_sqr  = (r_in - 1) * (r_in - 1);
-#endif
-    int16_t xi;
-    int16_t yi;
-    for(yi = -r_out; yi < 0; yi++) {
-        x_start[0] = LV_COORD_MIN;
-        x_start[1] = LV_COORD_MIN;
-        x_start[2] = LV_COORD_MIN;
-        x_start[3] = LV_COORD_MIN;
-        x_end[0]   = LV_COORD_MIN;
-        x_end[1]   = LV_COORD_MIN;
-        x_end[2]   = LV_COORD_MIN;
-        x_end[3]   = LV_COORD_MIN;
-        int xe     = 0;
-        for(xi = -r_out; xi < 0; xi++) {
+    lv_draw_mask_angle_param_t mask_angle_param;
+    lv_draw_mask_angle_init(&mask_angle_param, center_x, center_y, start_angle, end_angle);
 
-            uint32_t r_act_sqr = xi * xi + yi * yi;
-#if LV_ANTIALIAS
-            if(r_act_sqr > r_out_aa_sqr) {
-                continue;
-            }
-#else
-            if(r_act_sqr > r_out_sqr) continue;
-#endif
+    int16_t mask_angle_id = lv_draw_mask_add(&mask_angle_param, NULL);
 
-            deg_base = lv_atan2(xi, yi) - 180;
+    int32_t angle_gap;
+    if(end_angle > start_angle) {
+        angle_gap = 360 - (end_angle - start_angle);
+    }
+    else {
+        angle_gap = start_angle - end_angle;
+    }
+    if(angle_gap > SPLIT_ANGLE_GAP_LIMIT && radius > SPLIT_RADIUS_LIMIT) {
+        /*Handle each quarter individually and skip which is empty*/
+        quarter_draw_dsc_t q_dsc;
+        q_dsc.center_x = center_x;
+        q_dsc.center_y = center_y;
+        q_dsc.radius = radius;
+        q_dsc.start_angle = start_angle;
+        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.draw_dsc =  &cir_dsc;
+        q_dsc.draw_area = &area;
+        q_dsc.clip_area = clip_area;
 
-#if LV_ANTIALIAS
-            int opa2 = -1;
-            if(r_act_sqr > r_out_sqr) {
-                opa2 = LV_OPA_100 * (r_out + 1) - lv_sqrt(LV_OPA_100 * LV_OPA_100 * r_act_sqr);
-                if(opa2 < LV_OPA_0)
-                    opa2 = LV_OPA_0;
-                else if(opa2 > LV_OPA_100)
-                    opa2 = LV_OPA_100;
-            } else if(r_act_sqr < r_in_sqr) {
-                if(xe == 0) xe = xi;
-                opa2 = lv_sqrt(LV_OPA_100 * LV_OPA_100 * r_act_sqr) - LV_OPA_100 * (r_in - 1);
-                if(opa2 < LV_OPA_0)
-                    opa2 = LV_OPA_0;
-                else if(opa2 > LV_OPA_100)
-                    opa2 = LV_OPA_100;
-                if(r_act_sqr < r_in_aa_sqr)
-                    break; /*No need to continue the iteration in x once we found the inner edge of the
-                              arc*/
-            }
-            if(opa2 != -1) {
-                if(deg_test(180 + deg_base, start_angle, end_angle)) {
-                    lv_draw_px(center_x + xi, center_y + yi, mask, color, opa2);
-                }
-                if(deg_test(360 - deg_base, start_angle, end_angle)) {
-                    lv_draw_px(center_x + xi, center_y - yi, mask, color, opa2);
-                }
-                if(deg_test(180 - deg_base, start_angle, end_angle)) {
-                    lv_draw_px(center_x - xi, center_y + yi, mask, color, opa2);
-                }
-                if(deg_test(deg_base, start_angle, end_angle)) {
-                    lv_draw_px(center_x - xi, center_y - yi, mask, color, opa2);
-                }
-                continue;
-            }
-#endif
+        draw_quarter_0(&q_dsc);
+        draw_quarter_1(&q_dsc);
+        draw_quarter_2(&q_dsc);
+        draw_quarter_3(&q_dsc);
+    }
+    else {
+        lv_draw_rect(&area, clip_area, &cir_dsc);
+    }
+    lv_draw_mask_remove_id(mask_angle_id);
 
-            deg = 180 + deg_base;
-            if(deg_test(deg, start_angle, end_angle)) {
-                if(x_start[0] == LV_COORD_MIN) x_start[0] = xi;
-            } else if(x_start[0] != LV_COORD_MIN && x_end[0] == LV_COORD_MIN) {
-                x_end[0] = xi - 1;
-            }
+    if(dsc->round_start || dsc->round_end) {
+        cir_dsc.bg_color        = dsc->color;
+        cir_dsc.bg_opa        = dsc->opa;
+        cir_dsc.bg_blend_mode = dsc->blend_mode;
+        cir_dsc.border_width = 0;
 
-            deg = 360 - deg_base;
-            if(deg_test(deg, start_angle, end_angle)) {
-                if(x_start[1] == LV_COORD_MIN) x_start[1] = xi;
-            } else if(x_start[1] != LV_COORD_MIN && x_end[1] == LV_COORD_MIN) {
-                x_end[1] = xi - 1;
-            }
+        lv_area_t round_area;
+        if(dsc->round_start) {
+            get_rounded_area(start_angle, radius, dsc->width, &round_area);
+            round_area.x1 += center_x;
+            round_area.x2 += center_x;
+            round_area.y1 += center_y;
+            round_area.y2 += center_y;
 
-            deg = 180 - deg_base;
-            if(deg_test(deg, start_angle, end_angle)) {
-                if(x_start[2] == LV_COORD_MIN) x_start[2] = xi;
-            } else if(x_start[2] != LV_COORD_MIN && x_end[2] == LV_COORD_MIN) {
-                x_end[2] = xi - 1;
-            }
-
-            deg = deg_base;
-            if(deg_test(deg, start_angle, end_angle)) {
-                if(x_start[3] == LV_COORD_MIN) x_start[3] = xi;
-            } else if(x_start[3] != LV_COORD_MIN && x_end[3] == LV_COORD_MIN) {
-                x_end[3] = xi - 1;
-            }
-
-            if(r_act_sqr < r_in_sqr) {
-                xe = xi;
-                break; /*No need to continue the iteration in x once we found the inner edge of the
-                          arc*/
-            }
+            lv_draw_rect(&round_area, clip_area, &cir_dsc);
         }
 
-        if(x_start[0] != LV_COORD_MIN) {
-            if(x_end[0] == LV_COORD_MIN) x_end[0] = xe - 1;
-            hor_line(center_x + x_start[0], center_y + yi, mask, x_end[0] - x_start[0], color, opa);
-        }
+        if(dsc->round_end) {
+            get_rounded_area(end_angle, radius, dsc->width, &round_area);
+            round_area.x1 += center_x;
+            round_area.x2 += center_x;
+            round_area.y1 += center_y;
+            round_area.y2 += center_y;
 
-        if(x_start[1] != LV_COORD_MIN) {
-            if(x_end[1] == LV_COORD_MIN) x_end[1] = xe - 1;
-            hor_line(center_x + x_start[1], center_y - yi, mask, x_end[1] - x_start[1], color, opa);
-        }
-
-        if(x_start[2] != LV_COORD_MIN) {
-            if(x_end[2] == LV_COORD_MIN) x_end[2] = xe - 1;
-            hor_line(center_x - x_end[2], center_y + yi, mask, LV_MATH_ABS(x_end[2] - x_start[2]), color, opa);
-        }
-
-        if(x_start[3] != LV_COORD_MIN) {
-            if(x_end[3] == LV_COORD_MIN) x_end[3] = xe - 1;
-            hor_line(center_x - x_end[3], center_y - yi, mask, LV_MATH_ABS(x_end[3] - x_start[3]), color, opa);
+            lv_draw_rect(&round_area, clip_area, &cir_dsc);
         }
     }
 }
@@ -218,34 +170,265 @@ void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius, cons
 /**********************
  *   STATIC FUNCTIONS
  **********************/
-static void ver_line(lv_coord_t x, lv_coord_t y, const lv_area_t * mask, lv_coord_t len, lv_color_t color, lv_opa_t opa)
-{
-    lv_area_t area;
-    lv_area_set(&area, x, y, x, y + len);
 
-    lv_draw_fill(&area, mask, color, opa);
+static void draw_quarter_0(quarter_draw_dsc_t * q)
+{
+    lv_area_t quarter_area;
+
+    if(q->start_quarter == 0 && q->end_quarter == 0 && q->start_angle < q->end_angle) {
+        /*Small arc here*/
+        quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+        quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
+
+        quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
+        quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+        bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+        if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+    }
+    else if(q->start_quarter == 0 || q->end_quarter == 0) {
+        /*Start and/or end arcs here*/
+        if(q->start_quarter == 0) {
+            quarter_area.x1 = q->center_x;
+            quarter_area.y2 = q->center_y + q->radius;
+
+            quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+            quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
+
+            bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+            if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+        }
+        if(q->end_quarter == 0) {
+            quarter_area.x2 = q->center_x + q->radius;
+            quarter_area.y1 = q->center_y;
+
+            quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
+            quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+            bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+            if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+        }
+    }
+    else if((q->start_quarter == q->end_quarter && q->start_quarter != 0 && q->end_angle < q->start_angle) ||
+            (q->start_quarter == 2 && q->end_quarter == 1) ||
+            (q->start_quarter == 3 && q->end_quarter == 2) ||
+            (q->start_quarter == 3 && q->end_quarter == 1)) {
+        /*Arc crosses here*/
+        quarter_area.x1 = q->center_x;
+        quarter_area.y1 = q->center_y;
+        quarter_area.x2 = q->center_x + q->radius;
+        quarter_area.y2 = q->center_y + q->radius;
+
+        bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+        if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+    }
 }
 
-static void hor_line(lv_coord_t x, lv_coord_t y, const lv_area_t * mask, lv_coord_t len, lv_color_t color, lv_opa_t opa)
+static void draw_quarter_1(quarter_draw_dsc_t * q)
 {
-    lv_area_t area;
-    lv_area_set(&area, x, y, x + len, y);
+    lv_area_t quarter_area;
 
-    lv_draw_fill(&area, mask, color, opa);
+    if(q->start_quarter == 1 && q->end_quarter == 1 && q->start_angle < q->end_angle) {
+        /*Small arc here*/
+        quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
+        quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+        quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+        quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
+
+        bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+        if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+    }
+    else if(q->start_quarter == 1 || q->end_quarter == 1) {
+        /*Start and/or end arcs here*/
+        if(q->start_quarter == 1) {
+            quarter_area.x1 = q->center_x - q->radius;
+            quarter_area.y1 = q->center_y;
+
+            quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
+            quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+            bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+            if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+        }
+        if(q->end_quarter == 1) {
+            quarter_area.x2 = q->center_x - 1;
+            quarter_area.y2 = q->center_y + q->radius;
+
+            quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+            quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
+
+            bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+            if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+        }
+    }
+    else if((q->start_quarter == q->end_quarter && q->start_quarter != 1 && q->end_angle < q->start_angle) ||
+            (q->start_quarter == 0 && q->end_quarter == 2) ||
+            (q->start_quarter == 0 && q->end_quarter == 3) ||
+            (q->start_quarter == 3 && q->end_quarter == 2)) {
+        /*Arc crosses here*/
+        quarter_area.x1 = q->center_x - q->radius;
+        quarter_area.y1 = q->center_y;
+        quarter_area.x2 = q->center_x - 1;
+        quarter_area.y2 = q->center_y + q->radius;
+
+        bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+        if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+    }
 }
 
-static bool deg_test_norm(uint16_t deg, uint16_t start, uint16_t end)
+static void draw_quarter_2(quarter_draw_dsc_t * q)
 {
-    if(deg >= start && deg <= end)
-        return true;
-    else
-        return false;
+    lv_area_t quarter_area;
+
+    if(q->start_quarter == 2 && q->end_quarter == 2 && q->start_angle < q->end_angle) {
+        /*Small arc here*/
+        quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
+        quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+        quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->end_angle) * q->radius) >> LV_TRIGO_SHIFT);
+        quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+        bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+        if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+    }
+    else if(q->start_quarter == 2 || q->end_quarter == 2) {
+        /*Start and/or end arcs here*/
+        if(q->start_quarter == 2) {
+            quarter_area.x2 = q->center_x - 1;
+            quarter_area.y1 = q->center_y - q->radius;
+
+            quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
+            quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+            bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+            if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+        }
+        if(q->end_quarter == 2) {
+            quarter_area.x1 = q->center_x - q->radius;
+            quarter_area.y2 = q->center_y - 1;
+
+            quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+            quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
+
+            bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+            if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+        }
+    }
+    else if((q->start_quarter == q->end_quarter && q->start_quarter != 2 && q->end_angle < q->start_angle) ||
+            (q->start_quarter == 0 && q->end_quarter == 3) ||
+            (q->start_quarter == 1 && q->end_quarter == 3) ||
+            (q->start_quarter == 1 && q->end_quarter == 0)) {
+        /*Arc crosses here*/
+        quarter_area.x1 = q->center_x - q->radius;
+        quarter_area.y1 = q->center_y - q->radius;
+        quarter_area.x2 = q->center_x - 1;
+        quarter_area.y2 = q->center_y - 1;
+
+        bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+        if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+    }
 }
 
-static bool deg_test_inv(uint16_t deg, uint16_t start, uint16_t end)
+
+static void draw_quarter_3(quarter_draw_dsc_t * q)
 {
-    if(deg >= start || deg <= end) {
-        return true;
-    } else
-        return false;
+    lv_area_t quarter_area;
+
+    if(q->start_quarter == 3 && q->end_quarter == 3 && q->start_angle < q->end_angle) {
+        /*Small arc here*/
+        quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+        quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
+
+        quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
+        quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+        bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+        if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+    }
+    else if(q->start_quarter == 3 || q->end_quarter == 3) {
+        /*Start and/or end arcs here*/
+        if(q->start_quarter == 3) {
+            quarter_area.x2 = q->center_x + q->radius;
+            quarter_area.y2 = q->center_y - 1;
+
+            quarter_area.x1 = q->center_x + ((_lv_trigo_sin(q->start_angle + 90) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+            quarter_area.y1 = q->center_y + ((_lv_trigo_sin(q->start_angle) * (q->radius)) >> LV_TRIGO_SHIFT);
+
+            bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+            if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+        }
+        if(q->end_quarter == 3) {
+            quarter_area.x1 = q->center_x;
+            quarter_area.y1 = q->center_y - q->radius;
+
+            quarter_area.x2 = q->center_x + ((_lv_trigo_sin(q->end_angle + 90) * (q->radius)) >> LV_TRIGO_SHIFT);
+            quarter_area.y2 = q->center_y + ((_lv_trigo_sin(q->end_angle) * (q->radius - q->width)) >> LV_TRIGO_SHIFT);
+
+            bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+            if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+        }
+    }
+    else if((q->start_quarter == q->end_quarter && q->start_quarter != 3 && q->end_angle < q->start_angle) ||
+            (q->start_quarter == 2 && q->end_quarter == 0) ||
+            (q->start_quarter == 1 && q->end_quarter == 0) ||
+            (q->start_quarter == 2 && q->end_quarter == 1)) {
+        /*Arc crosses here*/
+        quarter_area.x1 = q->center_x;
+        quarter_area.y1 = q->center_y - q->radius;
+        quarter_area.x2 = q->center_x + q->radius;
+        quarter_area.y2 = q->center_y - 1;
+
+        bool ok = _lv_area_intersect(&quarter_area, &quarter_area, q->clip_area);
+        if(ok) lv_draw_rect(q->draw_area, &quarter_area, q->draw_dsc);
+    }
 }
+
+
+static void get_rounded_area(int16_t angle, lv_coord_t radius, uint8_t tickness, lv_area_t * res_area)
+{
+    const uint8_t ps = 8;
+    const uint8_t pa = 127;
+
+    int32_t thick_half = tickness / 2;
+    uint8_t thick_corr = (tickness & 0x01) ? 0 : 1;
+
+    int32_t rx_corr;
+    int32_t ry_corr;
+
+    if(angle > 90 && angle < 270) rx_corr = 0;
+    else  rx_corr = 0;
+
+    if(angle > 0 && angle < 180) ry_corr = 0;
+    else  ry_corr = 0;
+
+    int32_t cir_x;
+    int32_t cir_y;
+
+    cir_x = ((radius - rx_corr - thick_half) * _lv_trigo_sin(90 - angle)) >> (LV_TRIGO_SHIFT - ps);
+    cir_y = ((radius - ry_corr - thick_half) * _lv_trigo_sin(angle)) >> (LV_TRIGO_SHIFT - ps);
+
+    /* Actually the center of the pixel need to be calculated so apply 1/2 px offset*/
+    if(cir_x > 0) {
+        cir_x = (cir_x - pa) >> ps;
+        res_area->x1 = cir_x - thick_half + thick_corr;
+        res_area->x2 = cir_x + thick_half;
+    }
+    else {
+        cir_x = (cir_x + pa) >> ps;
+        res_area->x1 = cir_x - thick_half;
+        res_area->x2 = cir_x + thick_half - thick_corr;
+    }
+
+    if(cir_y > 0) {
+        cir_y = (cir_y - pa) >> ps;
+        res_area->y1 = cir_y - thick_half + thick_corr;
+        res_area->y2 = cir_y + thick_half;
+    }
+    else {
+        cir_y = (cir_y + pa) >> ps;
+        res_area->y1 = cir_y - thick_half;
+        res_area->y2 = cir_y + thick_half - thick_corr;
+    }
+}
+

src/lv_draw/lv_draw_arc.h

@@ -13,7 +13,7 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_draw.h"
+#include "lv_draw_line.h"
 
 /*********************
  *      DEFINES
@@ -38,8 +38,8 @@ extern "C" {
  * @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
  */
-void lv_draw_arc(lv_coord_t center_x, lv_coord_t center_y, uint16_t radius, const lv_area_t * mask,
-                 uint16_t start_angle, uint16_t end_angle, const lv_style_t * style, lv_opa_t opa_scale);
+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);
 
 /**********************
  *      MACROS

src/lv_draw/lv_draw_basic.c

@@ -1,783 +0,0 @@
-/**
- * @file lv_draw_basic.c
- *
- */
-
-#include "lv_draw_basic.h"
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "../lv_core/lv_refr.h"
-#include "../lv_hal/lv_hal.h"
-#include "../lv_font/lv_font.h"
-#include "../lv_misc/lv_area.h"
-#include "../lv_misc/lv_color.h"
-#include "../lv_misc/lv_log.h"
-
-#include <stddef.h>
-#include "lv_draw.h"
-
-/*********************
- *      INCLUDES
- *********************/
-
-/*********************
- *      DEFINES
- *********************/
-
-/*Always fill < 50 px with 'sw_color_fill' because of the hw. init overhead*/
-#define VFILL_HW_ACC_SIZE_LIMIT 50
-
-#ifndef LV_ATTRIBUTE_MEM_ALIGN
-#define LV_ATTRIBUTE_MEM_ALIGN
-#endif
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void sw_mem_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
-static void sw_color_fill(lv_color_t * mem, lv_coord_t mem_width, const lv_area_t * fill_area, lv_color_t color,
-                          lv_opa_t opa);
-
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-static inline lv_color_t color_mix_2_alpha(lv_color_t bg_color, lv_opa_t bg_opa, lv_color_t fg_color, lv_opa_t fg_opa);
-#endif
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Put a pixel in the Virtual Display Buffer
- * @param x pixel x coordinate
- * @param y pixel y coordinate
- * @param mask_p fill only on this mask (truncated to VDB area)
- * @param color pixel color
- * @param opa opacity of the area (0..255)
- */
-void lv_draw_px(lv_coord_t x, lv_coord_t y, const lv_area_t * mask_p, lv_color_t color, lv_opa_t opa)
-{
-
-    if(opa < LV_OPA_MIN) return;
-    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
-
-    /*Pixel out of the mask*/
-    if(x < mask_p->x1 || x > mask_p->x2 || y < mask_p->y1 || y > mask_p->y2) {
-        return;
-    }
-
-    lv_disp_t * disp    = lv_refr_get_disp_refreshing();
-    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
-    uint32_t vdb_width  = lv_area_get_width(&vdb->area);
-
-    /*Make the coordinates relative to VDB*/
-    x -= vdb->area.x1;
-    y -= vdb->area.y1;
-
-    if(disp->driver.set_px_cb) {
-        disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width, x, y, color, opa);
-    } else {
-        bool scr_transp = false;
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-        scr_transp = disp->driver.screen_transp;
-#endif
-
-        lv_color_t * vdb_px_p = vdb->buf_act;
-        vdb_px_p += y * vdb_width + x;
-
-        if(scr_transp == false) {
-            if(opa == LV_OPA_COVER) {
-                *vdb_px_p = color;
-            } else {
-                *vdb_px_p = lv_color_mix(color, *vdb_px_p, opa);
-            }
-        } else {
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-            *vdb_px_p = color_mix_2_alpha(*vdb_px_p, (*vdb_px_p).ch.alpha, color, opa);
-#endif
-        }
-    }
-}
-
-/**
- * Fill an area in the Virtual Display Buffer
- * @param cords_p coordinates of the area to fill
- * @param mask_p fill only o this mask  (truncated to VDB area)
- * @param color fill color
- * @param opa opacity of the area (0..255)
- */
-void lv_draw_fill(const lv_area_t * cords_p, const lv_area_t * mask_p, lv_color_t color, lv_opa_t opa)
-{
-    if(opa < LV_OPA_MIN) return;
-    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
-
-    lv_area_t res_a;
-    bool union_ok;
-
-    /*Get the union of cord and mask*/
-    /* The mask is already truncated to the vdb size
-     * in 'lv_refr_area_with_vdb' function */
-    union_ok = lv_area_intersect(&res_a, cords_p, mask_p);
-
-    /*If there are common part of the three area then draw to the vdb*/
-    if(union_ok == false) {
-        return;
-    }
-
-    lv_disp_t * disp    = lv_refr_get_disp_refreshing();
-    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
-
-    lv_area_t vdb_rel_a; /*Stores relative coordinates on vdb*/
-    vdb_rel_a.x1 = res_a.x1 - vdb->area.x1;
-    vdb_rel_a.y1 = res_a.y1 - vdb->area.y1;
-    vdb_rel_a.x2 = res_a.x2 - vdb->area.x1;
-    vdb_rel_a.y2 = res_a.y2 - vdb->area.y1;
-
-    lv_color_t * vdb_buf_tmp = vdb->buf_act;
-    uint32_t vdb_width       = lv_area_get_width(&vdb->area);
-    /*Move the vdb_tmp to the first row*/
-    vdb_buf_tmp += vdb_width * vdb_rel_a.y1;
-
-#if LV_USE_GPU
-    static LV_ATTRIBUTE_MEM_ALIGN lv_color_t color_array_tmp[LV_HOR_RES_MAX]; /*Used by 'lv_disp_mem_blend'*/
-    static lv_coord_t last_width = -1;
-
-    lv_coord_t w = lv_area_get_width(&vdb_rel_a);
-    /*Don't use hw. acc. for every small fill (because of the init overhead)*/
-    if(w < VFILL_HW_ACC_SIZE_LIMIT) {
-        sw_color_fill(vdb->buf_act, vdb_width, &vdb_rel_a, color, opa);
-    }
-    /*Not opaque fill*/
-    else if(opa == LV_OPA_COVER) {
-        /*Use hw fill if present*/
-        if(disp->driver.gpu_fill_cb) {
-            disp->driver.gpu_fill_cb(&disp->driver, vdb->buf_act, vdb_width, &vdb_rel_a, color);
-        }
-        /*Use hw blend if present and the area is not too small*/
-        else if(lv_area_get_height(&vdb_rel_a) > VFILL_HW_ACC_SIZE_LIMIT && disp->driver.gpu_blend_cb) {
-            /*Fill a  one line sized buffer with a color and blend this later*/
-            if(color_array_tmp[0].full != color.full || last_width != w) {
-                uint16_t i;
-                for(i = 0; i < w; i++) {
-                    color_array_tmp[i].full = color.full;
-                }
-                last_width = w;
-            }
-
-            /*Blend the filled line to every line VDB line-by-line*/
-            lv_coord_t row;
-            for(row = vdb_rel_a.y1; row <= vdb_rel_a.y2; row++) {
-                disp->driver.gpu_blend_cb(&disp->driver, &vdb_buf_tmp[vdb_rel_a.x1], color_array_tmp, w, opa);
-                vdb_buf_tmp += vdb_width;
-            }
-
-        }
-        /*Else use sw fill if no better option*/
-        else {
-            sw_color_fill(vdb->buf_act, vdb_width, &vdb_rel_a, color, opa);
-        }
-
-    }
-    /*Fill with opacity*/
-    else {
-        /*Use hw blend if present*/
-        if(disp->driver.gpu_blend_cb) {
-            if(color_array_tmp[0].full != color.full || last_width != w) {
-                uint16_t i;
-                for(i = 0; i < w; i++) {
-                    color_array_tmp[i].full = color.full;
-                }
-
-                last_width = w;
-            }
-            lv_coord_t row;
-            for(row = vdb_rel_a.y1; row <= vdb_rel_a.y2; row++) {
-                disp->driver.gpu_blend_cb(&disp->driver, &vdb_buf_tmp[vdb_rel_a.x1], color_array_tmp, w, opa);
-                vdb_buf_tmp += vdb_width;
-            }
-
-        }
-        /*Use sw fill with opa if no better option*/
-        else {
-            sw_color_fill(vdb->buf_act, vdb_width, &vdb_rel_a, color, opa);
-        }
-    }
-#else
-    sw_color_fill(vdb->buf_act, vdb_width, &vdb_rel_a, color, opa);
-#endif
-}
-
-/**
- * Draw a letter in the Virtual Display Buffer
- * @param pos_p left-top coordinate of the latter
- * @param mask_p the letter will be drawn only on this area  (truncated to VDB area)
- * @param font_p pointer to font
- * @param letter a letter to draw
- * @param color color of letter
- * @param opa opacity of letter (0..255)
- */
-void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * mask_p, const lv_font_t * font_p, uint32_t letter,
-                    lv_color_t color, lv_opa_t opa)
-{
-    /*clang-format off*/
-    const uint8_t bpp1_opa_table[2]  = {0, 255};          /*Opacity mapping with bpp = 1 (Just for compatibility)*/
-    const uint8_t bpp2_opa_table[4]  = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/
-    const uint8_t bpp4_opa_table[16] = {0,  17, 34,  51,  /*Opacity mapping with bpp = 4*/
-                                        68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
-    /*clang-format on*/
-
-    if(opa < LV_OPA_MIN) return;
-    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
-
-    if(font_p == NULL) {
-        LV_LOG_WARN("Font: character's bitmap not found");
-        return;
-    }
-
-    lv_font_glyph_dsc_t g;
-    bool g_ret = lv_font_get_glyph_dsc(font_p, &g, letter, '\0');
-    if(g_ret == false) return;
-
-
-    lv_coord_t pos_x = pos_p->x + g.ofs_x;
-    lv_coord_t pos_y = pos_p->y + (font_p->line_height - font_p->base_line) - g.box_h - g.ofs_y;
-
-    const uint8_t * bpp_opa_table;
-    uint8_t bitmask_init;
-    uint8_t bitmask;
-
-    /*bpp = 3 should be converted to bpp = 4 in lv_font_get_glyph_bitmap */
-    if(g.bpp == 3) g.bpp = 4;
-
-    switch(g.bpp) {
-        case 1:
-            bpp_opa_table = bpp1_opa_table;
-            bitmask_init  = 0x80;
-            break;
-        case 2:
-            bpp_opa_table = bpp2_opa_table;
-            bitmask_init  = 0xC0;
-            break;
-        case 4:
-            bpp_opa_table = bpp4_opa_table;
-            bitmask_init  = 0xF0;
-            break;
-        case 8:
-            bpp_opa_table = NULL;
-            bitmask_init  = 0xFF;
-            break;       /*No opa table, pixel value will be used directly*/
-        default: return; /*Invalid bpp. Can't render the letter*/
-    }
-
-    const uint8_t * map_p = lv_font_get_glyph_bitmap(font_p, letter);
-
-    if(map_p == NULL) return;
-
-    /*If the letter is completely out of mask don't draw it */
-    if(pos_x + g.box_w < mask_p->x1 || pos_x > mask_p->x2 || pos_y + g.box_h < mask_p->y1 || pos_y > mask_p->y2) return;
-
-    lv_disp_t * disp    = lv_refr_get_disp_refreshing();
-    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
-
-    lv_coord_t vdb_width     = lv_area_get_width(&vdb->area);
-    lv_color_t * vdb_buf_tmp = vdb->buf_act;
-    lv_coord_t col, row;
-
-    uint8_t width_byte_scr = g.box_w >> 3; /*Width in bytes (on the screen finally) (e.g. w = 11 -> 2 bytes wide)*/
-    if(g.box_w & 0x7) width_byte_scr++;
-    uint16_t width_bit = g.box_w * g.bpp; /*Letter width in bits*/
-
-    bool subpx = font_p->subpx == LV_FONT_SUBPX_NONE ? false : true;
-
-    /* Calculate the col/row start/end on the map*/
-    lv_coord_t col_start;
-    lv_coord_t col_end;
-    lv_coord_t row_start;
-    lv_coord_t row_end;
-
-    if(subpx == false) {
-        col_start = pos_x >= mask_p->x1 ? 0 : mask_p->x1 - pos_x;
-        col_end   = pos_x + g.box_w <= mask_p->x2 ? g.box_w : mask_p->x2 - pos_x + 1;
-        row_start = pos_y >= mask_p->y1 ? 0 : mask_p->y1 - pos_y;
-        row_end   = pos_y + g.box_h <= mask_p->y2 ? g.box_h : mask_p->y2 - pos_y + 1;
-    } else {
-        col_start = pos_x >= mask_p->x1 ? 0 : (mask_p->x1 - pos_x) * 3;
-        col_end   = pos_x + g.box_w / 3 <= mask_p->x2 ? g.box_w : (mask_p->x2 - pos_x + 1) * 3;
-        row_start = pos_y >= mask_p->y1 ? 0 : mask_p->y1 - pos_y;
-        row_end   = pos_y + g.box_h <= mask_p->y2 ? g.box_h : mask_p->y2 - pos_y + 1;
-    }
-
-    /*Set a pointer on VDB to the first pixel of the letter*/
-    vdb_buf_tmp += ((pos_y - vdb->area.y1) * vdb_width) + pos_x - vdb->area.x1;
-
-    /*If the letter is partially out of mask the move there on VDB*/
-    if(subpx) vdb_buf_tmp += (row_start * vdb_width) + col_start / 3;
-    else vdb_buf_tmp += (row_start * vdb_width) + col_start;
-
-    /*Move on the map too*/
-    uint32_t bit_ofs = (row_start * width_bit) + (col_start * g.bpp);
-    map_p += bit_ofs >> 3;
-
-    uint8_t letter_px;
-    lv_opa_t px_opa = 0;
-    uint16_t col_bit;
-    col_bit = bit_ofs & 0x7; /* "& 0x7" equals to "% 8" just faster */
-
-    bool scr_transp = false;
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-    scr_transp = disp->driver.screen_transp;
-#endif
-
-    uint8_t font_rgb[3];
-    uint8_t txt_rgb[3] = {LV_COLOR_GET_R(color), LV_COLOR_GET_G(color), LV_COLOR_GET_B(color)};
-
-    for(row = row_start; row < row_end; row++) {
-        bitmask = bitmask_init >> col_bit;
-        uint8_t sub_px_cnt = 0;
-        for(col = col_start; col < col_end; col++) {
-            letter_px = (*map_p & bitmask) >> (8 - col_bit - g.bpp);
-
-            /*subpx == 0*/
-            if(subpx == false) {
-                if(letter_px != 0) {
-                    if(opa == LV_OPA_COVER) {
-                        px_opa = g.bpp == 8 ? letter_px : bpp_opa_table[letter_px];
-                    } else {
-                        px_opa = g.bpp == 8 ? (uint16_t)((uint16_t)letter_px * opa) >> 8
-                                : (uint16_t)((uint16_t)bpp_opa_table[letter_px] * opa) >> 8;
-                    }
-
-                    if(disp->driver.set_px_cb) {
-                        disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width,
-                                (col + pos_x) - vdb->area.x1, (row + pos_y) - vdb->area.y1, color, px_opa);
-                    } else if(vdb_buf_tmp->full != color.full) {
-                        if(px_opa > LV_OPA_MAX) {
-                            *vdb_buf_tmp = color;
-                        } else if(px_opa > LV_OPA_MIN) {
-                            if(scr_transp == false) {
-                                *vdb_buf_tmp = lv_color_mix(color, *vdb_buf_tmp, px_opa);
-                            } else {
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-        *vdb_buf_tmp = color_mix_2_alpha(*vdb_buf_tmp, (*vdb_buf_tmp).ch.alpha, color, px_opa);
-#endif
-                            }
-                        }
-                    }
-                }
-                vdb_buf_tmp++;
-            }
-            /*Handle subpx drawing*/
-            else {
-                if(letter_px != 0) {
-                    if(opa == LV_OPA_COVER) {
-                        px_opa = g.bpp == 8 ? letter_px : bpp_opa_table[letter_px];
-                    } else {
-                        px_opa = g.bpp == 8 ? (uint16_t)((uint16_t)letter_px * opa) >> 8
-                                : (uint16_t)((uint16_t)bpp_opa_table[letter_px] * opa) >> 8;
-                    }
-
-                    font_rgb[sub_px_cnt] = px_opa;
-                } else {
-                    font_rgb[sub_px_cnt] = 0;
-                }
-                sub_px_cnt ++;
-
-                if(sub_px_cnt == 3) {
-                    lv_color_t res_color;
-
-                    if(font_rgb[0] == 0 && font_rgb[1] == 0 && font_rgb[2] == 0) {
-                        res_color = *vdb_buf_tmp;
-                    } else {
-
-                        uint8_t bg_rgb[3] = {LV_COLOR_GET_R(*vdb_buf_tmp), LV_COLOR_GET_G(*vdb_buf_tmp), LV_COLOR_GET_B(*vdb_buf_tmp)};
-
-#if LV_FONT_SUBPX_BGR
-                        LV_COLOR_SET_B(res_color, (uint16_t)((uint16_t)txt_rgb[0] * font_rgb[0] + (bg_rgb[2] * (255 - font_rgb[0]))) >> 8);
-                        LV_COLOR_SET_R(res_color, (uint16_t)((uint16_t)txt_rgb[2] * font_rgb[2] + (bg_rgb[0] * (255 - font_rgb[2]))) >> 8);
-#else
-                        LV_COLOR_SET_R(res_color, (uint16_t)((uint16_t)txt_rgb[0] * font_rgb[0] + (bg_rgb[0] * (255 - font_rgb[0]))) >> 8);
-                        LV_COLOR_SET_B(res_color, (uint16_t)((uint16_t)txt_rgb[2] * font_rgb[2] + (bg_rgb[2] * (255 - font_rgb[2]))) >> 8);
-#endif
-                        LV_COLOR_SET_G(res_color, (uint16_t)((uint16_t)txt_rgb[1] * font_rgb[1] + (bg_rgb[1] * (255 - font_rgb[1]))) >> 8);
-                    }
-                    if(scr_transp == false) {
-                        vdb_buf_tmp->full = res_color.full;
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-                    } else {
-                        *vdb_buf_tmp = color_mix_2_alpha(*vdb_buf_tmp, (*vdb_buf_tmp).ch.alpha, color, px_opa);
-#endif
-                    }
-                    sub_px_cnt = 0;
-                    vdb_buf_tmp++;
-                }
-            }
-
-
-            if(col_bit < 8 - g.bpp) {
-                col_bit += g.bpp;
-                bitmask = bitmask >> g.bpp;
-            } else {
-                col_bit = 0;
-                bitmask = bitmask_init;
-                map_p++;
-            }
-        }
-
-        col_bit += ((g.box_w - col_end) + col_start) * g.bpp;
-
-        map_p += (col_bit >> 3);
-        col_bit = col_bit & 0x7;
-
-        /*Next row in VDB*/
-        if(subpx) vdb_buf_tmp += vdb_width - (col_end - col_start) / 3;
-        else vdb_buf_tmp += vdb_width - (col_end - col_start);
-    }
-}
-
-/**
- * Draw a color map to the display (image)
- * @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 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 recolor mix the pixels with this color
- * @param recolor_opa the intense of recoloring
- */
-void lv_draw_map(const lv_area_t * cords_p, const lv_area_t * mask_p, const uint8_t * map_p, lv_opa_t opa,
-                 bool chroma_key, bool alpha_byte, lv_color_t recolor, lv_opa_t recolor_opa)
-{
-
-    if(opa < LV_OPA_MIN) return;
-    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
-
-    lv_area_t masked_a;
-    bool union_ok;
-
-    /*Get the union of map size and mask*/
-    /* The mask is already truncated to the vdb size
-     * in 'lv_refr_area_with_vdb' function */
-    union_ok = lv_area_intersect(&masked_a, cords_p, mask_p);
-
-    /*If there are common part of the three area then draw to the vdb*/
-    if(union_ok == false) return;
-
-    /*The pixel size in byte is different if an alpha byte is added too*/
-    uint8_t px_size_byte = alpha_byte ? LV_IMG_PX_SIZE_ALPHA_BYTE : sizeof(lv_color_t);
-
-    /*If the map starts OUT of the masked area then calc. the first pixel*/
-    lv_coord_t map_width = lv_area_get_width(cords_p);
-    if(cords_p->y1 < masked_a.y1) {
-        map_p += (uint32_t)map_width * ((masked_a.y1 - cords_p->y1)) * px_size_byte;
-    }
-    if(cords_p->x1 < masked_a.x1) {
-        map_p += (masked_a.x1 - cords_p->x1) * px_size_byte;
-    }
-
-    lv_disp_t * disp    = lv_refr_get_disp_refreshing();
-    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
-
-    /*Stores coordinates relative to the current VDB*/
-    masked_a.x1 = masked_a.x1 - vdb->area.x1;
-    masked_a.y1 = masked_a.y1 - vdb->area.y1;
-    masked_a.x2 = masked_a.x2 - vdb->area.x1;
-    masked_a.y2 = masked_a.y2 - vdb->area.y1;
-
-    lv_coord_t vdb_width     = lv_area_get_width(&vdb->area);
-    lv_color_t * vdb_buf_tmp = vdb->buf_act;
-    vdb_buf_tmp += (uint32_t)vdb_width * masked_a.y1; /*Move to the first row*/
-    vdb_buf_tmp += (uint32_t)masked_a.x1;             /*Move to the first col*/
-
-    lv_coord_t row;
-    lv_coord_t map_useful_w = lv_area_get_width(&masked_a);
-
-    bool scr_transp = false;
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-    scr_transp = disp->driver.screen_transp;
-#endif
-
-    /*The simplest case just copy the pixels into the VDB*/
-    if(chroma_key == false && alpha_byte == false && opa == LV_OPA_COVER && recolor_opa == LV_OPA_TRANSP) {
-
-        /*Use the custom VDB write function is exists*/
-        if(disp->driver.set_px_cb) {
-            lv_coord_t col;
-            for(row = masked_a.y1; row <= masked_a.y2; row++) {
-                for(col = 0; col < map_useful_w; col++) {
-                    lv_color_t px_color = *((lv_color_t *)&map_p[(uint32_t)col * px_size_byte]);
-                    disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width, col + masked_a.x1, row,
-                                           px_color, opa);
-                }
-                map_p += map_width * px_size_byte; /*Next row on the map*/
-            }
-        }
-        /*Normal native VDB*/
-        else {
-            for(row = masked_a.y1; row <= masked_a.y2; row++) {
-#if LV_USE_GPU
-                if(disp->driver.gpu_blend_cb == NULL) {
-                    sw_mem_blend(vdb_buf_tmp, (lv_color_t *)map_p, map_useful_w, opa);
-                } else {
-                    disp->driver.gpu_blend_cb(&disp->driver, vdb_buf_tmp, (lv_color_t *)map_p, map_useful_w, opa);
-                }
-#else
-                sw_mem_blend(vdb_buf_tmp, (lv_color_t *)map_p, map_useful_w, opa);
-#endif
-                map_p += map_width * px_size_byte; /*Next row on the map*/
-                vdb_buf_tmp += vdb_width;          /*Next row on the VDB*/
-            }
-        }
-    }
-
-    /*In the other cases every pixel need to be checked one-by-one*/
-    else {
-
-        lv_coord_t col;
-        lv_color_t last_img_px  = LV_COLOR_BLACK;
-        lv_color_t recolored_px = lv_color_mix(recolor, last_img_px, recolor_opa);
-        for(row = masked_a.y1; row <= masked_a.y2; row++) {
-            for(col = 0; col < map_useful_w; col++) {
-                lv_opa_t opa_result  = opa;
-                uint8_t * px_color_p = (uint8_t *)&map_p[(uint32_t)col * px_size_byte];
-                lv_color_t px_color;
-
-                /*Calculate with the pixel level alpha*/
-                if(alpha_byte) {
-#if LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
-                    px_color.full = px_color_p[0];
-#elif LV_COLOR_DEPTH == 16
-                    /*Because of Alpha byte 16 bit color can start on odd address which can cause
-                     * crash*/
-                    px_color.full = px_color_p[0] + (px_color_p[1] << 8);
-#elif LV_COLOR_DEPTH == 32
-                    px_color = *((lv_color_t *)px_color_p);
-#endif
-                    lv_opa_t px_opa = *(px_color_p + LV_IMG_PX_SIZE_ALPHA_BYTE - 1);
-                    if(px_opa == LV_OPA_TRANSP)
-                        continue;
-                    else if(px_opa != LV_OPA_COVER)
-                        opa_result = (uint32_t)((uint32_t)px_opa * opa_result) >> 8;
-                } else {
-                    px_color = *((lv_color_t *)px_color_p);
-                }
-
-                /*Handle chroma key*/
-                if(chroma_key && px_color.full == disp->driver.color_chroma_key.full) continue;
-
-                /*Re-color the pixel if required*/
-                if(recolor_opa != LV_OPA_TRANSP) {
-                    if(last_img_px.full != px_color.full) { /*Minor acceleration: calculate only for
-                                                               new colors (save the last)*/
-                        last_img_px  = px_color;
-                        recolored_px = lv_color_mix(recolor, last_img_px, recolor_opa);
-                    }
-                    /*Handle custom VDB write is present*/
-                    if(disp->driver.set_px_cb) {
-                        disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width, col + masked_a.x1,
-                                               row, recolored_px, opa_result);
-                    }
-                    /*Normal native VDB write*/
-                    else {
-                        if(opa_result == LV_OPA_COVER)
-                            vdb_buf_tmp[col].full = recolored_px.full;
-                        else
-                            vdb_buf_tmp[col] = lv_color_mix(recolored_px, vdb_buf_tmp[col], opa_result);
-                    }
-                } else {
-                    /*Handle custom VDB write is present*/
-                    if(disp->driver.set_px_cb) {
-                        disp->driver.set_px_cb(&disp->driver, (uint8_t *)vdb->buf_act, vdb_width, col + masked_a.x1,
-                                               row, px_color, opa_result);
-                    }
-                    /*Normal native VDB write*/
-                    else {
-
-                        if(opa_result == LV_OPA_COVER)
-                            vdb_buf_tmp[col] = px_color;
-                        else {
-                            if(scr_transp == false) {
-                                vdb_buf_tmp[col] = lv_color_mix(px_color, vdb_buf_tmp[col], opa_result);
-                            } else {
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-                                vdb_buf_tmp[col] = color_mix_2_alpha(vdb_buf_tmp[col], vdb_buf_tmp[col].ch.alpha,
-                                                                     px_color, opa_result);
-#endif
-                            }
-                        }
-                    }
-                }
-            }
-
-            map_p += map_width * px_size_byte; /*Next row on the map*/
-            vdb_buf_tmp += vdb_width;          /*Next row on the VDB*/
-        }
-    }
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Blend pixels to destination memory using opacity
- * @param dest a memory address. Copy 'src' here.
- * @param src pointer to pixel map. Copy it to 'dest'.
- * @param length number of pixels in 'src'
- * @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
- */
-static void sw_mem_blend(lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
-{
-    if(opa == LV_OPA_COVER) {
-        memcpy(dest, src, length * sizeof(lv_color_t));
-    } else {
-        uint32_t col;
-        for(col = 0; col < length; col++) {
-            dest[col] = lv_color_mix(src[col], dest[col], opa);
-        }
-    }
-}
-
-/**
- * Fill an area with a color
- * @param mem a memory address. Considered to a rectangular window according to 'mem_area'
- * @param mem_width width of the 'mem' buffer
- * @param fill_area coordinates of an area to fill. Relative to 'mem_area'.
- * @param color fill color
- * @param opa opacity (0, LV_OPA_TRANSP: transparent ... 255, LV_OPA_COVER, fully cover)
- */
-static void sw_color_fill(lv_color_t * mem, lv_coord_t mem_width, const lv_area_t * fill_area, lv_color_t color,
-                          lv_opa_t opa)
-{
-    /*Set all row in vdb to the given color*/
-    lv_coord_t row;
-    lv_coord_t col;
-
-    lv_disp_t * disp = lv_refr_get_disp_refreshing();
-    if(disp->driver.set_px_cb) {
-        for(col = fill_area->x1; col <= fill_area->x2; col++) {
-            for(row = fill_area->y1; row <= fill_area->y2; row++) {
-                disp->driver.set_px_cb(&disp->driver, (uint8_t *)mem, mem_width, col, row, color, opa);
-            }
-        }
-    } else {
-        mem += fill_area->y1 * mem_width; /*Go to the first row*/
-
-        /*Run simpler function without opacity*/
-        if(opa == LV_OPA_COVER) {
-
-            /*Fill the first row with 'color'*/
-            for(col = fill_area->x1; col <= fill_area->x2; col++) {
-                mem[col] = color;
-            }
-
-            /*Copy the first row to all other rows*/
-            lv_color_t * mem_first = &mem[fill_area->x1];
-            lv_coord_t copy_size   = (fill_area->x2 - fill_area->x1 + 1) * sizeof(lv_color_t);
-            mem += mem_width;
-
-            for(row = fill_area->y1 + 1; row <= fill_area->y2; row++) {
-                memcpy(&mem[fill_area->x1], mem_first, copy_size);
-                mem += mem_width;
-            }
-        }
-        /*Calculate with alpha too*/
-        else {
-            bool scr_transp = false;
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-            scr_transp = disp->driver.screen_transp;
-#endif
-
-            lv_color_t bg_tmp  = LV_COLOR_BLACK;
-            lv_color_t opa_tmp = lv_color_mix(color, bg_tmp, opa);
-            for(row = fill_area->y1; row <= fill_area->y2; row++) {
-                for(col = fill_area->x1; col <= fill_area->x2; col++) {
-                    if(scr_transp == false) {
-                        /*If the bg color changed recalculate the result color*/
-                        if(mem[col].full != bg_tmp.full) {
-                            bg_tmp  = mem[col];
-                            opa_tmp = lv_color_mix(color, bg_tmp, opa);
-                        }
-
-                        mem[col] = opa_tmp;
-
-                    } else {
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-                        mem[col] = color_mix_2_alpha(mem[col], mem[col].ch.alpha, color, opa);
-#endif
-                    }
-                }
-                mem += mem_width;
-            }
-        }
-    }
-}
-
-#if LV_COLOR_DEPTH == 32 && LV_COLOR_SCREEN_TRANSP
-/**
- * Mix two colors. Both color can have alpha value. It requires ARGB888 colors.
- * @param bg_color background color
- * @param bg_opa alpha of the background color
- * @param fg_color foreground color
- * @param fg_opa alpha of the foreground color
- * @return the mixed color. the alpha channel (color.alpha) contains the result alpha
- */
-static inline lv_color_t color_mix_2_alpha(lv_color_t bg_color, lv_opa_t bg_opa, lv_color_t fg_color, lv_opa_t fg_opa)
-{
-    /* Pick the foreground if it's fully opaque or the Background is fully transparent*/
-    if(fg_opa > LV_OPA_MAX || bg_opa <= LV_OPA_MIN) {
-        fg_color.ch.alpha = fg_opa;
-        return fg_color;
-    }
-    /*Transparent foreground: use the Background*/
-    else if(fg_opa <= LV_OPA_MIN) {
-        return bg_color;
-    }
-    /*Opaque background: use simple mix*/
-    else if(bg_opa >= LV_OPA_MAX) {
-        return lv_color_mix(fg_color, bg_color, fg_opa);
-    }
-    /*Both colors have alpha. Expensive calculation need to be applied*/
-    else {
-        /*Save the parameters and the result. If they will be asked again don't compute again*/
-        static lv_opa_t fg_opa_save     = 0;
-        static lv_opa_t bg_opa_save     = 0;
-        static lv_color_t fg_color_save = {{0}};
-        static lv_color_t bg_color_save = {{0}};
-        static lv_color_t c             = {{0}};
-
-        if(fg_opa != fg_opa_save || bg_opa != bg_opa_save || fg_color.full != fg_color_save.full ||
-           bg_color.full != bg_color_save.full) {
-            fg_opa_save        = fg_opa;
-            bg_opa_save        = bg_opa;
-            fg_color_save.full = fg_color.full;
-            bg_color_save.full = bg_color.full;
-            /*Info:
-             * https://en.wikipedia.org/wiki/Alpha_compositing#Analytical_derivation_of_the_over_operator*/
-            lv_opa_t alpha_res = 255 - ((uint16_t)((uint16_t)(255 - fg_opa) * (255 - bg_opa)) >> 8);
-            if(alpha_res == 0) {
-                while(1)
-                    ;
-            }
-            lv_opa_t ratio = (uint16_t)((uint16_t)fg_opa * 255) / alpha_res;
-            c              = lv_color_mix(fg_color, bg_color, ratio);
-            c.ch.alpha     = alpha_res;
-        }
-        return c;
-    }
-}
-#endif

src/lv_draw/lv_draw_basic.h

@@ -1,82 +0,0 @@
-/**
- * @file lv_draw_basic.h
- *
- */
-
-#ifndef LV_DRAW_BASIC_H
-#define LV_DRAW_BASIC_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*********************
- *      INCLUDES
- *********************/
-#ifdef LV_CONF_INCLUDE_SIMPLE
-#include "lv_conf.h"
-#else
-#include "../../../lv_conf.h"
-#endif
-
-#include "../lv_font/lv_font.h"
-#include "../lv_misc/lv_color.h"
-#include "../lv_misc/lv_area.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-void lv_draw_px(lv_coord_t x, lv_coord_t y, const lv_area_t * mask_p, lv_color_t color, lv_opa_t opa);
-/**
- * Fill an area in the Virtual Display Buffer
- * @param cords_p coordinates of the area to fill
- * @param mask_p fill only o this mask
- * @param color fill color
- * @param opa opacity of the area (0..255)
- */
-void lv_draw_fill(const lv_area_t * cords_p, const lv_area_t * mask_p, lv_color_t color, lv_opa_t opa);
-
-/**
- * Draw a letter in the Virtual Display Buffer
- * @param pos_p left-top coordinate of the latter
- * @param mask_p the letter will be drawn only on this area
- * @param font_p pointer to font
- * @param letter a letter to draw
- * @param color color of letter
- * @param opa opacity of letter (0..255)
- */
-void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * mask_p, const lv_font_t * font_p, uint32_t letter,
-                    lv_color_t color, lv_opa_t opa);
-
-/**
- * Draw a color map to the display (image)
- * @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 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 recolor mix the pixels with this color
- * @param recolor_opa the intense of recoloring
- */
-void lv_draw_map(const lv_area_t * cords_p, const lv_area_t * mask_p, const uint8_t * map_p, lv_opa_t opa,
-                 bool chroma_key, bool alpha_byte, lv_color_t recolor, lv_opa_t recolor_opa);
-
-/**********************
- *      MACROS
- **********************/
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif /*LV_DRAW_BASIC_H*/

src/lv_draw/lv_draw_blend.c

@@ -0,0 +1,998 @@
+/**
+ * @file lv_draw_blend.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_draw_blend.h"
+#include "lv_img_decoder.h"
+#include "../lv_misc/lv_math.h"
+#include "../lv_hal/lv_hal_disp.h"
+#include "../lv_core/lv_refr.h"
+
+#include "../lv_gpu/lv_gpu_stm32_dma2d.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define GPU_SIZE_LIMIT      240
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void fill_set_px(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_ATTRIBUTE_FAST_MEM static void fill_normal(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);
+
+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);
+
+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,
+                       const lv_opa_t * mask, lv_draw_mask_res_t mask_res);
+
+LV_ATTRIBUTE_FAST_MEM static void map_normal(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);
+
+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);
+
+/**********************
+ *  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
+ **********************/
+
+
+#define FILL_NORMAL_MASK_PX(out_x,  color)                                                          \
+    if(*mask_tmp_x) {          \
+        if(*mask_tmp_x == LV_OPA_COVER) disp_buf_first[out_x] = color;                                 \
+        else disp_buf_first[out_x] = lv_color_mix(color, disp_buf_first[out_x], *mask_tmp_x);            \
+    }                                                                                               \
+    mask_tmp_x++;
+
+
+#define FILL_NORMAL_MASK_PX_SCR_TRANSP(out_x,  color)                                               \
+    if(*mask_tmp_x) {          \
+        if(*mask_tmp_x == LV_OPA_COVER) disp_buf_first[out_x] = color;                                 \
+        else if(disp->driver.screen_transp) lv_color_mix_with_alpha(disp_buf_first[out_x], disp_buf_first[out_x].ch.alpha,              \
+                                                                        color, *mask_tmp_x, &disp_buf_first[out_x], &disp_buf_first[out_x].ch.alpha);           \
+        else disp_buf_first[out_x] = lv_color_mix(color, disp_buf_first[out_x], *mask_tmp_x);            \
+    }                                                                                                      \
+    mask_tmp_x++;
+
+
+#define MAP_NORMAL_MASK_PX(x)                                                          \
+    if(*mask_tmp_x) {          \
+        if(*mask_tmp_x == LV_OPA_COVER) disp_buf_first[x] = map_buf_first[x];                                 \
+        else disp_buf_first[x] = lv_color_mix(map_buf_first[x], disp_buf_first[x], *mask_tmp_x);            \
+    }                                                                                               \
+    mask_tmp_x++;
+
+#define MAP_NORMAL_MASK_PX_SCR_TRANSP(x)                        \
+    if(*mask_tmp_x) {          \
+        if(*mask_tmp_x == LV_OPA_COVER) disp_buf_first[x] = map_buf_first[x];                                 \
+        else if(disp->driver.screen_transp) lv_color_mix_with_alpha(disp_buf_first[x], disp_buf_first[x].ch.alpha,              \
+                                                                        map_buf_first[x], *mask_tmp_x, &disp_buf_first[x], &disp_buf_first[x].ch.alpha);                  \
+        else disp_buf_first[x] = lv_color_mix(map_buf_first[x], disp_buf_first[x], *mask_tmp_x);            \
+    }                                                                                               \
+    mask_tmp_x++;
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+
+/**
+ * Fill and area in the display buffer.
+ * @param clip_area clip the fill to this area  (absolute coordinates)
+ * @param fill_area fill this area  (absolute coordinates) (should be clipped)
+ * @param color fill color
+ * @param mask a mask to apply on the fill (uint8_t array with 0x00..0xff values).
+ *             Relative to fill area but its width is truncated to clip area.
+ * @param mask_res LV_MASK_RES_COVER: the mask has only 0xff values (no mask),
+ *                 LV_MASK_RES_TRANSP: the mask has only 0x00 values (full transparent),
+ *                 LV_MASK_RES_CHANGED: the mask has mixed values
+ * @param opa overall opacity in 0x00..0xff range
+ * @param mode blend mode from `lv_blend_mode_t`
+ */
+LV_ATTRIBUTE_FAST_MEM void _lv_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area,
+                                          lv_color_t color, lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa,
+                                          lv_blend_mode_t mode)
+{
+    /*Do not draw transparent things*/
+    if(opa < LV_OPA_MIN) return;
+    if(mask_res == LV_DRAW_MASK_RES_TRANSP) return;
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+    const lv_area_t * disp_area = &vdb->area;
+    lv_color_t * disp_buf = vdb->buf_act;
+
+
+    /* 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, clip_area, fill_area);
+    if(!is_common) return;
+
+    /* 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;
+
+    /*Round the values in the mask if anti-aliasing is disabled*/
+#if LV_ANTIALIAS
+    if(mask && disp->driver.antialiasing == 0)
+#else
+    if(mask)
+#endif
+    {
+        int32_t mask_w = lv_area_get_width(&draw_area);
+        int32_t i;
+        for(i = 0; i < mask_w; i++)  mask[i] = mask[i] > 128 ? LV_OPA_COVER : LV_OPA_TRANSP;
+    }
+
+    if(disp->driver.set_px_cb) {
+        fill_set_px(disp_area, disp_buf, &draw_area, color, opa, mask, mask_res);
+    }
+    else if(mode == LV_BLEND_MODE_NORMAL) {
+        fill_normal(disp_area, disp_buf, &draw_area, color, opa, mask, mask_res);
+    }
+    else {
+        fill_blended(disp_area, disp_buf, &draw_area, color, opa, mask, mask_res, mode);
+    }
+}
+
+/**
+ * Copy a map (image) to a display buffer.
+ * @param clip_area clip the map to this area (absolute coordinates)
+ * @param map_area area of the image  (absolute coordinates)
+ * @param map_buf a pixels of the map (image)
+ * @param mask a mask to apply on every pixel (uint8_t array with 0x00..0xff values).
+ *                Relative to map area but its width is truncated to clip area.
+ * @param mask_res LV_MASK_RES_COVER: the mask has only 0xff values (no mask),
+ *                 LV_MASK_RES_TRANSP: the mask has only 0x00 values (full transparent),
+ *                 LV_MASK_RES_CHANGED: the mask has mixed values
+ * @param opa  overall opacity in 0x00..0xff range
+ * @param mode blend mode from `lv_blend_mode_t`
+ */
+LV_ATTRIBUTE_FAST_MEM void _lv_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
+                                         const lv_color_t * map_buf,
+                                         lv_opa_t * mask, lv_draw_mask_res_t mask_res,
+                                         lv_opa_t opa, lv_blend_mode_t mode)
+{
+    /*Do not draw transparent things*/
+    if(opa < LV_OPA_MIN) return;
+    if(mask_res == LV_DRAW_MASK_RES_TRANSP) return;
+
+    /* 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, clip_area, map_area);
+    if(!is_common) return;
+
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+    const lv_area_t * disp_area = &vdb->area;
+    lv_color_t * disp_buf = vdb->buf_act;
+
+    /* 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;
+
+    /*Round the values in the mask if anti-aliasing is disabled*/
+#if LV_ANTIALIAS
+    if(mask && disp->driver.antialiasing == 0)
+#else
+    if(mask)
+#endif
+    {
+        int32_t mask_w = lv_area_get_width(&draw_area);
+        int32_t i;
+        for(i = 0; i < mask_w; i++)  mask[i] = mask[i] > 128 ? LV_OPA_COVER : LV_OPA_TRANSP;
+    }
+    if(disp->driver.set_px_cb) {
+        map_set_px(disp_area, disp_buf, &draw_area, map_area, map_buf, opa, mask, mask_res);
+    }
+    else if(mode == LV_BLEND_MODE_NORMAL) {
+        map_normal(disp_area, disp_buf, &draw_area, map_area, map_buf, opa, mask, mask_res);
+    }
+    else {
+        map_blended(disp_area, disp_buf, &draw_area, map_area, map_buf, opa, mask, mask_res, mode);
+    }
+}
+
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+static void fill_set_px(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_disp_t * disp = _lv_refr_get_disp_refreshing();
+
+    /*Get the width of the `disp_area` it will be used to go to the next line*/
+    int32_t disp_w = lv_area_get_width(disp_area);
+
+    int32_t x;
+    int32_t y;
+
+    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) {
+        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, opa);
+            }
+        }
+    }
+    else {
+        /* The mask is relative to the clipped area.
+         * In the cycles below mask will be indexed from `draw_area.x1`
+         * but it corresponds to zero index. So prepare `mask_tmp` accordingly. */
+        const lv_opa_t * mask_tmp = mask - draw_area->x1;
+
+        /*Get the width of the `draw_area` it will be used to go to the next line of the mask*/
+        int32_t draw_area_w = lv_area_get_width(draw_area);
+
+        for(y = draw_area->y1; y <= draw_area->y2; y++) {
+            for(x = draw_area->x1; x <= draw_area->x2; x++) {
+                if(mask_tmp[x]) {
+                    disp->driver.set_px_cb(&disp->driver, (void *)disp_buf, disp_w, x, y, color,
+                                           (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
+                }
+            }
+            mask_tmp += draw_area_w;
+        }
+    }
+}
+
+/**
+ * Fill an area with a color
+ * @param disp_area the current display area (destination area)
+ * @param disp_buf destination buffer
+ * @param draw_area fill this area (relative to `disp_area`)
+ * @param color fill color
+ * @param opa overall opacity in 0x00..0xff range
+ * @param mask a mask to apply on every pixel (uint8_t array with 0x00..0xff values).
+ *                It fits into draw_area.
+ * @param mask_res LV_MASK_RES_COVER: the mask has only 0xff values (no mask),
+ *                 LV_MASK_RES_TRANSP: the mask has only 0x00 values (full transparent),
+ *                 LV_MASK_RES_CHANGED: the mask has mixed values
+ */
+LV_ATTRIBUTE_FAST_MEM static void fill_normal(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)
+{
+
+#if LV_USE_GPU || LV_COLOR_SCREEN_TRANSP
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+#endif
+
+    /*Get the width of the `disp_area` it will be used to go to the next line*/
+    int32_t disp_w = lv_area_get_width(disp_area);
+
+    int32_t draw_area_w = lv_area_get_width(draw_area);
+    int32_t draw_area_h = lv_area_get_height(draw_area);
+
+    /*Create a temp. disp_buf which always point to the first pixel of the destination area*/
+    lv_color_t * disp_buf_first = disp_buf + disp_w * draw_area->y1 + draw_area->x1;
+
+    int32_t x;
+    int32_t y;
+
+    /*Simple fill (maybe with opacity), no masking*/
+    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) {
+        if(opa > LV_OPA_MAX) {
+#if LV_USE_GPU
+            if(disp->driver.gpu_fill_cb && lv_area_get_size(draw_area) > GPU_SIZE_LIMIT) {
+                disp->driver.gpu_fill_cb(&disp->driver, disp_buf, disp_w, draw_area, color);
+                return;
+            }
+#endif
+
+#if LV_USE_GPU_STM32_DMA2D
+            if(lv_area_get_size(draw_area) >= 240) {
+                lv_gpu_stm32_dma2d_fill(disp_buf_first, disp_w, color, draw_area_w, draw_area_h);
+                return;
+            }
+#endif
+            /*Software rendering*/
+            for(y = 0; y < draw_area_h; y++) {
+                lv_color_fill(disp_buf_first, color, draw_area_w);
+                disp_buf_first += disp_w;
+            }
+        }
+        /*No mask with opacity*/
+        else {
+#if LV_USE_GPU
+            if(disp->driver.gpu_blend_cb && lv_area_get_size(draw_area) > GPU_SIZE_LIMIT) {
+                for(x = 0; x < draw_area_w ; x++) blend_buf[x].full = color.full;
+
+                for(y = draw_area->y1; y <= draw_area->y2; y++) {
+                    disp->driver.gpu_blend_cb(&disp->driver, disp_buf_first, blend_buf, draw_area_w, opa);
+                    disp_buf_first += disp_w;
+                }
+                return;
+            }
+#endif
+
+
+#if LV_USE_GPU_STM32_DMA2D
+            if(lv_area_get_size(draw_area) >= 240) {
+                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;
+                for(y = 0; y <= draw_area_h - line_h; y += line_h) {
+                    lv_gpu_stm32_dma2d_blend(disp_buf_first, disp_w, blend_buf, opa, draw_area_w, draw_area_w, line_h);
+                    disp_buf_first += disp_w * line_h;
+                }
+
+                if(y != draw_area_h) {
+                    lv_gpu_stm32_dma2d_blend(disp_buf_first, disp_w, blend_buf, opa, draw_area_w, draw_area_w, draw_area_h - y);
+                }
+
+                return;
+            }
+#endif
+            lv_color_t last_dest_color = LV_COLOR_BLACK;
+            lv_color_t last_res_color = lv_color_mix(color, last_dest_color, opa);
+
+            uint16_t color_premult[3];
+            lv_color_premult(color, opa, color_premult);
+            lv_opa_t opa_inv = 255 - opa;
+
+            for(y = 0; y < draw_area_h; y++) {
+                for(x = 0; x < draw_area_w; x++) {
+                    if(last_dest_color.full != disp_buf_first[x].full) {
+                        last_dest_color = disp_buf_first[x];
+
+#if LV_COLOR_SCREEN_TRANSP
+                        if(disp->driver.screen_transp) {
+                            lv_color_mix_with_alpha(disp_buf_first[x], disp_buf_first[x].ch.alpha, color, opa, &last_res_color,
+                                                    &last_res_color.ch.alpha);
+                        }
+                        else
+#endif
+                        {
+                            last_res_color = lv_color_mix_premult(color_premult, disp_buf_first[x], opa_inv);
+                        }
+                    }
+                    disp_buf_first[x] = last_res_color;
+                }
+                disp_buf_first += disp_w;
+            }
+        }
+    }
+    /*Masked*/
+    else {
+        /*DMA2D could be used here but it's much slower than software rendering*/
+#if LV_USE_GPU_STM32_DMA2D && 0
+        if(lv_area_get_size(draw_area) > 240) {
+            lv_gpu_stm32_dma2d_fill_mask(disp_buf_first, disp_w, color, mask, opa, draw_area_w, draw_area_h);
+            return;
+        }
+#endif
+
+
+        /*Buffer the result color to avoid recalculating the same color*/
+        lv_color_t last_dest_color;
+        lv_color_t last_res_color;
+        lv_opa_t last_mask = LV_OPA_TRANSP;
+        last_dest_color.full = disp_buf_first[0].full;
+        last_res_color.full = disp_buf_first[0].full;
+
+        int32_t x_end4 = draw_area_w - 4;
+
+        /*Only the mask matters*/
+        if(opa > LV_OPA_MAX) {
+            for(y = 0; y < draw_area_h; y++) {
+                const lv_opa_t * mask_tmp_x = mask;
+#if 0
+                for(x = 0; x < draw_area_w; x++) {
+#if LV_COLOR_SCREEN_TRANSP
+                    FILL_NORMAL_MASK_PX_SCR_TRANSP(x, color)
+#else
+                    FILL_NORMAL_MASK_PX(x, color)
+#endif
+                }
+#else
+                for(x = 0; x < draw_area_w && ((lv_uintptr_t)mask_tmp_x & 0x3); x++) {
+#if LV_COLOR_SCREEN_TRANSP
+                    FILL_NORMAL_MASK_PX_SCR_TRANSP(x, color)
+#else
+                    FILL_NORMAL_MASK_PX(x, color)
+#endif
+                }
+
+                uint32_t * mask32 = (uint32_t *) mask_tmp_x;
+                for(; x <= x_end4; x += 4) {
+                    if(*mask32) {
+                        if((*mask32) == 0xFFFFFFFF) {
+                            disp_buf_first[x] = color;
+                            disp_buf_first[x + 1] = color;
+                            disp_buf_first[x + 2] = color;
+                            disp_buf_first[x + 3] = color;
+                        }
+                        else {
+                            mask_tmp_x = (const lv_opa_t *)mask32;
+#if LV_COLOR_SCREEN_TRANSP
+                            FILL_NORMAL_MASK_PX_SCR_TRANSP(x, color)
+                            FILL_NORMAL_MASK_PX_SCR_TRANSP(x + 1, color)
+                            FILL_NORMAL_MASK_PX_SCR_TRANSP(x + 2, color)
+                            FILL_NORMAL_MASK_PX_SCR_TRANSP(x + 3, color)
+#else
+                            FILL_NORMAL_MASK_PX(x, color)
+                            FILL_NORMAL_MASK_PX(x + 1, color)
+                            FILL_NORMAL_MASK_PX(x + 2, color)
+                            FILL_NORMAL_MASK_PX(x + 3, color)
+#endif
+                        }
+                    }
+                    mask32++;
+                }
+
+                mask_tmp_x = (const lv_opa_t *)mask32;
+                for(; x < draw_area_w ; x++) {
+#if LV_COLOR_SCREEN_TRANSP
+                    FILL_NORMAL_MASK_PX_SCR_TRANSP(x, color)
+#else
+                    FILL_NORMAL_MASK_PX(x, color)
+#endif
+                }
+#endif
+                disp_buf_first += disp_w;
+                mask += draw_area_w;
+            }
+        }
+        /*Handle opa and mask values too*/
+        else {
+            lv_opa_t opa_tmp = LV_OPA_TRANSP;
+            for(y = draw_area->y1; y <= draw_area->y2; y++) {
+                const lv_opa_t * mask_tmp_x = mask;
+                for(x = 0; x < draw_area_w; x++) {
+                    if(*mask_tmp_x) {
+                        if(*mask_tmp_x != last_mask) opa_tmp = *mask_tmp_x == LV_OPA_COVER ? opa :
+                                                                   (uint32_t)((uint32_t)(*mask_tmp_x) * opa) >> 8;
+                        if(*mask_tmp_x != last_mask || last_dest_color.full != disp_buf_first[x].full) {
+#if LV_COLOR_SCREEN_TRANSP
+                            if(disp->driver.screen_transp) {
+                                lv_color_mix_with_alpha(disp_buf_first[x], disp_buf_first[x].ch.alpha, color, opa_tmp, &last_res_color,
+                                                        &last_res_color.ch.alpha);
+                            }
+                            else
+#endif
+                            {
+                                if(opa_tmp == LV_OPA_COVER) last_res_color = color;
+                                else last_res_color = lv_color_mix(color, disp_buf_first[x], opa_tmp);
+                            }
+                            last_mask = *mask_tmp_x;
+                            last_dest_color.full = disp_buf_first[x].full;
+                        }
+                        disp_buf_first[x] = last_res_color;
+                    }
+                    mask_tmp_x++;
+                }
+                disp_buf_first += disp_w;
+                mask += draw_area_w;
+            }
+        }
+    }
+}
+
+
+/**
+ * Fill an area with a color but apply blending algorithms
+ * @param disp_area the current display area (destination area)
+ * @param disp_buf destination buffer
+ * @param draw_area fill this area (relative to `disp_area`)
+ * @param color fill color
+ * @param opa overall opacity in 0x00..0xff range
+ * @param mask a mask to apply on every pixel (uint8_t array with 0x00..0xff values).
+ *                It fits into draw_area.
+ * @param mask_res LV_MASK_RES_COVER: the mask has only 0xff values (no mask),
+ *                 LV_MASK_RES_TRANSP: the mask has only 0x00 values (full transparent),
+ *                 LV_MASK_RES_CHANGED: the mask has mixed values
+ * @param mode blend mode from `lv_blend_mode_t`
+ */
+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)
+{
+    /*Get the width of the `disp_area` it will be used to go to the next line*/
+    int32_t disp_w = lv_area_get_width(disp_area);
+
+    /*Create a temp. disp_buf which always point to current line to draw*/
+    lv_color_t * disp_buf_tmp = disp_buf + disp_w * draw_area->y1;
+
+
+    lv_color_t (*blend_fp)(lv_color_t, lv_color_t, lv_opa_t);
+    switch(mode) {
+        case LV_BLEND_MODE_ADDITIVE:
+            blend_fp = color_blend_true_color_additive;
+            break;
+        case LV_BLEND_MODE_SUBTRACTIVE:
+            blend_fp = color_blend_true_color_subtractive;
+            break;
+        default:
+            LV_LOG_WARN("fill_blended: unsupported blend mode");
+            return;
+    }
+
+    int32_t x;
+    int32_t y;
+
+    /*Simple fill (maybe with opacity), no masking*/
+    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) {
+        lv_color_t last_dest_color = LV_COLOR_BLACK;
+        lv_color_t last_res_color = lv_color_mix(color, last_dest_color, opa);
+        for(y = draw_area->y1; y <= draw_area->y2; y++) {
+            for(x = draw_area->x1; x <= draw_area->x2; x++) {
+                if(last_dest_color.full != disp_buf_tmp[x].full) {
+                    last_dest_color = disp_buf_tmp[x];
+                    last_res_color = blend_fp(color, disp_buf_tmp[x], opa);
+                }
+                disp_buf_tmp[x] = last_res_color;
+            }
+            disp_buf_tmp += disp_w;
+        }
+    }
+    /*Masked*/
+    else {
+        /*Get the width of the `draw_area` it will be used to go to the next line of the mask*/
+        int32_t draw_area_w = lv_area_get_width(draw_area);
+
+        /* The mask is relative to the clipped area.
+         * In the cycles below mask will be indexed from `draw_area.x1`
+         * but it corresponds to zero index. So prepare `mask_tmp` accordingly. */
+        const lv_opa_t * mask_tmp = mask - draw_area->x1;
+
+        /*Buffer the result color to avoid recalculating the same color*/
+        lv_color_t last_dest_color;
+        lv_color_t last_res_color;
+        lv_opa_t last_mask = LV_OPA_TRANSP;
+        last_dest_color.full = disp_buf_tmp[0].full;
+        last_res_color.full = disp_buf_tmp[0].full;
+
+        for(y = draw_area->y1; y <= draw_area->y2; y++) {
+            for(x = draw_area->x1; x <= draw_area->x2; x++) {
+                if(mask_tmp[x] == 0) continue;
+                if(mask_tmp[x] != last_mask || last_dest_color.full != disp_buf_tmp[x].full) {
+                    lv_opa_t opa_tmp = mask_tmp[x] >= LV_OPA_MAX ? opa : (uint32_t)((uint32_t)mask_tmp[x] * opa) >> 8;
+
+                    last_res_color = blend_fp(color, disp_buf_tmp[x], opa_tmp);
+                    last_mask = mask_tmp[x];
+                    last_dest_color.full = disp_buf_tmp[x].full;
+                }
+                disp_buf_tmp[x] = last_res_color;
+            }
+            disp_buf_tmp += disp_w;
+            mask_tmp += draw_area_w;
+        }
+    }
+}
+
+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,
+                       const lv_opa_t * mask, lv_draw_mask_res_t mask_res)
+
+{
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+
+    /*Get the width of the `disp_area` it will be used to go to the next line*/
+    int32_t disp_w = lv_area_get_width(disp_area);
+
+    /*Get the width of the `draw_area` it will be used to go to the next line of the mask*/
+    int32_t draw_area_w = lv_area_get_width(draw_area);
+
+    /*Get the width of the `mask_area` it will be used to go to the next line*/
+    int32_t map_w = lv_area_get_width(map_area);
+
+    /*Create a temp. map_buf which always point to current line to draw*/
+    const lv_color_t * map_buf_tmp = map_buf + map_w * (draw_area->y1 - (map_area->y1 - disp_area->y1));
+
+    map_buf_tmp += (draw_area->x1 - (map_area->x1 - disp_area->x1));
+    map_buf_tmp -= draw_area->x1;
+    int32_t x;
+    int32_t y;
+
+    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) {
+        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], opa);
+            }
+            map_buf_tmp += map_w;
+        }
+    }
+    else {
+        /* The mask is relative to the clipped area.
+         * In the cycles below mask will be indexed from `draw_area.x1`
+         * but it corresponds to zero index. So prepare `mask_tmp` accordingly. */
+        const lv_opa_t * mask_tmp = mask - draw_area->x1;
+
+        for(y = draw_area->y1; y <= draw_area->y2; y++) {
+            for(x = draw_area->x1; x <= draw_area->x2; x++) {
+                if(mask_tmp[x]) {
+                    disp->driver.set_px_cb(&disp->driver, (void *)disp_buf, disp_w, x, y, map_buf_tmp[x],
+                                           (uint32_t)((uint32_t)opa * mask_tmp[x]) >> 8);
+                }
+            }
+            mask_tmp += draw_area_w;
+            map_buf_tmp += map_w;
+        }
+    }
+}
+
+/**
+ * Copy an image to an area
+ * @param disp_area the current display area (destination area)
+ * @param disp_buf destination buffer
+ * @param map_area coordinates of the map (image) to copy. (absolute coordinates)
+ * @param map_buf the pixel of the image
+ * @param opa overall opacity in 0x00..0xff range
+ * @param mask a mask to apply on every pixel (uint8_t array with 0x00..0xff values).
+ *                It fits into draw_area.
+ * @param mask_res LV_MASK_RES_COVER: the mask has only 0xff values (no mask),
+ *                 LV_MASK_RES_TRANSP: the mask has only 0x00 values (full transparent),
+ *                 LV_MASK_RES_CHANGED: the mask has mixed values
+ */
+LV_ATTRIBUTE_FAST_MEM static void map_normal(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)
+{
+
+    /*Get the width of the `disp_area` it will be used to go to the next line*/
+    int32_t disp_w = lv_area_get_width(disp_area);
+
+    int32_t draw_area_w = lv_area_get_width(draw_area);
+    int32_t draw_area_h = lv_area_get_height(draw_area);
+
+    /*Get the width of the `mask_area` it will be used to go to the next line*/
+    int32_t map_w = lv_area_get_width(map_area);
+
+    /*Create a temp. disp_buf which always point to first pixel to draw*/
+    lv_color_t * disp_buf_first = disp_buf + disp_w * draw_area->y1 + draw_area->x1;
+
+    /*Create a temp. map_buf which always point to first pixel to draw from the map*/
+    const lv_color_t * map_buf_first = map_buf + map_w * (draw_area->y1 - (map_area->y1 - disp_area->y1));
+    map_buf_first += (draw_area->x1 - (map_area->x1 - disp_area->x1));
+
+#if LV_COLOR_SCREEN_TRANSP || LV_USE_GPU
+    lv_disp_t * disp = _lv_refr_get_disp_refreshing();
+#endif
+
+    int32_t x;
+    int32_t y;
+
+    /*Simple fill (maybe with opacity), no masking*/
+    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) {
+#if LV_USE_GPU
+        if(disp->driver.gpu_blend_cb && (lv_area_get_size(draw_area) > GPU_SIZE_LIMIT)) {
+            for(y = draw_area->y1; y <= draw_area->y2; y++) {
+                disp->driver.gpu_blend_cb(&disp->driver, disp_buf_first, map_buf_first, draw_area_w, opa);
+                disp_buf_first += disp_w;
+                map_buf_first += map_w;
+            }
+            return;
+        }
+#endif
+
+        if(opa > LV_OPA_MAX) {
+#if LV_USE_GPU_STM32_DMA2D
+            if(lv_area_get_size(draw_area) >= 240) {
+                lv_gpu_stm32_dma2d_copy(disp_buf_first, disp_w, map_buf_first, map_w, draw_area_w, draw_area_h);
+                return;
+            }
+#endif
+
+            /*Software rendering*/
+            for(y = 0; y < draw_area_h; y++) {
+                _lv_memcpy(disp_buf_first, map_buf_first, draw_area_w * sizeof(lv_color_t));
+                disp_buf_first += disp_w;
+                map_buf_first += map_w;
+            }
+        }
+        else {
+#if LV_USE_GPU_STM32_DMA2D
+            if(lv_area_get_size(draw_area) >= 240) {
+                lv_gpu_stm32_dma2d_blend(disp_buf_first, disp_w, map_buf_first, opa, map_w, draw_area_w, draw_area_h);
+                return;
+            }
+#endif
+
+            /*Software rendering*/
+
+            for(y = 0; y < draw_area_h; y++) {
+                for(x = 0; x < draw_area_w; x++) {
+#if LV_COLOR_SCREEN_TRANSP
+                    if(disp->driver.screen_transp) {
+                        lv_color_mix_with_alpha(disp_buf_first[x], disp_buf_first[x].ch.alpha, map_buf_first[x], opa, &disp_buf_first[x],
+                                                &disp_buf_first[x].ch.alpha);
+                    }
+                    else
+#endif
+                    {
+                        disp_buf_first[x] = lv_color_mix(map_buf_first[x], disp_buf_first[x], opa);
+                    }
+                }
+                disp_buf_first += disp_w;
+                map_buf_first += map_w;
+            }
+        }
+    }
+    /*Masked*/
+    else {
+        /*Only the mask matters*/
+        if(opa > LV_OPA_MAX) {
+            /*Go to the first pixel of the row */
+
+            int32_t x_end4 = draw_area_w - 4;
+
+            for(y = 0; y < draw_area_h; y++) {
+                const lv_opa_t * mask_tmp_x = mask;
+#if 0
+                for(x = 0; x < draw_area_w; x++) {
+                    MAP_NORMAL_MASK_PX(x);
+                }
+#else
+                for(x = 0; x < draw_area_w && ((lv_uintptr_t)mask_tmp_x & 0x3); x++) {
+#if LV_COLOR_SCREEN_TRANSP
+                    MAP_NORMAL_MASK_PX_SCR_TRANSP(x)
+#else
+                    MAP_NORMAL_MASK_PX(x)
+#endif
+                }
+
+                uint32_t * mask32 = (uint32_t *) mask_tmp_x;
+                for(; x < x_end4; x += 4) {
+                    if(*mask32) {
+                        if((*mask32) == 0xFFFFFFFF) {
+                            disp_buf_first[x] = map_buf_first[x];
+                            disp_buf_first[x + 1] = map_buf_first[x + 1];
+                            disp_buf_first[x + 2] = map_buf_first[x + 2];
+                            disp_buf_first[x + 3] = map_buf_first[x + 3];
+                        }
+                        else {
+                            mask_tmp_x = (const lv_opa_t *)mask32;
+#if LV_COLOR_SCREEN_TRANSP
+                            MAP_NORMAL_MASK_PX_SCR_TRANSP(x)
+                            MAP_NORMAL_MASK_PX_SCR_TRANSP(x + 1)
+                            MAP_NORMAL_MASK_PX_SCR_TRANSP(x + 2)
+                            MAP_NORMAL_MASK_PX_SCR_TRANSP(x + 3)
+#else
+                            MAP_NORMAL_MASK_PX(x)
+                            MAP_NORMAL_MASK_PX(x + 1)
+                            MAP_NORMAL_MASK_PX(x + 2)
+                            MAP_NORMAL_MASK_PX(x + 3)
+#endif
+                        }
+                    }
+                    mask32++;
+                }
+
+                mask_tmp_x = (const lv_opa_t *)mask32;
+                for(; x < draw_area_w ; x++) {
+#if LV_COLOR_SCREEN_TRANSP
+                    MAP_NORMAL_MASK_PX_SCR_TRANSP(x)
+#else
+                    MAP_NORMAL_MASK_PX(x)
+#endif
+                }
+#endif
+                disp_buf_first += disp_w;
+                mask += draw_area_w;
+                map_buf_first += map_w;
+            }
+        }
+        /*Handle opa and mask values too*/
+        else {
+            for(y = 0; y < draw_area_h; y++) {
+                for(x = 0; x < draw_area_w; x++) {
+                    if(mask[x]) {
+                        lv_opa_t opa_tmp = mask[x] >= LV_OPA_MAX ? opa : ((opa * mask[x]) >> 8);
+#if LV_COLOR_SCREEN_TRANSP
+                        if(disp->driver.screen_transp) {
+                            lv_color_mix_with_alpha(disp_buf_first[x], disp_buf_first[x].ch.alpha, map_buf_first[x], opa_tmp, &disp_buf_first[x],
+                                                    &disp_buf_first[x].ch.alpha);
+                        }
+                        else
+#endif
+                        {
+                            disp_buf_first[x] = lv_color_mix(map_buf_first[x], disp_buf_first[x], opa_tmp);
+                        }
+                    }
+                }
+                disp_buf_first += disp_w;
+                mask += draw_area_w;
+                map_buf_first += map_w;
+            }
+        }
+    }
+}
+
+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)
+{
+
+    /*Get the width of the `disp_area` it will be used to go to the next line*/
+    int32_t disp_w = lv_area_get_width(disp_area);
+
+    /*Get the width of the `draw_area` it will be used to go to the next line of the mask*/
+    int32_t draw_area_w = lv_area_get_width(draw_area);
+
+    /*Get the width of the `mask_area` it will be used to go to the next line*/
+    int32_t map_w = lv_area_get_width(map_area);
+
+    /*Create a temp. disp_buf which always point to current line to draw*/
+    lv_color_t * disp_buf_tmp = disp_buf + disp_w * draw_area->y1;
+
+    /*Create a temp. map_buf which always point to current line to draw*/
+    const lv_color_t * map_buf_tmp = map_buf + map_w * (draw_area->y1 - (map_area->y1 - disp_area->y1));
+
+    lv_color_t (*blend_fp)(lv_color_t, lv_color_t, lv_opa_t);
+    switch(mode) {
+        case LV_BLEND_MODE_ADDITIVE:
+            blend_fp = color_blend_true_color_additive;
+            break;
+        case LV_BLEND_MODE_SUBTRACTIVE:
+            blend_fp = color_blend_true_color_subtractive;
+            break;
+        default:
+            LV_LOG_WARN("fill_blended: unsupported blend mode");
+            return;
+    }
+
+    int32_t x;
+    int32_t y;
+
+    /*Simple fill (maybe with opacity), no masking*/
+    if(mask_res == LV_DRAW_MASK_RES_FULL_COVER) {
+        /*Go to the first px of the row*/
+        map_buf_tmp += (draw_area->x1 - (map_area->x1 - disp_area->x1));
+
+        /*The map will be indexed from `draw_area->x1` so compensate it.*/
+        map_buf_tmp -= draw_area->x1;
+
+        for(y = draw_area->y1; y <= draw_area->y2; y++) {
+            for(x = draw_area->x1; x <= draw_area->x2; x++) {
+                disp_buf_tmp[x] = blend_fp(map_buf_tmp[x], disp_buf_tmp[x], opa);
+            }
+            disp_buf_tmp += disp_w;
+            map_buf_tmp += map_w;
+        }
+    }
+    /*Masked*/
+    else {
+        /* The mask is relative to the clipped area.
+         * In the cycles below mask will be indexed from `draw_area.x1`
+         * but it corresponds to zero index. So prepare `mask_tmp` accordingly. */
+        const lv_opa_t * mask_tmp = mask - draw_area->x1;
+
+        map_buf_tmp -= draw_area->x1;
+        for(y = draw_area->y1; y <= draw_area->y2; y++) {
+            for(x = draw_area->x1; x <= draw_area->x2; x++) {
+                if(mask_tmp[x] == 0) continue;
+                lv_opa_t opa_tmp = mask_tmp[x] >= LV_OPA_MAX ? opa : ((opa * mask_tmp[x]) >> 8);
+                disp_buf_tmp[x] = blend_fp(map_buf_tmp[x], disp_buf_tmp[x], opa_tmp);
+            }
+            disp_buf_tmp += disp_w;
+            mask_tmp += draw_area_w;
+            map_buf_tmp += map_w;
+        }
+    }
+}
+
+static inline lv_color_t color_blend_true_color_additive(lv_color_t fg, lv_color_t bg, lv_opa_t opa)
+{
+
+    if(opa <= LV_OPA_MIN) return bg;
+
+    uint32_t tmp;
+#if LV_COLOR_DEPTH == 1
+    tmp = bg.full + fg.full;
+    fg.full = LV_MATH_MIN(tmp, 1);
+#else
+    tmp = bg.ch.red + fg.ch.red;
+#if LV_COLOR_DEPTH == 8
+    fg.ch.red = LV_MATH_MIN(tmp, 7);
+#elif LV_COLOR_DEPTH == 16
+    fg.ch.red = LV_MATH_MIN(tmp, 31);
+#elif LV_COLOR_DEPTH == 32
+    fg.ch.red = LV_MATH_MIN(tmp, 255);
+#endif
+
+#if LV_COLOR_DEPTH == 8
+    fg.ch.green = LV_MATH_MIN(tmp, 7);
+#elif LV_COLOR_DEPTH == 16
+#if LV_COLOR_16_SWAP == 0
+    tmp = bg.ch.green + fg.ch.green;
+    fg.ch.green = LV_MATH_MIN(tmp, 63);
+#else
+    tmp = (bg.ch.green_h << 3) + bg.ch.green_l + (fg.ch.green_h << 3) + fg.ch.green_l;
+    tmp = LV_MATH_MIN(tmp, 63);
+    fg.ch.green_h = tmp >> 3;
+    fg.ch.green_l = tmp & 0x7;
+#endif
+
+#elif LV_COLOR_DEPTH == 32
+    fg.ch.green = LV_MATH_MIN(tmp, 255);
+#endif
+
+    tmp = bg.ch.blue + fg.ch.blue;
+#if LV_COLOR_DEPTH == 8
+    fg.ch.blue = LV_MATH_MIN(tmp, 4);
+#elif LV_COLOR_DEPTH == 16
+    fg.ch.blue = LV_MATH_MIN(tmp, 31);
+#elif LV_COLOR_DEPTH == 32
+    fg.ch.blue = LV_MATH_MIN(tmp, 255);
+#endif
+#endif
+
+    if(opa == LV_OPA_COVER) return fg;
+
+    return lv_color_mix(fg, bg, opa);
+}
+
+static inline lv_color_t color_blend_true_color_subtractive(lv_color_t fg, lv_color_t bg, lv_opa_t opa)
+{
+
+    if(opa <= LV_OPA_MIN) return bg;
+
+    int32_t tmp;
+    tmp = bg.ch.red - fg.ch.red;
+    fg.ch.red = LV_MATH_MAX(tmp, 0);
+
+#if LV_COLOR_16_SWAP == 0
+    tmp = bg.ch.green - fg.ch.green;
+    fg.ch.green = LV_MATH_MAX(tmp, 0);
+#else
+    tmp = (bg.ch.green_h << 3) + bg.ch.green_l + (fg.ch.green_h << 3) + fg.ch.green_l;
+    tmp = LV_MATH_MAX(tmp, 0);
+    fg.ch.green_h = tmp >> 3;
+    fg.ch.green_l = tmp & 0x7;
+#endif
+
+    tmp = bg.ch.blue - fg.ch.blue;
+    fg.ch.blue = LV_MATH_MAX(tmp, 0);
+
+    if(opa == LV_OPA_COVER) return fg;
+
+    return lv_color_mix(fg, bg, opa);
+}

src/lv_draw/lv_draw_blend.h

@@ -0,0 +1,57 @@
+/**
+ * @file lv_draw_blend.h
+ *
+ */
+
+#ifndef LV_DRAW_BLEND_H
+#define LV_DRAW_BLEND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "../lv_misc/lv_color.h"
+#include "../lv_misc/lv_area.h"
+#include "lv_draw_mask.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+enum {
+    LV_BLEND_MODE_NORMAL,
+    LV_BLEND_MODE_ADDITIVE,
+    LV_BLEND_MODE_SUBTRACTIVE,
+};
+
+typedef uint8_t lv_blend_mode_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+//! @cond Doxygen_Suppress
+LV_ATTRIBUTE_FAST_MEM void _lv_blend_fill(const lv_area_t * clip_area, const lv_area_t * fill_area, lv_color_t color,
+                                          lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa, lv_blend_mode_t mode);
+
+
+LV_ATTRIBUTE_FAST_MEM void _lv_blend_map(const lv_area_t * clip_area, const lv_area_t * map_area,
+                                         const lv_color_t * map_buf,
+                                         lv_opa_t * mask, lv_draw_mask_res_t mask_res, lv_opa_t opa, lv_blend_mode_t mode);
+
+//! @endcond
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_DRAW_BLEND_H*/

src/lv_draw/lv_draw_img.c

@@ -8,8 +8,13 @@
  *********************/
 #include "lv_draw_img.h"
 #include "lv_img_cache.h"
+#include "../lv_hal/lv_hal_disp.h"
 #include "../lv_misc/lv_log.h"
+#include "../lv_core/lv_refr.h"
 #include "../lv_misc/lv_mem.h"
+#include "../lv_misc/lv_math.h"
+#include "../lv_gpu/lv_gpu_stm32_dma2d.h"
+
 
 /*********************
  *      DEFINES
@@ -22,8 +27,16 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * mask, const void * src,
-                                 const lv_style_t * style, lv_opa_t opa_scale);
+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);
+
+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);
+
+static void show_error(const lv_area_t * coords, const lv_area_t * clip_area, const char * msg);
 
 /**********************
  *  STATIC VARIABLES
@@ -37,354 +50,87 @@ static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * mas
  *   GLOBAL FUNCTIONS
  **********************/
 
+void lv_draw_img_dsc_init(lv_draw_img_dsc_t * dsc)
+{
+    _lv_memset_00(dsc, sizeof(lv_draw_img_dsc_t));
+    dsc->recolor = LV_COLOR_BLACK;
+    dsc->opa = LV_OPA_COVER;
+    dsc->zoom = LV_IMG_ZOOM_NONE;
+    dsc->antialias = LV_ANTIALIAS;
+
+}
+
 /**
  * Draw an image
  * @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
  */
-void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, const lv_style_t * style,
-                 lv_opa_t opa_scale)
+void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, lv_draw_img_dsc_t * dsc)
 {
     if(src == NULL) {
         LV_LOG_WARN("Image draw: src is NULL");
-        lv_draw_rect(coords, mask, &lv_style_plain, LV_OPA_COVER);
-        lv_draw_label(coords, mask, &lv_style_plain, LV_OPA_COVER, "No\ndata", LV_TXT_FLAG_NONE, NULL, NULL, NULL, LV_BIDI_DIR_LTR);
+        show_error(coords, mask, "No\ndata");
         return;
     }
 
+    if(dsc->opa <= LV_OPA_MIN) return;
+
     lv_res_t res;
-    res = lv_img_draw_core(coords, mask, src, style, opa_scale);
+    res = lv_img_draw_core(coords, mask, src, dsc);
 
     if(res == LV_RES_INV) {
         LV_LOG_WARN("Image draw error");
-        lv_draw_rect(coords, mask, &lv_style_plain, LV_OPA_COVER);
-        lv_draw_label(coords, mask, &lv_style_plain, LV_OPA_COVER, "No\ndata", LV_TXT_FLAG_NONE, NULL,  NULL, NULL, LV_BIDI_DIR_LTR);
+        show_error(coords, mask, "No\ndata");
         return;
     }
 }
 
-/**
- * Get the color of an image's pixel
- * @param dsc an image descriptor
- * @param x x coordinate of the point to get
- * @param y x coordinate of the point to get
- * @param style style of the image. In case of `LV_IMG_CF_ALPHA_1/2/4/8` `style->image.color` shows
- * the color. Can be `NULL` but for `ALPHA` images black will be returned. In other cases it is not
- * used.
- * @return color of the point
- */
-lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, const lv_style_t * style)
-{
-    lv_color_t p_color = LV_COLOR_BLACK;
-    if(x >= (lv_coord_t)dsc->header.w) {
-        x = dsc->header.w - 1;
-        LV_LOG_WARN("lv_canvas_get_px: x is too large (out of canvas)");
-    } else if(x < 0) {
-        x = 0;
-        LV_LOG_WARN("lv_canvas_get_px: x is < 0 (out of canvas)");
-    }
-
-    if(y >= (lv_coord_t)dsc->header.h) {
-        y = dsc->header.h - 1;
-        LV_LOG_WARN("lv_canvas_get_px: y is too large (out of canvas)");
-    } else if(y < 0) {
-        y = 0;
-        LV_LOG_WARN("lv_canvas_get_px: y is < 0 (out of canvas)");
-    }
-
-    uint8_t * buf_u8 = (uint8_t *)dsc->data;
-
-    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED ||
-       dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
-        uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf) >> 3;
-        uint32_t px     = dsc->header.w * y * px_size + x * px_size;
-        memcpy(&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*/
-#endif
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) {
-        buf_u8 += 4 * 2;
-        uint8_t bit = x & 0x7;
-        x           = x >> 3;
-
-        /* Get the current pixel.
-         * dsc->header.w + 7 means rounding up to 8 because the lines are byte aligned
-         * so the possible real width are 8, 16, 24 ...*/
-        uint32_t px  = ((dsc->header.w + 7) >> 3) * y + x;
-        p_color.full = (buf_u8[px] & (1 << (7 - bit))) >> (7 - bit);
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_2BIT) {
-        buf_u8 += 4 * 4;
-        uint8_t bit = (x & 0x3) * 2;
-        x           = x >> 2;
-
-        /* Get the current pixel.
-         * dsc->header.w + 3 means rounding up to 4 because the lines are byte aligned
-         * so the possible real width are 4, 8, 12 ...*/
-        uint32_t px  = ((dsc->header.w + 3) >> 2) * y + x;
-        p_color.full = (buf_u8[px] & (3 << (6 - bit))) >> (6 - bit);
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_4BIT) {
-        buf_u8 += 4 * 16;
-        uint8_t bit = (x & 0x1) * 4;
-        x           = x >> 1;
-
-        /* Get the current pixel.
-         * dsc->header.w + 1 means rounding up to 2 because the lines are byte aligned
-         * so the possible real width are 2, 4, 6 ...*/
-        uint32_t px  = ((dsc->header.w + 1) >> 1) * y + x;
-        p_color.full = (buf_u8[px] & (0xF << (4 - bit))) >> (4 - bit);
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
-        buf_u8 += 4 * 256;
-        uint32_t px  = dsc->header.w * y + x;
-        p_color.full = buf_u8[px];
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT || dsc->header.cf == LV_IMG_CF_ALPHA_2BIT ||
-              dsc->header.cf == LV_IMG_CF_ALPHA_4BIT || dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
-        if(style)
-            p_color = style->image.color;
-        else
-            p_color = LV_COLOR_BLACK;
-    }
-    return p_color;
-}
-
-/**
- * Get the alpha value of an image's pixel
- * @param dsc pointer to an image descriptor
- * @param x x coordinate of the point to set
- * @param y x coordinate of the point to set
- * @return alpha value of the point
- */
-lv_opa_t lv_img_buf_get_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y)
-{
-    if(x >= (lv_coord_t)dsc->header.w) {
-        x = dsc->header.w - 1;
-        LV_LOG_WARN("lv_canvas_get_px: x is too large (out of canvas)");
-    } else if(x < 0) {
-        x = 0;
-        LV_LOG_WARN("lv_canvas_get_px: x is < 0 (out of canvas)");
-    }
-
-    if(y >= (lv_coord_t)dsc->header.h) {
-        y = dsc->header.h - 1;
-        LV_LOG_WARN("lv_canvas_get_px: y is too large (out of canvas)");
-    } else if(y < 0) {
-        y = 0;
-        LV_LOG_WARN("lv_canvas_get_px: y is < 0 (out of canvas)");
-    }
-
-    uint8_t * buf_u8 = (uint8_t *)dsc->data;
-
-    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
-        uint32_t px = dsc->header.w * y * LV_IMG_PX_SIZE_ALPHA_BYTE + x * LV_IMG_PX_SIZE_ALPHA_BYTE;
-        return buf_u8[px + LV_IMG_PX_SIZE_ALPHA_BYTE - 1];
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT) {
-        uint8_t bit = x & 0x7;
-        x           = x >> 3;
-
-        /* Get the current pixel.
-         * dsc->header.w + 7 means rounding up to 8 because the lines are byte aligned
-         * so the possible real width are 8 ,16, 24 ...*/
-        uint32_t px    = ((dsc->header.w + 7) >> 3) * y + x;
-        uint8_t px_opa = (buf_u8[px] & (1 << (7 - bit))) >> (7 - bit);
-        return px_opa ? LV_OPA_TRANSP : LV_OPA_COVER;
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_2BIT) {
-        const uint8_t opa_table[4] = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/
-
-        uint8_t bit = (x & 0x3) * 2;
-        x           = x >> 2;
-
-        /* Get the current pixel.
-         * dsc->header.w + 4 means rounding up to 8 because the lines are byte aligned
-         * so the possible real width are 4 ,8, 12 ...*/
-        uint32_t px    = ((dsc->header.w + 3) >> 2) * y + x;
-        uint8_t px_opa = (buf_u8[px] & (3 << (6 - bit))) >> (6 - bit);
-        return opa_table[px_opa];
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_4BIT) {
-        const uint8_t opa_table[16] = {0,  17, 34,  51, /*Opacity mapping with bpp = 4*/
-                                       68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
-
-        uint8_t bit = (x & 0x1) * 4;
-        x           = x >> 1;
-
-        /* Get the current pixel.
-         * dsc->header.w + 1 means rounding up to 8 because the lines are byte aligned
-         * so the possible real width are 2 ,4, 6 ...*/
-        uint32_t px    = ((dsc->header.w + 1) >> 1) * y + x;
-        uint8_t px_opa = (buf_u8[px] & (0xF << (4 - bit))) >> (4 - bit);
-        return opa_table[px_opa];
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
-        uint32_t px = dsc->header.w * y + x;
-        return buf_u8[px];
-    }
-
-    return LV_OPA_COVER;
-}
-
-/**
- * Set the color of a pixel of an image. The alpha channel won't be affected.
- * @param dsc pointer to an image descriptor
- * @param x x coordinate of the point to set
- * @param y x coordinate of the point to set
- * @param c color of the point
- */
-void lv_img_buf_set_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_color_t c)
-{
-    uint8_t * buf_u8 = (uint8_t *)dsc->data;
-
-    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) {
-        uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf) >> 3;
-        uint32_t px     = dsc->header.w * y * px_size + x * px_size;
-        memcpy(&buf_u8[px], &c, px_size);
-    } else if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
-        uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf) >> 3;
-        uint32_t px     = dsc->header.w * y * px_size + x * px_size;
-        memcpy(&buf_u8[px], &c, px_size - 1); /*-1 to not overwrite the alpha value*/
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) {
-        buf_u8 += sizeof(lv_color32_t) * 2; /*Skip the palette*/
-
-        uint8_t bit = x & 0x7;
-        x           = x >> 3;
-
-        /* Get the current pixel.
-         * dsc->header.w + 7 means rounding up to 8 because the lines are byte aligned
-         * so the possible real width are 8 ,16, 24 ...*/
-        uint32_t px = ((dsc->header.w + 7) >> 3) * y + x;
-        buf_u8[px]  = buf_u8[px] & ~(1 << (7 - bit));
-        buf_u8[px]  = buf_u8[px] | ((c.full & 0x1) << (7 - bit));
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_2BIT) {
-        buf_u8 += sizeof(lv_color32_t) * 4; /*Skip the palette*/
-        uint8_t bit = (x & 0x3) * 2;
-        x           = x >> 2;
-
-        /* Get the current pixel.
-         * dsc->header.w + 3 means rounding up to 4 because the lines are byte aligned
-         * so the possible real width are 4, 8 ,12 ...*/
-        uint32_t px = ((dsc->header.w + 3) >> 2) * y + x;
-
-        buf_u8[px] = buf_u8[px] & ~(3 << (6 - bit));
-        buf_u8[px] = buf_u8[px] | ((c.full & 0x3) << (6 - bit));
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_4BIT) {
-        buf_u8 += sizeof(lv_color32_t) * 16; /*Skip the palette*/
-        uint8_t bit = (x & 0x1) * 4;
-        x           = x >> 1;
-
-        /* Get the current pixel.
-         * dsc->header.w + 1 means rounding up to 2 because the lines are byte aligned
-         * so the possible real width are 2 ,4, 6 ...*/
-        uint32_t px = ((dsc->header.w + 1) >> 1) * y + x;
-        buf_u8[px]  = buf_u8[px] & ~(0xF << (4 - bit));
-        buf_u8[px]  = buf_u8[px] | ((c.full & 0xF) << (4 - bit));
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
-        buf_u8 += sizeof(lv_color32_t) * 256; /*Skip the palette*/
-        uint32_t px = dsc->header.w * y + x;
-        buf_u8[px]  = c.full;
-    }
-}
-
-/**
- * Set the alpha value of a pixel of an image. The color won't be affected
- * @param dsc pointer to an image descriptor
- * @param x x coordinate of the point to set
- * @param y x coordinate of the point to set
- * @param opa the desired opacity
- */
-void lv_img_buf_set_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_opa_t opa)
-{
-    uint8_t * buf_u8 = (uint8_t *)dsc->data;
-
-    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
-        uint8_t px_size          = lv_img_color_format_get_px_size(dsc->header.cf) >> 3;
-        uint32_t px              = dsc->header.w * y * px_size + x * px_size;
-        buf_u8[px + px_size - 1] = opa;
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT) {
-        opa         = opa >> 7; /*opa -> [0,1]*/
-        uint8_t bit = x & 0x7;
-        x           = x >> 3;
-
-        /* Get the current pixel.
-         * dsc->header.w + 7 means rounding up to 8 because the lines are byte aligned
-         * so the possible real width are 8 ,16, 24 ...*/
-        uint32_t px = ((dsc->header.w + 7) >> 3) * y + x;
-        buf_u8[px]  = buf_u8[px] & ~(1 << (7 - bit));
-        buf_u8[px]  = buf_u8[px] | ((opa & 0x1) << (7 - bit));
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_2BIT) {
-        opa         = opa >> 6; /*opa -> [0,3]*/
-        uint8_t bit = (x & 0x3) * 2;
-        x           = x >> 2;
-
-        /* Get the current pixel.
-         * dsc->header.w + 4 means rounding up to 8 because the lines are byte aligned
-         * so the possible real width are 4 ,8, 12 ...*/
-        uint32_t px = ((dsc->header.w + 3) >> 2) * y + x;
-        buf_u8[px]  = buf_u8[px] & ~(3 << (6 - bit));
-        buf_u8[px]  = buf_u8[px] | ((opa & 0x3) << (6 - bit));
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_4BIT) {
-        opa         = opa >> 4; /*opa -> [0,15]*/
-        uint8_t bit = (x & 0x1) * 4;
-        x           = x >> 1;
-
-        /* Get the current pixel.
-         * dsc->header.w + 1 means rounding up to 8 because the lines are byte aligned
-         * so the possible real width are 2 ,4, 6 ...*/
-        uint32_t px = ((dsc->header.w + 1) >> 1) * y + x;
-        buf_u8[px]  = buf_u8[px] & ~(0xF << (4 - bit));
-        buf_u8[px]  = buf_u8[px] | ((opa & 0xF) << (4 - bit));
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
-        uint32_t px = dsc->header.w * y + x;
-        buf_u8[px]  = opa;
-    }
-}
-
-/**
- * Set the palette color of an indexed image. Valid only for `LV_IMG_CF_INDEXED1/2/4/8`
- * @param dsc pointer to an image descriptor
- * @param id the palette color to set:
- *   - for `LV_IMG_CF_INDEXED1`: 0..1
- *   - for `LV_IMG_CF_INDEXED2`: 0..3
- *   - for `LV_IMG_CF_INDEXED4`: 0..15
- *   - for `LV_IMG_CF_INDEXED8`: 0..255
- * @param c the color to set
- */
-void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c)
-{
-    if((dsc->header.cf == LV_IMG_CF_ALPHA_1BIT && id > 1) || (dsc->header.cf == LV_IMG_CF_ALPHA_2BIT && id > 3) ||
-       (dsc->header.cf == LV_IMG_CF_ALPHA_4BIT && id > 15) || (dsc->header.cf == LV_IMG_CF_ALPHA_8BIT)) {
-        LV_LOG_WARN("lv_img_buf_set_px_alpha: invalid 'id'");
-        return;
-    }
-
-    lv_color32_t c32;
-    c32.full      = lv_color_to32(c);
-    uint8_t * buf = (uint8_t *)dsc->data;
-    memcpy(&buf[id * sizeof(c32)], &c32, sizeof(c32));
-}
-
 /**
  * Get the pixel size of a color format in bits
  * @param cf a color format (`LV_IMG_CF_...`)
  * @return the pixel size in bits
  */
-uint8_t lv_img_color_format_get_px_size(lv_img_cf_t cf)
+uint8_t lv_img_cf_get_px_size(lv_img_cf_t cf)
 {
     uint8_t px_size = 0;
 
     switch(cf) {
         case LV_IMG_CF_UNKNOWN:
-        case LV_IMG_CF_RAW: px_size = 0; break;
+        case LV_IMG_CF_RAW:
+            px_size = 0;
+            break;
         case LV_IMG_CF_TRUE_COLOR:
-        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED: px_size = LV_COLOR_SIZE; break;
-        case LV_IMG_CF_TRUE_COLOR_ALPHA: px_size = LV_IMG_PX_SIZE_ALPHA_BYTE << 3; break;
+        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED:
+            px_size = LV_COLOR_SIZE;
+            break;
+        case LV_IMG_CF_TRUE_COLOR_ALPHA:
+            px_size = LV_IMG_PX_SIZE_ALPHA_BYTE << 3;
+            break;
         case LV_IMG_CF_INDEXED_1BIT:
-        case LV_IMG_CF_ALPHA_1BIT: px_size = 1; break;
+        case LV_IMG_CF_ALPHA_1BIT:
+            px_size = 1;
+            break;
         case LV_IMG_CF_INDEXED_2BIT:
-        case LV_IMG_CF_ALPHA_2BIT: px_size = 2; break;
+        case LV_IMG_CF_ALPHA_2BIT:
+            px_size = 2;
+            break;
         case LV_IMG_CF_INDEXED_4BIT:
-        case LV_IMG_CF_ALPHA_4BIT: px_size = 4; break;
+        case LV_IMG_CF_ALPHA_4BIT:
+            px_size = 4;
+            break;
         case LV_IMG_CF_INDEXED_8BIT:
-        case LV_IMG_CF_ALPHA_8BIT: px_size = 8; break;
-        default: px_size = 0; break;
+        case LV_IMG_CF_ALPHA_8BIT:
+            px_size = 8;
+            break;
+        default:
+            px_size = 0;
+            break;
     }
 
     return px_size;
@@ -395,22 +141,23 @@ uint8_t lv_img_color_format_get_px_size(lv_img_cf_t cf)
  * @param cf a color format (`LV_IMG_CF_...`)
  * @return true: chroma keyed; false: not chroma keyed
  */
-bool lv_img_color_format_is_chroma_keyed(lv_img_cf_t cf)
+bool lv_img_cf_is_chroma_keyed(lv_img_cf_t cf)
 {
     bool is_chroma_keyed = false;
 
     switch(cf) {
         case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED:
         case LV_IMG_CF_RAW_CHROMA_KEYED:
-#if LV_INDEXED_CHROMA
         case LV_IMG_CF_INDEXED_1BIT:
         case LV_IMG_CF_INDEXED_2BIT:
         case LV_IMG_CF_INDEXED_4BIT:
         case LV_IMG_CF_INDEXED_8BIT:
-#endif
-            is_chroma_keyed = true; break;
+            is_chroma_keyed = true;
+            break;
 
-        default: is_chroma_keyed = false; break;
+        default:
+            is_chroma_keyed = false;
+            break;
     }
 
     return is_chroma_keyed;
@@ -421,7 +168,7 @@ bool lv_img_color_format_is_chroma_keyed(lv_img_cf_t cf)
  * @param cf a color format (`LV_IMG_CF_...`)
  * @return true: has alpha channel; false: doesn't have alpha channel
  */
-bool lv_img_color_format_has_alpha(lv_img_cf_t cf)
+bool lv_img_cf_has_alpha(lv_img_cf_t cf)
 {
     bool has_alpha = false;
 
@@ -435,8 +182,12 @@ bool lv_img_color_format_has_alpha(lv_img_cf_t cf)
         case LV_IMG_CF_ALPHA_1BIT:
         case LV_IMG_CF_ALPHA_2BIT:
         case LV_IMG_CF_ALPHA_4BIT:
-        case LV_IMG_CF_ALPHA_8BIT: has_alpha = true; break;
-        default: has_alpha = false; break;
+        case LV_IMG_CF_ALPHA_8BIT:
+            has_alpha = true;
+            break;
+        default:
+            has_alpha = false;
+            break;
     }
 
     return has_alpha;
@@ -460,9 +211,11 @@ lv_img_src_t lv_img_src_get_type(const void * src)
     /*The first byte shows the type of the image source*/
     if(u8_p[0] >= 0x20 && u8_p[0] <= 0x7F) {
         img_src_type = LV_IMG_SRC_FILE; /*If it's an ASCII character then it's file name*/
-    } else if(u8_p[0] >= 0x80) {
+    }
+    else if(u8_p[0] >= 0x80) {
         img_src_type = LV_IMG_SRC_SYMBOL; /*Symbols begins after 0x7F*/
-    } else {
+    }
+    else {
         img_src_type = LV_IMG_SRC_VARIABLE; /*`lv_img_dsc_t` is design to the first byte < 0x20*/
     }
 
@@ -473,129 +226,413 @@ lv_img_src_t lv_img_src_get_type(const void * src)
     return img_src_type;
 }
 
-lv_img_dsc_t *lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
-{
-    /* Allocate image descriptor */
-    lv_img_dsc_t *dsc = lv_mem_alloc(sizeof(lv_img_dsc_t));
-    if(dsc == NULL)
-        return NULL;
-    
-    memset(dsc, 0, sizeof(lv_img_dsc_t));
-    
-    /* Get image data size */
-    dsc->data_size = lv_img_buf_get_img_size(w, h, cf);
-    if(dsc->data_size == 0) {
-        lv_mem_free(dsc);
-        return NULL;
-    }
-    
-    /* Allocate raw buffer */
-    dsc->data = lv_mem_alloc(dsc->data_size);
-    if(dsc->data == NULL) {
-        lv_mem_free(dsc);
-        return NULL;
-    }
-    memset((uint8_t *)dsc->data, 0, dsc->data_size);
-    
-    /* Fill in header */
-    dsc->header.always_zero = 0;
-    dsc->header.w = w;
-    dsc->header.h = h;
-    dsc->header.cf = cf;
-    return dsc;
-}
-
-void lv_img_buf_free(lv_img_dsc_t *dsc)
-{
-    if(dsc != NULL) {
-        if(dsc->data != NULL)
-            lv_mem_free(dsc->data);
-        
-        lv_mem_free(dsc);
-    }
-}
-
-uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
-{
-    switch(cf) {
-        case LV_IMG_CF_TRUE_COLOR: return LV_IMG_BUF_SIZE_TRUE_COLOR(w, h);
-        case LV_IMG_CF_TRUE_COLOR_ALPHA: return LV_IMG_BUF_SIZE_TRUE_COLOR_ALPHA(w, h);
-        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED: return LV_IMG_BUF_SIZE_TRUE_COLOR_CHROMA_KEYED(w, h);
-        case LV_IMG_CF_ALPHA_1BIT: return LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h);
-        case LV_IMG_CF_ALPHA_2BIT: return LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h);
-        case LV_IMG_CF_ALPHA_4BIT: return LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h);
-        case LV_IMG_CF_ALPHA_8BIT: return LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h);
-        case LV_IMG_CF_INDEXED_1BIT: return LV_IMG_BUF_SIZE_INDEXED_1BIT(w, h);
-        case LV_IMG_CF_INDEXED_2BIT: return LV_IMG_BUF_SIZE_INDEXED_2BIT(w, h);
-        case LV_IMG_CF_INDEXED_4BIT: return LV_IMG_BUF_SIZE_INDEXED_4BIT(w, h);
-        case LV_IMG_CF_INDEXED_8BIT: return LV_IMG_BUF_SIZE_INDEXED_8BIT(w, h);
-        default: return 0;
-    }
-}
-
 /**********************
  *   STATIC FUNCTIONS
  **********************/
 
-static lv_res_t lv_img_draw_core(const lv_area_t * coords, const lv_area_t * mask, const void * src,
-                                 const lv_style_t * style, lv_opa_t opa_scale)
+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)
 {
+    if(draw_dsc->opa <= LV_OPA_MIN) return LV_RES_OK;
 
-    lv_area_t mask_com; /*Common area of mask and coords*/
-    bool union_ok;
-    union_ok = lv_area_intersect(&mask_com, mask, coords);
-    if(union_ok == false) {
-        return LV_RES_OK; /*Out of mask. There is nothing to draw so the image is drawn
-                             successfully.*/
-    }
-
-    lv_opa_t opa =
-        opa_scale == LV_OPA_COVER ? style->image.opa : (uint16_t)((uint16_t)style->image.opa * opa_scale) >> 8;
-
-    lv_img_cache_entry_t * cdsc = lv_img_cache_open(src, style);
+    lv_img_cache_entry_t * cdsc = _lv_img_cache_open(src, draw_dsc->recolor);
 
     if(cdsc == NULL) return LV_RES_INV;
 
-    bool chroma_keyed = lv_img_color_format_is_chroma_keyed(cdsc->dec_dsc.header.cf);
-    bool alpha_byte   = lv_img_color_format_has_alpha(cdsc->dec_dsc.header.cf);
+    bool chroma_keyed = lv_img_cf_is_chroma_keyed(cdsc->dec_dsc.header.cf);
+    bool alpha_byte   = lv_img_cf_has_alpha(cdsc->dec_dsc.header.cf);
 
     if(cdsc->dec_dsc.error_msg != NULL) {
         LV_LOG_WARN("Image draw error");
-        lv_draw_rect(coords, mask, &lv_style_plain, LV_OPA_COVER);
-        lv_draw_label(coords, mask, &lv_style_plain, LV_OPA_COVER, cdsc->dec_dsc.error_msg, LV_TXT_FLAG_NONE, NULL, NULL, NULL, LV_BIDI_DIR_LTR);
+
+        show_error(coords, clip_area, cdsc->dec_dsc.error_msg);
     }
-    /* The decoder open could open the image and gave the entire uncompressed image.
+    /* The decoder could open the image and gave the entire uncompressed image.
      * Just draw it!*/
     else if(cdsc->dec_dsc.img_data) {
-        lv_draw_map(coords, mask, cdsc->dec_dsc.img_data, opa, chroma_keyed, alpha_byte, style->image.color,
-                    style->image.intense);
+        lv_area_t map_area_rot;
+        lv_area_copy(&map_area_rot, coords);
+        if(draw_dsc->angle || draw_dsc->zoom != LV_IMG_ZOOM_NONE) {
+            int32_t w = lv_area_get_width(coords);
+            int32_t h = lv_area_get_height(coords);
+
+            _lv_img_buf_get_transformed_area(&map_area_rot, w, h, draw_dsc->angle, draw_dsc->zoom, &draw_dsc->pivot);
+
+            map_area_rot.x1 += coords->x1;
+            map_area_rot.y1 += coords->y1;
+            map_area_rot.x2 += coords->x1;
+            map_area_rot.y2 += coords->y1;
+        }
+
+        lv_area_t mask_com; /*Common area of mask and coords*/
+        bool union_ok;
+        union_ok = _lv_area_intersect(&mask_com, clip_area, &map_area_rot);
+        if(union_ok == false) {
+            return LV_RES_OK; /*Out of mask. There is nothing to draw so the image is drawn
+                                 successfully.*/
+        }
+
+        lv_draw_map(coords, &mask_com, cdsc->dec_dsc.img_data, draw_dsc, chroma_keyed, alpha_byte);
     }
     /* The whole uncompressed image is not available. Try to read it line-by-line*/
     else {
-        lv_coord_t width = lv_area_get_width(&mask_com);
+        lv_area_t mask_com; /*Common area of mask and coords*/
+        bool union_ok;
+        union_ok = _lv_area_intersect(&mask_com, clip_area, coords);
+        if(union_ok == false) {
+            return LV_RES_OK; /*Out of mask. There is nothing to draw so the image is drawn
+                                 successfully.*/
+        }
 
-        uint8_t  * buf = lv_draw_get_buf(lv_area_get_width(&mask_com) * LV_IMG_PX_SIZE_ALPHA_BYTE);  /*space for the possible alpha byte*/
+        int32_t width = lv_area_get_width(&mask_com);
+
+        uint8_t  * buf = _lv_mem_buf_get(lv_area_get_width(&mask_com) *
+                                         LV_IMG_PX_SIZE_ALPHA_BYTE);  /*+1 because of the possible alpha byte*/
 
         lv_area_t line;
         lv_area_copy(&line, &mask_com);
         lv_area_set_height(&line, 1);
-        lv_coord_t x = mask_com.x1 - coords->x1;
-        lv_coord_t y = mask_com.y1 - coords->y1;
-        lv_coord_t row;
+        int32_t x = mask_com.x1 - coords->x1;
+        int32_t y = mask_com.y1 - coords->y1;
+        int32_t row;
         lv_res_t read_res;
         for(row = mask_com.y1; row <= mask_com.y2; row++) {
+            lv_area_t mask_line;
+            union_ok = _lv_area_intersect(&mask_line, clip_area, &line);
+            if(union_ok == false) continue;
+
             read_res = lv_img_decoder_read_line(&cdsc->dec_dsc, x, y, width, buf);
             if(read_res != LV_RES_OK) {
                 lv_img_decoder_close(&cdsc->dec_dsc);
                 LV_LOG_WARN("Image draw can't read the line");
+                _lv_mem_buf_release(buf);
                 return LV_RES_INV;
             }
-            lv_draw_map(&line, mask, buf, opa, chroma_keyed, alpha_byte, style->image.color, style->image.intense);
+
+
+            lv_draw_map(&line, &mask_line, buf, draw_dsc, chroma_keyed, alpha_byte);
             line.y1++;
             line.y2++;
             y++;
         }
+        _lv_mem_buf_release(buf);
     }
 
     return LV_RES_OK;
 }
+
+/**
+ * Draw a color map to the display (image)
+ * @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 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)
+{
+    /* Use the clip area as draw area*/
+    lv_area_t draw_area;
+    lv_area_copy(&draw_area, clip_area);
+
+    lv_disp_t * disp    = _lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+    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;
+
+    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
+
+    /*The simplest case just copy the pixels into the VDB*/
+    if(other_mask_cnt == 0 && draw_dsc->angle == 0 && draw_dsc->zoom == LV_IMG_ZOOM_NONE &&
+       chroma_key == false && alpha_byte == false && draw_dsc->recolor_opa == LV_OPA_TRANSP) {
+        _lv_blend_map(clip_area, map_area, (lv_color_t *)map_p, NULL, LV_DRAW_MASK_RES_FULL_COVER, draw_dsc->opa,
+                      draw_dsc->blend_mode);
+    }
+    /*In the other cases every pixel need to be checked one-by-one*/
+    else {
+        /*The pixel size in byte is different if an alpha byte is added too*/
+        uint8_t px_size_byte = alpha_byte ? LV_IMG_PX_SIZE_ALPHA_BYTE : sizeof(lv_color_t);
+
+        /*Go to the first displayed pixel of the map*/
+        int32_t map_w = lv_area_get_width(map_area);
+        const uint8_t * map_buf_tmp = map_p;
+        map_buf_tmp += map_w * (draw_area.y1 - (map_area->y1 - disp_area->y1)) * px_size_byte;
+        map_buf_tmp += (draw_area.x1 - (map_area->x1 - disp_area->x1)) * px_size_byte;
+
+        lv_color_t c;
+        lv_color_t chroma_keyed_color = LV_COLOR_TRANSP;
+        uint32_t px_i = 0;
+
+        const uint8_t * map_px;
+
+        lv_area_t blend_area;
+        blend_area.x1 = draw_area.x1 + disp_area->x1;
+        blend_area.x2 = blend_area.x1 + lv_area_get_width(&draw_area) - 1;
+        blend_area.y1 = disp_area->y1 + draw_area.y1;
+        blend_area.y2 = blend_area.y1;
+
+        lv_coord_t draw_area_h = lv_area_get_height(&draw_area);
+        lv_coord_t draw_area_w = lv_area_get_width(&draw_area);
+
+#if LV_USE_IMG_TRANSFORM
+        bool transform = draw_dsc->angle != 0 || draw_dsc->zoom != LV_IMG_ZOOM_NONE ? true : false;
+#else
+        bool transform = false;
+#endif
+        /*Simple ARGB image. Handle it as special case because it's very common*/
+        if(other_mask_cnt == 0 && !transform && !chroma_key && draw_dsc->recolor_opa == LV_OPA_TRANSP && alpha_byte) {
+#if LV_USE_GPU_STM32_DMA2D && LV_COLOR_DEPTH == 32
+            /*Blend ARGB images directly*/
+            if(lv_area_get_size(&draw_area) > 240) {
+                int32_t disp_w = lv_area_get_width(disp_area);
+                lv_color_t * disp_buf = vdb->buf_act;
+                lv_color_t * disp_buf_first = disp_buf + disp_w * draw_area.y1 + draw_area.x1;
+                lv_gpu_stm32_dma2d_blend(disp_buf_first, disp_w, (const lv_color_t *)map_buf_tmp, draw_dsc->opa, map_w, draw_area_w,
+                                         draw_area_h);
+                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);
+
+            int32_t x;
+            int32_t y;
+            for(y = 0; y < draw_area_h; y++) {
+                map_px = map_buf_tmp;
+                for(x = 0; x < draw_area_w; x++, map_px += px_size_byte, px_i++) {
+                    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
+                        map2[px_i].full =  map_px[0];
+#elif LV_COLOR_DEPTH == 16
+                        map2[px_i].full =  map_px[0] + (map_px[1] << 8);
+#elif LV_COLOR_DEPTH == 32
+                        map2[px_i].full =  *((uint32_t *)map_px);
+#endif
+                    }
+#if LV_COLOR_DEPTH == 32
+                    map2[px_i].ch.alpha = 0xFF;
+#endif
+                }
+
+                map_buf_tmp += map_w * px_size_byte;
+                if(px_i + lv_area_get_width(&draw_area) < mask_buf_size) {
+                    blend_area.y2 ++;
+                }
+                else {
+                    _lv_blend_map(clip_area, &blend_area, map2, mask_buf, LV_DRAW_MASK_RES_CHANGED, draw_dsc->opa, draw_dsc->blend_mode);
+
+                    blend_area.y1 = blend_area.y2 + 1;
+                    blend_area.y2 = blend_area.y1;
+
+                    px_i = 0;
+                }
+            }
+            /*Flush the last part*/
+            if(blend_area.y1 != blend_area.y2) {
+                blend_area.y2--;
+                _lv_blend_map(clip_area, &blend_area, map2, mask_buf, LV_DRAW_MASK_RES_CHANGED, draw_dsc->opa, draw_dsc->blend_mode);
+            }
+
+            _lv_mem_buf_release(mask_buf);
+            _lv_mem_buf_release(map2);
+        }
+        /*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);
+
+#if LV_USE_IMG_TRANSFORM
+            lv_img_transform_dsc_t trans_dsc;
+            _lv_memset_00(&trans_dsc, sizeof(lv_img_transform_dsc_t));
+            if(transform) {
+                lv_img_cf_t cf = LV_IMG_CF_TRUE_COLOR;
+                if(alpha_byte) cf = LV_IMG_CF_TRUE_COLOR_ALPHA;
+                else if(chroma_key) cf = LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED;
+
+                trans_dsc.cfg.angle = draw_dsc->angle;
+                trans_dsc.cfg.zoom = draw_dsc->zoom;
+                trans_dsc.cfg.src = map_p;
+                trans_dsc.cfg.src_w = map_w;
+                trans_dsc.cfg.src_h = lv_area_get_height(map_area);;
+                trans_dsc.cfg.cf = cf;
+                trans_dsc.cfg.pivot_x = draw_dsc->pivot.x;
+                trans_dsc.cfg.pivot_y = draw_dsc->pivot.y;
+                trans_dsc.cfg.color = draw_dsc->recolor;
+                trans_dsc.cfg.antialias = draw_dsc->antialias;
+
+                _lv_img_buf_transform_init(&trans_dsc);
+            }
+#endif
+            uint16_t recolor_premult[3] = {0};
+            lv_opa_t recolor_opa_inv = 255 - draw_dsc->recolor_opa;
+            if(draw_dsc->recolor_opa != 0) {
+                lv_color_premult(draw_dsc->recolor, draw_dsc->recolor_opa, recolor_premult);
+            }
+
+            lv_draw_mask_res_t mask_res;
+            mask_res = (alpha_byte || chroma_key || draw_dsc->angle ||
+                        draw_dsc->zoom != LV_IMG_ZOOM_NONE) ? LV_DRAW_MASK_RES_CHANGED : LV_DRAW_MASK_RES_FULL_COVER;
+
+
+            /*Prepare the `mask_buf`if there are other masks*/
+            if(other_mask_cnt) {
+                _lv_memset_ff(mask_buf, mask_buf_size);
+            }
+
+            int32_t x;
+            int32_t y;
+#if LV_USE_IMG_TRANSFORM
+            int32_t rot_y = disp_area->y1 + draw_area.y1 - map_area->y1;
+#endif
+            for(y = 0; y < draw_area_h; y++) {
+                map_px = map_buf_tmp;
+                uint32_t px_i_start = px_i;
+
+#if LV_USE_IMG_TRANSFORM
+                int32_t rot_x = disp_area->x1 + draw_area.x1 - map_area->x1;
+#endif
+                for(x = 0; x < draw_area_w; x++, map_px += px_size_byte, px_i++) {
+
+
+#if LV_USE_IMG_TRANSFORM
+                    if(transform) {
+
+                        /*Transform*/
+                        bool ret;
+                        ret = _lv_img_buf_transform(&trans_dsc, rot_x + x, rot_y + y);
+                        if(ret == false) {
+                            mask_buf[px_i] = LV_OPA_TRANSP;
+                            continue;
+                        }
+                        else {
+                            mask_buf[px_i] = trans_dsc.res.opa;
+                            c.full = trans_dsc.res.color.full;
+                        }
+                    }
+                    /*No transform*/
+                    else
+#endif
+                    {
+                        if(alpha_byte) {
+                            lv_opa_t px_opa = map_px[LV_IMG_PX_SIZE_ALPHA_BYTE - 1];
+                            mask_buf[px_i] = px_opa;
+                            if(px_opa == 0) {
+#if  LV_COLOR_DEPTH == 32
+                                map2[px_i].full = 0;
+#endif
+                                continue;
+                            }
+                        }
+                        else {
+                            mask_buf[px_i] = 0xFF;
+                        }
+
+#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);
+#elif LV_COLOR_DEPTH == 32
+                        c.full =  *((uint32_t *)map_px);
+                        c.ch.alpha = 0xFF;
+#endif
+                        if(chroma_key) {
+                            if(c.full == chroma_keyed_color.full) {
+                                mask_buf[px_i] = LV_OPA_TRANSP;
+#if  LV_COLOR_DEPTH == 32
+                                map2[px_i].full = 0;
+#endif
+                                continue;
+                            }
+                        }
+                    }
+
+                    if(draw_dsc->recolor_opa != 0) {
+                        c = lv_color_mix_premult(recolor_premult, c, recolor_opa_inv);
+                    }
+
+                    map2[px_i].full = c.full;
+                }
+
+                /*Apply the masks if any*/
+                if(other_mask_cnt) {
+                    lv_draw_mask_res_t mask_res_sub;
+                    mask_res_sub = lv_draw_mask_apply(mask_buf + px_i_start, draw_area.x1 + vdb->area.x1, y + draw_area.y1 + vdb->area.y1,
+                                                      lv_area_get_width(&draw_area));
+                    if(mask_res_sub == LV_DRAW_MASK_RES_TRANSP) {
+                        _lv_memset_00(mask_buf + px_i_start, lv_area_get_width(&draw_area));
+                        mask_res = LV_DRAW_MASK_RES_CHANGED;
+                    }
+                    else if(mask_res_sub == LV_DRAW_MASK_RES_CHANGED) {
+                        mask_res = LV_DRAW_MASK_RES_CHANGED;
+                    }
+                }
+
+                map_buf_tmp += map_w * px_size_byte;
+                if(px_i + lv_area_get_width(&draw_area) < mask_buf_size) {
+                    blend_area.y2 ++;
+                }
+                else {
+
+                    _lv_blend_map(clip_area, &blend_area, map2, mask_buf, mask_res, draw_dsc->opa, draw_dsc->blend_mode);
+
+                    blend_area.y1 = blend_area.y2 + 1;
+                    blend_area.y2 = blend_area.y1;
+
+                    px_i = 0;
+                    mask_res = (alpha_byte || chroma_key || draw_dsc->angle ||
+                                draw_dsc->zoom != LV_IMG_ZOOM_NONE) ? LV_DRAW_MASK_RES_CHANGED : LV_DRAW_MASK_RES_FULL_COVER;
+
+                    /*Prepare the `mask_buf`if there are other masks*/
+                    if(other_mask_cnt) {
+                        _lv_memset_ff(mask_buf, mask_buf_size);
+                    }
+                }
+            }
+
+            /*Flush the last part*/
+            if(blend_area.y1 != blend_area.y2) {
+                blend_area.y2--;
+                _lv_blend_map(clip_area, &blend_area, map2, mask_buf, mask_res, draw_dsc->opa, draw_dsc->blend_mode);
+            }
+
+            _lv_mem_buf_release(mask_buf);
+            _lv_mem_buf_release(map2);
+        }
+    }
+}
+
+static void show_error(const lv_area_t * coords, const lv_area_t * clip_area, const char * msg)
+{
+    lv_draw_rect_dsc_t rect_dsc;
+    lv_draw_rect_dsc_init(&rect_dsc);
+    rect_dsc.bg_color = LV_COLOR_WHITE;
+    lv_draw_rect(coords, clip_area, &rect_dsc);
+
+    lv_draw_label_dsc_t label_dsc;
+    lv_draw_label_dsc_init(&label_dsc);
+    lv_draw_label(coords, clip_area, &label_dsc, msg, NULL);
+}
+

src/lv_draw/lv_draw_img.h

@@ -13,8 +13,8 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_draw.h"
 #include "lv_img_decoder.h"
+#include "lv_img_buf.h"
 
 /*********************
  *      DEFINES
@@ -24,40 +24,42 @@ extern "C" {
  *      MACROS
  **********************/
 
-#define LV_IMG_BUF_SIZE_TRUE_COLOR(w, h) ((LV_COLOR_SIZE / 8) * w * h)
-#define LV_IMG_BUF_SIZE_TRUE_COLOR_CHROMA_KEYED(w, h) ((LV_COLOR_SIZE / 8) * w * h)
-#define LV_IMG_BUF_SIZE_TRUE_COLOR_ALPHA(w, h) (LV_IMG_PX_SIZE_ALPHA_BYTE * w * h)
-
-/*+ 1: to be sure no fractional row*/
-#define LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h) ((((w / 8) + 1) * h))
-#define LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h) ((((w / 4) + 1) * h))
-#define LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h) ((((w / 2) + 1) * h))
-#define LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h) ((w * h))
-
-/*4 * X: for palette*/
-#define LV_IMG_BUF_SIZE_INDEXED_1BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h) + 4 * 2)
-#define LV_IMG_BUF_SIZE_INDEXED_2BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h) + 4 * 4)
-#define LV_IMG_BUF_SIZE_INDEXED_4BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h) + 4 * 16)
-#define LV_IMG_BUF_SIZE_INDEXED_8BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h) + 4 * 256)
-
 /**********************
  *      TYPEDEFS
  **********************/
 
+typedef struct {
+    lv_opa_t opa;
+
+    uint16_t angle;
+    lv_point_t pivot;
+    uint16_t zoom;
+
+    lv_opa_t recolor_opa;
+    lv_color_t recolor;
+
+    lv_blend_mode_t blend_mode;
+
+    uint8_t antialias       : 1;
+} lv_draw_img_dsc_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
+void lv_draw_img_dsc_init(lv_draw_img_dsc_t * dsc);
 /**
  * Draw an image
  * @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
  */
-void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, const lv_style_t * style,
-                 lv_opa_t opa_scale);
+void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void * src, lv_draw_img_dsc_t * dsc);
 
 /**
  * Get the type of an image source
@@ -69,100 +71,26 @@ void lv_draw_img(const lv_area_t * coords, const lv_area_t * mask, const void *
  */
 lv_img_src_t lv_img_src_get_type(const void * src);
 
-/**
- * Get the color of an image's pixel
- * @param dsc an image descriptor
- * @param x x coordinate of the point to get
- * @param y x coordinate of the point to get
- * @param style style of the image. In case of `LV_IMG_CF_ALPHA_1/2/4/8` `style->image.color` shows
- * the color. Can be `NULL` but for `ALPHA` images black will be returned. In other cases it is not
- * used.
- * @return color of the point
- */
-lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, const lv_style_t * style);
-/**
- * Get the alpha value of an image's pixel
- * @param dsc pointer to an image descriptor
- * @param x x coordinate of the point to set
- * @param y x coordinate of the point to set
- * @return alpha value of the point
- */
-lv_opa_t lv_img_buf_get_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y);
-
-/**
- * Set the color of a pixel of an image. The alpha channel won't be affected.
- * @param dsc pointer to an image descriptor
- * @param x x coordinate of the point to set
- * @param y x coordinate of the point to set
- * @param c color of the point
- */
-void lv_img_buf_set_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_color_t c);
-
-/**
- * Set the alpha value of a pixel of an image. The color won't be affected
- * @param dsc pointer to an image descriptor
- * @param x x coordinate of the point to set
- * @param y x coordinate of the point to set
- * @param opa the desired opacity
- */
-void lv_img_buf_set_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_opa_t opa);
-
-/**
- * Set the palette color of an indexed image. Valid only for `LV_IMG_CF_INDEXED1/2/4/8`
- * @param dsc pointer to an image descriptor
- * @param id the palette color to set:
- *   - for `LV_IMG_CF_INDEXED1`: 0..1
- *   - for `LV_IMG_CF_INDEXED2`: 0..3
- *   - for `LV_IMG_CF_INDEXED4`: 0..15
- *   - for `LV_IMG_CF_INDEXED8`: 0..255
- * @param c the color to set
- */
-void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c);
-
 /**
  * Get the pixel size of a color format in bits
  * @param cf a color format (`LV_IMG_CF_...`)
  * @return the pixel size in bits
  */
-uint8_t lv_img_color_format_get_px_size(lv_img_cf_t cf);
+uint8_t lv_img_cf_get_px_size(lv_img_cf_t cf);
 
 /**
  * Check if a color format is chroma keyed or not
  * @param cf a color format (`LV_IMG_CF_...`)
  * @return true: chroma keyed; false: not chroma keyed
  */
-bool lv_img_color_format_is_chroma_keyed(lv_img_cf_t cf);
+bool lv_img_cf_is_chroma_keyed(lv_img_cf_t cf);
 
 /**
  * Check if a color format has alpha channel or not
  * @param cf a color format (`LV_IMG_CF_...`)
  * @return true: has alpha channel; false: doesn't have alpha channel
  */
-bool lv_img_color_format_has_alpha(lv_img_cf_t cf);
-
-/**
- * Allocate an image buffer in RAM
- * @param w width of image
- * @param h height of image
- * @param cf a color format (`LV_IMG_CF_...`)
- * @return an allocated image, or NULL on failure
- */
-lv_img_dsc_t *lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf);
-
-/**
- * Free an allocated image buffer
- * @param dsc image buffer to free
- */
-void lv_img_buf_free(lv_img_dsc_t *dsc);
-
-/**
- * Get the memory consumption of a raw bitmap, given color format and dimensions.
- * @param w width
- * @param h height
- * @param cf color format
- * @return size in bytes
- */
-uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf);
+bool lv_img_cf_has_alpha(lv_img_cf_t cf);
 
 
 #ifdef __cplusplus

src/lv_draw/lv_draw_label.c

@@ -8,7 +8,10 @@
  *********************/
 #include "lv_draw_label.h"
 #include "../lv_misc/lv_math.h"
+#include "../lv_hal/lv_hal_disp.h"
+#include "../lv_core/lv_refr.h"
 #include "../lv_misc/lv_bidi.h"
+#include "../lv_misc/lv_debug.h"
 
 /*********************
  *      DEFINES
@@ -29,12 +32,56 @@ typedef uint8_t cmd_state_t;
 /**********************
  *  STATIC PROTOTYPES
  **********************/
+LV_ATTRIBUTE_FAST_MEM static void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
+                                                 const lv_font_t * font_p,
+                                                 uint32_t letter, lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode);
+LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(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);
+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);
+
+
 static uint8_t hex_char_to_num(char hex);
 
 /**********************
  *  STATIC VARIABLES
  **********************/
 
+/**********************
+ *  GLOBAL VARIABLES
+ **********************/
+
+const uint8_t _lv_bpp1_opa_table[2]  = {0, 255};          /*Opacity mapping with bpp = 1 (Just for compatibility)*/
+const uint8_t _lv_bpp2_opa_table[4]  = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/
+
+const uint8_t _lv_bpp3_opa_table[8]  = {0, 36,  73, 109,   /*Opacity mapping with bpp = 3*/
+                                        146, 182,  219, 255
+                                       };
+
+const uint8_t _lv_bpp4_opa_table[16] = {0,  17, 34,  51,  /*Opacity mapping with bpp = 4*/
+                                        68, 85, 102, 119,
+                                        136, 153, 170, 187,
+                                        204, 221, 238, 255
+                                       };
+const uint8_t _lv_bpp8_opa_table[256] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+                                         16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+                                         32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+                                         48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+                                         64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
+                                         80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
+                                         96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+                                         112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+                                         128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+                                         144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+                                         160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+                                         176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+                                         192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+                                         208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+                                         224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+                                         240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
+                                        };
+
 /**********************
  *      MACROS
  **********************/
@@ -43,57 +90,69 @@ static uint8_t hex_char_to_num(char hex);
  *   GLOBAL FUNCTIONS
  **********************/
 
+LV_ATTRIBUTE_FAST_MEM void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc)
+{
+    _lv_memset_00(dsc, sizeof(lv_draw_label_dsc_t));
+    dsc->opa = LV_OPA_COVER;
+    dsc->color = LV_COLOR_BLACK;
+    dsc->font = LV_THEME_DEFAULT_FONT_NORMAL;
+    dsc->sel_start = LV_DRAW_LABEL_NO_TXT_SEL;
+    dsc->sel_end = LV_DRAW_LABEL_NO_TXT_SEL;
+    dsc->sel_color = LV_COLOR_BLUE;
+    dsc->bidi_dir = LV_BIDI_DIR_LTR;
+}
 
 /**
  * Write a text
  * @param coords coordinates of the label
  * @param mask the label will be drawn only in this area
- * @param style pointer to a style
- * @param opa_scale scale down all opacities by the factor
- * @param txt 0 terminated text to write
- * @param flag settings for the text from 'txt_flag_t' enum
- * @param offset text offset in x and y direction (NULL if unused)
- * @param sel_start start index of selected area (`LV_DRAW_LABEL_NO_TXT_SEL` if none)
+ * @param dsc pointer to draw descriptor
+ * @param txt `\0` terminated text to write
  * @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).
- * @param bidi_dir base direction of the text
  */
-void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale,
-                   const char * txt, lv_txt_flag_t flag, lv_point_t * offset, lv_draw_label_txt_sel_t * sel,
-                   lv_draw_label_hint_t * hint, lv_bidi_dir_t bidi_dir)
+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)
 {
-    const lv_font_t * font = style->text.font;
-    lv_coord_t w;
+
+    if(dsc->opa <= LV_OPA_MIN) return;
+    const lv_font_t * font = dsc->font;
+    int32_t w;
 
     /*No need to waste processor time if string is empty*/
-    if (txt[0] == '\0')  return;
+    if(txt[0] == '\0')  return;
 
-    if((flag & LV_TXT_FLAG_EXPAND) == 0) {
+    lv_area_t clipped_area;
+    bool clip_ok = _lv_area_intersect(&clipped_area, coords, mask);
+    if(!clip_ok) return;
+
+
+    if((dsc->flag & LV_TXT_FLAG_EXPAND) == 0) {
         /*Normally use the label's width as width*/
         w = lv_area_get_width(coords);
-    } else {
+    }
+    else {
         /*If EXAPND is enabled then not limit the text's width to the object's width*/
         lv_point_t p;
-        lv_txt_get_size(&p, txt, style->text.font, style->text.letter_space, style->text.line_space, LV_COORD_MAX,
-                flag);
+        _lv_txt_get_size(&p, txt, dsc->font, dsc->letter_space, dsc->line_space, LV_COORD_MAX,
+                         dsc->flag);
         w = p.x;
     }
 
-    lv_coord_t line_height = lv_font_get_line_height(font) + style->text.line_space;
+    int32_t line_height_font = lv_font_get_line_height(font);
+    int32_t line_height = line_height_font + dsc->line_space;
 
     /*Init variables for the first line*/
-    lv_coord_t line_width = 0;
+    int32_t line_width = 0;
     lv_point_t pos;
     pos.x = coords->x1;
     pos.y = coords->y1;
 
-    lv_coord_t x_ofs = 0;
-    lv_coord_t y_ofs = 0;
-    if(offset != NULL) {
-        x_ofs = offset->x;
-        y_ofs = offset->y;
-        pos.y += y_ofs;
-    }
+    int32_t x_ofs = 0;
+    int32_t y_ofs = 0;
+    x_ofs = dsc->ofs_x;
+    y_ofs = dsc->ofs_y;
+    pos.y += y_ofs;
 
     uint32_t line_start     = 0;
     int32_t last_line_start = -1;
@@ -113,14 +172,13 @@ void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_st
         pos.y += hint->y;
     }
 
-
-    uint32_t line_end = line_start + lv_txt_get_next_line(&txt[line_start], font, style->text.letter_space, w, flag);
+    uint32_t line_end = line_start + _lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
 
     /*Go the first visible line*/
-    while(pos.y + line_height < mask->y1) {
+    while(pos.y + line_height_font < mask->y1) {
         /*Go to next line*/
         line_start = line_end;
-        line_end += lv_txt_get_next_line(&txt[line_start], font, style->text.letter_space, w, flag);
+        line_end += _lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
         pos.y += line_height;
 
         /*Save at the threshold coordinate*/
@@ -134,85 +192,90 @@ void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_st
     }
 
     /*Align to middle*/
-    if(flag & LV_TXT_FLAG_CENTER) {
-        line_width = lv_txt_get_width(&txt[line_start], line_end - line_start, font, style->text.letter_space, flag);
+    if(dsc->flag & LV_TXT_FLAG_CENTER) {
+        line_width = _lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
 
         pos.x += (lv_area_get_width(coords) - line_width) / 2;
 
     }
     /*Align to the right*/
-    else if(flag & LV_TXT_FLAG_RIGHT) {
-        line_width = lv_txt_get_width(&txt[line_start], line_end - line_start, font, style->text.letter_space, flag);
+    else if(dsc->flag & LV_TXT_FLAG_RIGHT) {
+        line_width = _lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
         pos.x += lv_area_get_width(coords) - line_width;
     }
 
-    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->text.opa : (uint16_t)((uint16_t)style->text.opa * opa_scale) >> 8;
+    lv_opa_t opa = dsc->opa;
 
-    uint16_t sel_start = 0xFFFF;
-    uint16_t sel_end = 0xFFFF;
-    if(sel) {
-        sel_start = sel->start;
-        sel_end = sel->end;
-        if(sel_start > sel_end) {
-            uint16_t tmp = sel_start;
-            sel_start = sel_end;
-            sel_end = tmp;
-        }
+    uint32_t sel_start = dsc->sel_start;
+    uint32_t sel_end = dsc->sel_end;
+    if(sel_start > sel_end) {
+        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.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;
-    lv_coord_t letter_w;
-    lv_style_t sel_style;
-    lv_style_copy(&sel_style, &lv_style_plain_color);
-    sel_style.body.main_color = sel_style.body.grad_color = style->text.sel_color;
+    int32_t letter_w;
 
+
+    lv_draw_rect_dsc_t draw_dsc_sel;
+    lv_draw_rect_dsc_init(&draw_dsc_sel);
+    draw_dsc_sel.bg_color = dsc->sel_color;
+
+    int32_t pos_x_start = pos.x;
     /*Write out all lines*/
     while(txt[line_start] != '\0') {
-        if(offset != NULL) {
-            pos.x += x_ofs;
-        }
+        pos.x += x_ofs;
+
         /*Write all letter of a line*/
         cmd_state = CMD_STATE_WAIT;
         i         = 0;
-        uint32_t letter;
-        uint32_t letter_next;
 #if LV_USE_BIDI
-        char *bidi_txt = lv_draw_get_buf(line_end - line_start + 1);
-        lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, bidi_dir, NULL, 0);
+        char * bidi_txt = _lv_mem_buf_get(line_end - line_start + 1);
+        _lv_bidi_process_paragraph(txt + line_start, bidi_txt, line_end - line_start, dsc->bidi_dir, NULL, 0);
 #else
-        (void)bidi_dir;
-        const char *bidi_txt = txt + line_start;
+        const char * bidi_txt = txt + line_start;
 #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);
-                logical_char_pos += lv_bidi_get_logical_pos(bidi_txt, NULL, line_end - line_start, bidi_dir, t, NULL);
+                logical_char_pos = _lv_txt_encoded_get_char_id(txt, line_start);
+                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);
+                logical_char_pos = _lv_txt_encoded_get_char_id(txt, line_start + i);
 #endif
             }
 
-            letter      = lv_txt_encoded_next(bidi_txt, &i);
-            letter_next = lv_txt_encoded_next(&bidi_txt[i], NULL);
-
+            uint32_t letter      = _lv_txt_encoded_next(bidi_txt, &i);
+            uint32_t letter_next = _lv_txt_encoded_next(&bidi_txt[i], NULL);
 
             /*Handle the re-color command*/
-            if((flag & LV_TXT_FLAG_RECOLOR) != 0) {
+            if((dsc->flag & LV_TXT_FLAG_RECOLOR) != 0) {
                 if(letter == (uint32_t)LV_TXT_COLOR_CMD[0]) {
                     if(cmd_state == CMD_STATE_WAIT) { /*Start char*/
                         par_start = i;
                         cmd_state = CMD_STATE_PAR;
                         continue;
-                    } else if(cmd_state == CMD_STATE_PAR) { /*Other start char in parameter escaped cmd. char */
+                    }
+                    else if(cmd_state == CMD_STATE_PAR) {   /*Other start char in parameter escaped cmd. char */
                         cmd_state = CMD_STATE_WAIT;
-                    } else if(cmd_state == CMD_STATE_IN) { /*Command end */
+                    }
+                    else if(cmd_state == CMD_STATE_IN) {   /*Command end */
                         cmd_state = CMD_STATE_WAIT;
                         continue;
                     }
@@ -224,15 +287,16 @@ void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_st
                         /*Get the parameter*/
                         if(i - par_start == LABEL_RECOLOR_PAR_LENGTH + 1) {
                             char buf[LABEL_RECOLOR_PAR_LENGTH + 1];
-                            memcpy(buf, &bidi_txt[par_start], LABEL_RECOLOR_PAR_LENGTH);
+                            _lv_memcpy_small(buf, &bidi_txt[par_start], LABEL_RECOLOR_PAR_LENGTH);
                             buf[LABEL_RECOLOR_PAR_LENGTH] = '\0';
                             int r, g, b;
                             r       = (hex_char_to_num(buf[0]) << 4) + hex_char_to_num(buf[1]);
                             g       = (hex_char_to_num(buf[2]) << 4) + hex_char_to_num(buf[3]);
                             b       = (hex_char_to_num(buf[4]) << 4) + hex_char_to_num(buf[5]);
                             recolor = lv_color_make(r, g, b);
-                        } else {
-                            recolor.full = style->text.color.full;
+                        }
+                        else {
+                            recolor.full = dsc->color.full;
                         }
                         cmd_state = CMD_STATE_IN; /*After the parameter the text is in the command*/
                     }
@@ -240,7 +304,7 @@ void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_st
                 }
             }
 
-            lv_color_t color = style->text.color;
+            lv_color_t color = dsc->color;
 
             if(cmd_state == CMD_STATE_IN) color = recolor;
 
@@ -251,35 +315,60 @@ void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_st
                     lv_area_t sel_coords;
                     sel_coords.x1 = pos.x;
                     sel_coords.y1 = pos.y;
-                    sel_coords.x2 = pos.x + letter_w + style->text.letter_space - 1;
+                    sel_coords.x2 = pos.x + letter_w + dsc->letter_space - 1;
                     sel_coords.y2 = pos.y + line_height - 1;
-                    lv_draw_rect(&sel_coords, mask, &sel_style, opa);
+                    lv_draw_rect(&sel_coords, mask, &draw_dsc_sel);
                 }
             }
 
-            lv_draw_letter(&pos, mask, font, letter, color, opa);
+            lv_draw_letter(&pos, mask, font, letter, color, opa, dsc->blend_mode);
 
             if(letter_w > 0) {
-                pos.x += letter_w + style->text.letter_space;
+                pos.x += letter_w + dsc->letter_space;
             }
         }
+
+        if(dsc->decor & LV_TEXT_DECOR_STRIKETHROUGH) {
+            lv_point_t p1;
+            lv_point_t p2;
+            p1.x = pos_x_start;
+            p1.y = pos.y + (dsc->font->line_height / 2)  + line_dsc.width / 2;
+            p2.x = pos.x;
+            p2.y = p1.y;
+            lv_draw_line(&p1, &p2, mask, &line_dsc);
+        }
+
+        if(dsc->decor  & LV_TEXT_DECOR_UNDERLINE) {
+            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;
+            p2.x = pos.x;
+            p2.y = p1.y;
+            lv_draw_line(&p1, &p2, mask, &line_dsc);
+        }
+
+#if LV_USE_BIDI
+        _lv_mem_buf_release(bidi_txt);
+        bidi_txt = NULL;
+#endif
         /*Go to next line*/
         line_start = line_end;
-        line_end += lv_txt_get_next_line(&txt[line_start], font, style->text.letter_space, w, flag);
+        line_end += _lv_txt_get_next_line(&txt[line_start], font, dsc->letter_space, w, dsc->flag);
 
         pos.x = coords->x1;
         /*Align to middle*/
-        if(flag & LV_TXT_FLAG_CENTER) {
+        if(dsc->flag & LV_TXT_FLAG_CENTER) {
             line_width =
-                    lv_txt_get_width(&txt[line_start], line_end - line_start, font, style->text.letter_space, flag);
+                _lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
 
             pos.x += (lv_area_get_width(coords) - line_width) / 2;
 
         }
         /*Align to the right*/
-        else if(flag & LV_TXT_FLAG_RIGHT) {
+        else if(dsc->flag & LV_TXT_FLAG_RIGHT) {
             line_width =
-                    lv_txt_get_width(&txt[line_start], line_end - line_start, font, style->text.letter_space, flag);
+                _lv_txt_get_width(&txt[line_start], line_end - line_start, font, dsc->letter_space, dsc->flag);
             pos.x += lv_area_get_width(coords) - line_width;
         }
 
@@ -288,12 +377,438 @@ void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_st
 
         if(pos.y > mask->y2) return;
     }
+
+    LV_ASSERT_MEM_INTEGRITY();
 }
 
 /**********************
  *   STATIC FUNCTIONS
  **********************/
 
+
+/**
+ * Draw a letter in the Virtual Display Buffer
+ * @param pos_p left-top coordinate of the latter
+ * @param mask_p the letter will be drawn only on this area  (truncated to VDB area)
+ * @param font_p pointer to font
+ * @param letter a letter to draw
+ * @param color color of letter
+ * @param opa opacity of letter (0..255)
+ */
+LV_ATTRIBUTE_FAST_MEM static void lv_draw_letter(const lv_point_t * pos_p, const lv_area_t * clip_area,
+                                                 const lv_font_t * font_p,
+                                                 uint32_t letter,
+                                                 lv_color_t color, lv_opa_t opa, lv_blend_mode_t blend_mode)
+{
+    if(opa < LV_OPA_MIN) return;
+    if(opa > LV_OPA_MAX) opa = LV_OPA_COVER;
+
+    if(font_p == NULL) {
+        LV_LOG_WARN("lv_draw_letter: font is NULL");
+        return;
+    }
+
+    lv_font_glyph_dsc_t g;
+    bool g_ret = lv_font_get_glyph_dsc(font_p, &g, letter, '\0');
+    if(g_ret == false)  {
+        /* Add waring if the dsc is not found
+         * but do not print warning for non printable ASCII chars (e.g. '\n')*/
+        if(letter >= 0x20) {
+            LV_LOG_WARN("lv_draw_letter: glyph dsc. not found");
+        }
+        return;
+    }
+
+    /* Don't draw anything if the character is empty. E.g. space */
+    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;
+
+    /*If the letter is completely out of mask don't draw it */
+    if(pos_x + g.box_w < clip_area->x1 ||
+       pos_x > clip_area->x2 ||
+       pos_y + g.box_h < clip_area->y1 ||
+       pos_y > clip_area->y2)  {
+        return;
+    }
+
+
+    const uint8_t * map_p = lv_font_get_glyph_bitmap(font_p, letter);
+    if(map_p == NULL) {
+        LV_LOG_WARN("lv_draw_letter: character's bitmap not found");
+        return;
+    }
+
+    if(font_p->subpx) {
+        draw_letter_subpx(pos_x, pos_y, &g, clip_area, map_p, color, opa, blend_mode);
+    }
+    else {
+        draw_letter_normal(pos_x, pos_y, &g, clip_area, map_p, color, opa, blend_mode);
+    }
+}
+
+
+LV_ATTRIBUTE_FAST_MEM static void draw_letter_normal(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)
+{
+    const uint8_t * bpp_opa_table_p;
+    uint32_t bitmask_init;
+    uint32_t bitmask;
+    uint32_t bpp = g->bpp;
+    uint32_t shades;
+    if(bpp == 3) bpp = 4;
+
+    switch(bpp) {
+        case 1:
+            bpp_opa_table_p = _lv_bpp1_opa_table;
+            bitmask_init  = 0x80;
+            shades = 2;
+            break;
+        case 2:
+            bpp_opa_table_p = _lv_bpp2_opa_table;
+            bitmask_init  = 0xC0;
+            shades = 4;
+            break;
+        case 4:
+            bpp_opa_table_p = _lv_bpp4_opa_table;
+            bitmask_init  = 0xF0;
+            shades = 16;
+            break;
+        case 8:
+            bpp_opa_table_p = _lv_bpp8_opa_table;
+            bitmask_init  = 0xFF;
+            shades = 256;
+            break;       /*No opa table, pixel value will be used directly*/
+        default:
+            LV_LOG_WARN("lv_draw_letter: invalid bpp");
+            return; /*Invalid bpp. Can't render the letter*/
+    }
+
+    static lv_opa_t opa_table[256];
+    static lv_opa_t prev_opa = LV_OPA_TRANSP;
+    static uint32_t prev_bpp = 0;
+    if(opa < LV_OPA_MAX) {
+        if(prev_opa != opa || prev_bpp != bpp) {
+            uint32_t i;
+            for(i = 0; i < shades; i++) {
+                opa_table[i] = bpp_opa_table_p[i] == LV_OPA_COVER ? opa : ((bpp_opa_table_p[i] * opa) >> 8);
+            }
+        }
+        bpp_opa_table_p = opa_table;
+        prev_opa = opa;
+        prev_bpp = bpp;
+    }
+
+    int32_t col, row;
+    int32_t box_w = g->box_w;
+    int32_t box_h = g->box_h;
+    int32_t width_bit = box_w * bpp; /*Letter width in bits*/
+
+    /* Calculate the col/row start/end on the map*/
+    int32_t col_start = pos_x >= clip_area->x1 ? 0 : clip_area->x1 - pos_x;
+    int32_t col_end   = pos_x + box_w <= clip_area->x2 ? box_w : clip_area->x2 - pos_x + 1;
+    int32_t row_start = pos_y >= clip_area->y1 ? 0 : clip_area->y1 - pos_y;
+    int32_t row_end   = pos_y + box_h <= clip_area->y2 ? box_h : clip_area->y2 - pos_y + 1;
+
+    /*Move on the map too*/
+    uint32_t bit_ofs = (row_start * width_bit) + (col_start * bpp);
+    map_p += bit_ofs >> 3;
+
+    uint8_t letter_px;
+    uint32_t col_bit;
+    col_bit = bit_ofs & 0x7; /* "& 0x7" equals to "% 8" just faster */
+
+    uint32_t mask_buf_size = box_w * box_h > LV_HOR_RES_MAX ? LV_HOR_RES_MAX : box_w * box_h;
+    lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
+    int32_t mask_p = 0;
+
+    lv_area_t fill_area;
+    fill_area.x1 = col_start + pos_x;
+    fill_area.x2 = col_end  + pos_x - 1;
+    fill_area.y1 = row_start + pos_y;
+    fill_area.y2 = fill_area.y1;
+
+    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
+
+    uint32_t col_bit_max = 8 - bpp;
+    uint32_t col_bit_row_ofs = (box_w + col_start - col_end) * bpp;
+
+    for(row = row_start ; row < row_end; row++) {
+        int32_t mask_p_start = mask_p;
+
+        bitmask = bitmask_init >> col_bit;
+        for(col = col_start; col < col_end; col++) {
+            /*Load the pixel's opacity into the mask*/
+            letter_px = (*map_p & bitmask) >> (col_bit_max - col_bit);
+            if(letter_px) {
+                mask_buf[mask_p] = bpp_opa_table_p[letter_px];
+            }
+            else {
+                mask_buf[mask_p] = 0;
+            }
+
+            /*Go to the next column*/
+            if(col_bit < col_bit_max) {
+                col_bit += bpp;
+                bitmask = bitmask >> bpp;
+            }
+            else {
+                col_bit = 0;
+                bitmask = bitmask_init;
+                map_p++;
+            }
+
+            /*Next mask byte*/
+            mask_p++;
+        }
+
+
+        /*Apply masks if any*/
+        if(other_mask_cnt) {
+            lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf + mask_p_start, fill_area.x1, fill_area.y2,
+                                                             lv_area_get_width(&fill_area));
+            if(mask_res == LV_DRAW_MASK_RES_TRANSP) {
+                _lv_memset_00(mask_buf + mask_p_start, lv_area_get_width(&fill_area));
+            }
+        }
+
+        if((uint32_t) mask_p + (col_end - col_start) < mask_buf_size) {
+            fill_area.y2 ++;
+        }
+        else {
+            _lv_blend_fill(clip_area, &fill_area,
+                           color, mask_buf, LV_DRAW_MASK_RES_CHANGED, LV_OPA_COVER,
+                           blend_mode);
+
+            fill_area.y1 = fill_area.y2 + 1;
+            fill_area.y2 = fill_area.y1;
+            mask_p = 0;
+        }
+
+        col_bit += col_bit_row_ofs;
+        map_p += (col_bit >> 3);
+        col_bit = col_bit & 0x7;
+    }
+
+    /*Flush the last part*/
+    if(fill_area.y1 != fill_area.y2) {
+        fill_area.y2--;
+        _lv_blend_fill(clip_area, &fill_area,
+                       color, mask_buf, LV_DRAW_MASK_RES_CHANGED, LV_OPA_COVER,
+                       blend_mode);
+        mask_p = 0;
+    }
+
+    _lv_mem_buf_release(mask_buf);
+}
+
+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)
+{
+    const uint8_t * bpp_opa_table;
+    uint32_t bitmask_init;
+    uint32_t bitmask;
+    uint32_t bpp = g->bpp;
+    if(bpp == 3) bpp = 4;
+
+    switch(bpp) {
+        case 1:
+            bpp_opa_table = _lv_bpp1_opa_table;
+            bitmask_init  = 0x80;
+            break;
+        case 2:
+            bpp_opa_table = _lv_bpp2_opa_table;
+            bitmask_init  = 0xC0;
+            break;
+        case 4:
+            bpp_opa_table = _lv_bpp4_opa_table;
+            bitmask_init  = 0xF0;
+            break;
+        case 8:
+            bpp_opa_table = _lv_bpp8_opa_table;
+            bitmask_init  = 0xFF;
+            break;       /*No opa table, pixel value will be used directly*/
+        default:
+            LV_LOG_WARN("lv_draw_letter: invalid bpp not found");
+            return; /*Invalid bpp. Can't render the letter*/
+    }
+
+    int32_t col, row;
+
+    int32_t box_w = g->box_w;
+    int32_t box_h = g->box_h;
+    int32_t width_bit = box_w * bpp; /*Letter width in bits*/
+
+
+    /* Calculate the col/row start/end on the map*/
+    int32_t col_start = pos_x >= clip_area->x1 ? 0 : (clip_area->x1 - pos_x) * 3;
+    int32_t col_end   = pos_x + box_w / 3 <= clip_area->x2 ? box_w : (clip_area->x2 - pos_x + 1) * 3;
+    int32_t row_start = pos_y >= clip_area->y1 ? 0 : clip_area->y1 - pos_y;
+    int32_t row_end   = pos_y + box_h <= clip_area->y2 ? box_h : clip_area->y2 - pos_y + 1;
+
+    /*Move on the map too*/
+    int32_t bit_ofs = (row_start * width_bit) + (col_start * bpp);
+    map_p += bit_ofs >> 3;
+
+    uint8_t letter_px;
+    lv_opa_t px_opa;
+    int32_t col_bit;
+    col_bit = bit_ofs & 0x7; /* "& 0x7" equals to "% 8" just faster */
+
+    int32_t mask_buf_size = box_w * box_h > LV_HOR_RES_MAX ? LV_HOR_RES_MAX : g->box_w * g->box_h;
+    lv_opa_t * mask_buf = _lv_mem_buf_get(mask_buf_size);
+    int32_t mask_p = 0;
+
+    lv_color_t * color_buf = _lv_mem_buf_get(mask_buf_size * sizeof(lv_color_t));
+
+    lv_disp_t * disp    = _lv_refr_get_disp_refreshing();
+    lv_disp_buf_t * vdb = lv_disp_get_buf(disp);
+
+    int32_t vdb_width     = lv_area_get_width(&vdb->area);
+    lv_color_t * vdb_buf_tmp = vdb->buf_act;
+
+    /*Set a pointer on VDB to the first pixel of the letter*/
+    vdb_buf_tmp += ((pos_y - vdb->area.y1) * vdb_width) + pos_x - vdb->area.x1;
+
+    /*If the letter is partially out of mask the move there on VDB*/
+    vdb_buf_tmp += (row_start * vdb_width) + col_start / 3;
+
+    lv_area_t map_area;
+    map_area.x1 = col_start / 3 + pos_x;
+    map_area.x2 = col_end / 3  + pos_x - 1;
+    map_area.y1 = row_start + pos_y;
+    map_area.y2 = map_area.y1;
+
+    uint8_t other_mask_cnt = lv_draw_mask_get_cnt();
+
+    uint8_t font_rgb[3];
+
+#if LV_COLOR_16_SWAP == 0
+    uint8_t txt_rgb[3] = {color.ch.red, color.ch.green, color.ch.blue};
+#else
+    uint8_t txt_rgb[3] = {color.ch.red, (color.ch.green_h << 3) + color.ch.green_l, color.ch.blue};
+#endif
+
+    for(row = row_start ; row < row_end; row++) {
+        uint32_t subpx_cnt = 0;
+        bitmask = bitmask_init >> col_bit;
+        int32_t mask_p_start = mask_p;
+
+        for(col = col_start; col < col_end; col++) {
+            /*Load the pixel's opacity into the mask*/
+            letter_px = (*map_p & bitmask) >> (8 - col_bit - bpp);
+            if(letter_px != 0) {
+                if(opa == LV_OPA_COVER) {
+                    px_opa = bpp == 8 ? letter_px : bpp_opa_table[letter_px];
+                }
+                else {
+                    px_opa = bpp == 8 ? (uint32_t)((uint32_t)letter_px * opa) >> 8
+                             : (uint32_t)((uint32_t)bpp_opa_table[letter_px] * opa) >> 8;
+                }
+            }
+            else {
+                px_opa = 0;
+            }
+
+            font_rgb[subpx_cnt] = px_opa;
+
+            subpx_cnt ++;
+            if(subpx_cnt == 3) {
+                subpx_cnt = 0;
+
+                lv_color_t res_color;
+#if LV_COLOR_16_SWAP == 0
+                uint8_t bg_rgb[3] = {vdb_buf_tmp->ch.red, vdb_buf_tmp->ch.green, vdb_buf_tmp->ch.blue};
+#else
+                uint8_t bg_rgb[3] = {vdb_buf_tmp->ch.red,
+                                     (vdb_buf_tmp->ch.green_h << 3) + vdb_buf_tmp->ch.green_l,
+                                     vdb_buf_tmp->ch.blue
+                                    };
+#endif
+
+#if LV_FONT_SUBPX_BGR
+                res_color.ch.blue = (uint32_t)((uint32_t)txt_rgb[0] * font_rgb[0] + (bg_rgb[0] * (255 - font_rgb[0]))) >> 8;
+                res_color.ch.red = (uint32_t)((uint32_t)txt_rgb[2] * font_rgb[2] + (bg_rgb[2] * (255 - font_rgb[2]))) >> 8;
+#else
+                res_color.ch.red = (uint32_t)((uint16_t)txt_rgb[0] * font_rgb[0] + (bg_rgb[0] * (255 - font_rgb[0]))) >> 8;
+                res_color.ch.blue = (uint32_t)((uint16_t)txt_rgb[2] * font_rgb[2] + (bg_rgb[2] * (255 - font_rgb[2]))) >> 8;
+#endif
+
+#if LV_COLOR_16_SWAP == 0
+                res_color.ch.green = (uint32_t)((uint32_t)txt_rgb[1] * font_rgb[1] + (bg_rgb[1] * (255 - font_rgb[1]))) >> 8;
+#else
+                uint8_t green = (uint32_t)((uint32_t)txt_rgb[1] * font_rgb[1] + (bg_rgb[1] * (255 - font_rgb[1]))) >> 8;
+                res_color.ch.green_h = green >> 3;
+                res_color.ch.green_l = green & 0x7;
+#endif
+
+#if LV_COLOR_DEPTH == 32
+                res_color.ch.alpha =  0xff;
+#endif
+
+                if(font_rgb[0] == 0 && font_rgb[1] == 0 && font_rgb[2] == 0) mask_buf[mask_p] = LV_OPA_TRANSP;
+                else mask_buf[mask_p] = LV_OPA_COVER;
+                color_buf[mask_p] = res_color;
+
+                /*Next mask byte*/
+                mask_p++;
+                vdb_buf_tmp++;
+            }
+
+            /*Go to the next column*/
+            if(col_bit < (int32_t)(8 - bpp)) {
+                col_bit += bpp;
+                bitmask = bitmask >> bpp;
+            }
+            else {
+                col_bit = 0;
+                bitmask = bitmask_init;
+                map_p++;
+            }
+        }
+
+        /*Apply masks if any*/
+        if(other_mask_cnt) {
+            lv_draw_mask_res_t mask_res = lv_draw_mask_apply(mask_buf + mask_p_start, map_area.x1, map_area.y2,
+                                                             lv_area_get_width(&map_area));
+            if(mask_res == LV_DRAW_MASK_RES_TRANSP) {
+                _lv_memset_00(mask_buf + mask_p_start, lv_area_get_width(&map_area));
+            }
+        }
+
+        if((int32_t) mask_p + (col_end - col_start) < mask_buf_size) {
+            map_area.y2 ++;
+        }
+        else {
+            _lv_blend_map(clip_area, &map_area, color_buf, mask_buf, LV_DRAW_MASK_RES_CHANGED, opa, blend_mode);
+
+            map_area.y1 = map_area.y2 + 1;
+            map_area.y2 = map_area.y1;
+            mask_p = 0;
+        }
+
+        col_bit += ((box_w - col_end) + col_start) * bpp;
+
+        map_p += (col_bit >> 3);
+        col_bit = col_bit & 0x7;
+
+        /*Next row in VDB*/
+        vdb_buf_tmp += vdb_width - (col_end - col_start) / 3;
+    }
+
+    /*Flush the last part*/
+    if(map_area.y1 != map_area.y2) {
+        map_area.y2--;
+        _lv_blend_map(clip_area, &map_area, color_buf, mask_buf, LV_DRAW_MASK_RES_CHANGED, opa, blend_mode);
+    }
+
+    _lv_mem_buf_release(mask_buf);
+    _lv_mem_buf_release(color_buf);
+}
+
+
 /**
  * Convert a hexadecimal characters to a number (0..15)
  * @param hex Pointer to a hexadecimal character (0..9, A..F)
@@ -305,17 +820,32 @@ static uint8_t hex_char_to_num(char hex)
 
     if(hex >= '0' && hex <= '9') {
         result = hex - '0';
-    } else {
+    }
+    else {
         if(hex >= 'a') hex -= 'a' - 'A'; /*Convert to upper case*/
 
         switch(hex) {
-        case 'A': result = 10; break;
-        case 'B': result = 11; break;
-        case 'C': result = 12; break;
-        case 'D': result = 13; break;
-        case 'E': result = 14; break;
-        case 'F': result = 15; break;
-        default: result = 0; break;
+            case 'A':
+                result = 10;
+                break;
+            case 'B':
+                result = 11;
+                break;
+            case 'C':
+                result = 12;
+                break;
+            case 'D':
+                result = 13;
+                break;
+            case 'E':
+                result = 14;
+                break;
+            case 'F':
+                result = 15;
+                break;
+            default:
+                result = 0;
+                break;
         }
     }
 

src/lv_draw/lv_draw_label.h

@@ -13,8 +13,9 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_draw.h"
 #include "../lv_misc/lv_bidi.h"
+#include "../lv_misc/lv_txt.h"
+#include "../lv_core/lv_style.h"
 
 /*********************
  *      DEFINES
@@ -25,12 +26,22 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
-typedef struct
-{
-    uint16_t start;
-    uint16_t end;
-}lv_draw_label_txt_sel_t;
-
+typedef struct {
+    lv_color_t color;
+    lv_color_t sel_color;
+    const lv_font_t * font;
+    lv_opa_t opa;
+    lv_style_int_t line_space;
+    lv_style_int_t letter_space;
+    uint32_t sel_start;
+    uint32_t sel_end;
+    lv_coord_t ofs_x;
+    lv_coord_t ofs_y;
+    lv_bidi_dir_t bidi_dir;
+    lv_txt_flag_t flag;
+    lv_text_decor_t decor;
+    lv_blend_mode_t blend_mode;
+} lv_draw_label_dsc_t;
 
 /** Store some info to speed up drawing of very large texts
  * It takes a lot of time to get the first visible character because
@@ -47,29 +58,37 @@ typedef struct {
     /** The 'y1' coordinate of the label when the hint was saved.
      * Used to invalidate the hint if the label has moved too much. */
     int32_t coord_y;
-}lv_draw_label_hint_t;
+} lv_draw_label_hint_t;
 
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
+//! @cond Doxygen_Suppress
+
+LV_ATTRIBUTE_FAST_MEM void lv_draw_label_dsc_init(lv_draw_label_dsc_t * dsc);
+
 /**
  * Write a text
  * @param coords coordinates of the label
  * @param mask the label will be drawn only in this area
- * @param style pointer to a style
- * @param opa_scale scale down all opacities by the factor
- * @param txt 0 terminated text to write
- * @param flag settings for the text from 'txt_flag_t' enum
- * @param offset text offset in x and y direction (NULL if unused)
- * @param sel_start start index of selected area (`LV_DRAW_LABEL_NO_TXT_SEL` if none)
+ * @param dsc pointer to draw descriptor
+ * @param txt `\0` terminated text to write
  * @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).
- * @param bidi_dir base direction of the text
  */
-void lv_draw_label(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale,
-                   const char * txt, lv_txt_flag_t flag, lv_point_t * offset, lv_draw_label_txt_sel_t * sel,
-                   lv_draw_label_hint_t * hint, lv_bidi_dir_t bidi_dir);
+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);
+
+//! @endcond
+/***********************
+ * GLOBAL VARIABLES
+ ***********************/
+extern const uint8_t _lv_bpp2_opa_table[];
+extern const uint8_t _lv_bpp3_opa_table[];
+extern const uint8_t _lv_bpp1_opa_table[];
+extern const uint8_t _lv_bpp4_opa_table[];
+extern const uint8_t _lv_bpp8_opa_table[];
 
 /**********************
  *      MACROS

src/lv_draw/lv_draw_line.h

@@ -13,6 +13,7 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
+#include "../lv_core/lv_style.h"
 
 /*********************
  *      DEFINES
@@ -21,11 +22,23 @@ extern "C" {
 /**********************
  *      TYPEDEFS
  **********************/
+typedef struct {
+    lv_color_t color;
+    lv_style_int_t width;
+    lv_style_int_t dash_width;
+    lv_style_int_t dash_gap;
+    lv_opa_t opa;
+    lv_blend_mode_t blend_mode  : 2;
+    uint8_t round_start : 1;
+    uint8_t round_end   : 1;
+    uint8_t raw_end     : 1;    /*Do not bother with perpendicular line ending is it's not visible for any reason*/
+} lv_draw_line_dsc_t;
 
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
+//! @cond Doxygen_Suppress
 /**
  * Draw a line
  * @param point1 first point of the line
@@ -34,8 +47,13 @@ extern "C" {
  * @param style pointer to a line's style
  * @param opa_scale scale down all opacities by the factor
  */
-void lv_draw_line(const lv_point_t * point1, const lv_point_t * point2, const lv_area_t * mask,
-                  const lv_style_t * style, lv_opa_t opa_scale);
+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_dsc_init(lv_draw_line_dsc_t * dsc);
+
+
+//! @endcond
 
 /**********************
  *      MACROS

src/lv_draw/lv_draw_mask.h

@@ -0,0 +1,307 @@
+/**
+ * @file lv_mask.h
+ *
+ */
+
+#ifndef LV_MASK_H
+#define LV_MASK_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdbool.h>
+#include "../lv_misc/lv_area.h"
+#include "../lv_misc/lv_color.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+#define LV_MASK_ID_INV  (-1)
+#define _LV_MASK_MAX_NUM     16
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+enum {
+    LV_DRAW_MASK_RES_TRANSP,
+    LV_DRAW_MASK_RES_FULL_COVER,
+    LV_DRAW_MASK_RES_CHANGED,
+    LV_DRAW_MASK_RES_UNKNOWN
+};
+
+typedef uint8_t lv_draw_mask_res_t;
+
+
+enum {
+    LV_DRAW_MASK_TYPE_LINE,
+    LV_DRAW_MASK_TYPE_ANGLE,
+    LV_DRAW_MASK_TYPE_RADIUS,
+    LV_DRAW_MASK_TYPE_FADE,
+    LV_DRAW_MASK_TYPE_MAP,
+};
+
+typedef uint8_t lv_draw_mask_type_t;
+
+enum {
+    LV_DRAW_MASK_LINE_SIDE_LEFT = 0,
+    LV_DRAW_MASK_LINE_SIDE_RIGHT,
+    LV_DRAW_MASK_LINE_SIDE_TOP,
+    LV_DRAW_MASK_LINE_SIDE_BOTTOM,
+};
+
+/**
+ * A common callback type for every mask type.
+ * Used internally by the library.
+ */
+typedef lv_draw_mask_res_t (*lv_draw_mask_xcb_t)(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
+                                                 lv_coord_t len,
+                                                 void * p);
+
+typedef uint8_t lv_draw_mask_line_side_t;
+
+typedef struct {
+    lv_draw_mask_xcb_t cb;
+    lv_draw_mask_type_t type;
+} lv_draw_mask_common_dsc_t;
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        /*First point */
+        lv_point_t p1;
+
+        /*Second point*/
+        lv_point_t p2;
+
+        /*Which side to keep?*/
+        lv_draw_mask_line_side_t side : 2;
+    } cfg;
+
+    /*A point of the line*/
+    lv_point_t origo;
+
+    /* X / (1024*Y) steepness (X is 0..1023 range). What is the change of X in 1024 Y?*/
+    int32_t xy_steep;
+
+    /* Y / (1024*X) steepness (Y is 0..1023 range). What is the change of Y in 1024 X?*/
+    int32_t yx_steep;
+
+    /*Helper which stores yx_steep for flat lines and xy_steep for steep (non flat) lines */
+    int32_t steep;
+
+    /*Steepness in 1 px in 0..255 range. Used only by flat lines. */
+    int32_t spx;
+
+    /*1: It's a flat line? (Near to horizontal)*/
+    uint8_t flat : 1;
+
+
+    /* Invert the mask. The default is: Keep the left part.
+     * It is used to select left/right/top/bottom*/
+    uint8_t inv: 1;
+} lv_draw_mask_line_param_t;
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_point_t vertex_p;
+        lv_coord_t start_angle;
+        lv_coord_t end_angle;
+    } cfg;
+
+    lv_draw_mask_line_param_t start_line;
+    lv_draw_mask_line_param_t end_line;
+    uint16_t delta_deg;
+} lv_draw_mask_angle_param_t;
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_area_t rect;
+        lv_coord_t radius;
+        /* Invert the mask. 0: Keep the pixels inside.*/
+        uint8_t outer: 1;
+    } cfg;
+    int32_t y_prev;
+    lv_sqrt_res_t y_prev_x;
+
+} lv_draw_mask_radius_param_t;
+
+typedef struct {
+    /*The first element must be the common descriptor*/
+    lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_area_t coords;
+        lv_coord_t y_top;
+        lv_coord_t y_bottom;
+        lv_opa_t opa_top;
+        lv_opa_t opa_bottom;
+    } cfg;
+
+} lv_draw_mask_fade_param_t;
+
+typedef struct _lv_draw_mask_map_param_t {
+    /*The first element must be the common descriptor*/
+    lv_draw_mask_common_dsc_t dsc;
+
+    struct {
+        lv_area_t coords;
+        const lv_opa_t * map;
+    } cfg;
+} lv_draw_mask_map_param_t;
+
+typedef struct {
+    void * param;
+    void * custom_id;
+} _lv_draw_mask_saved_t;
+
+typedef _lv_draw_mask_saved_t _lv_draw_mask_saved_arr_t[_LV_MASK_MAX_NUM];
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Add a draw mask. Everything drawn after it (until removing the mask) will be affected by the mask.
+ * @param param an initialized mask parameter. Only the pointer is saved.
+ * @param custom_id a custom pointer to identify the mask. Used in `lv_draw_mask_remove_custom`.
+ * @return the an integer, the ID of the mask. Can be used in `lv_draw_mask_remove_id`.
+ */
+int16_t lv_draw_mask_add(void * param, void * custom_id);
+
+
+//! @cond Doxygen_Suppress
+
+/**
+ * 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 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
+ */
+LV_ATTRIBUTE_FAST_MEM lv_draw_mask_res_t lv_draw_mask_apply(lv_opa_t * mask_buf, lv_coord_t abs_x, lv_coord_t abs_y,
+                                                            lv_coord_t len);
+
+
+//! @endcond
+
+/**
+ * Remove a mask with a given ID
+ * @param id the ID of the mask.  Returned by `lv_draw_mask_add`
+ * @return the parameter of the removed mask.
+ * If more masks have `custom_id` ID then the last mask's parameter will be returned
+ */
+void * lv_draw_mask_remove_id(int16_t id);
+
+/**
+ * Remove all mask with a given custom ID
+ * @param custom_id a pointer used in `lv_draw_mask_add`
+ * @return return the parameter of the removed mask.
+ * If more masks have `custom_id` ID then the last mask's parameter will be returned
+ */
+void * lv_draw_mask_remove_custom(void * custom_id);
+
+//! @cond Doxygen_Suppress
+
+/**
+ * Count the currently added masks
+ * @return number of active masks
+ */
+LV_ATTRIBUTE_FAST_MEM uint8_t lv_draw_mask_get_cnt(void);
+
+
+//! @endcond
+
+/**
+ *Initialize a line mask from two points.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param p1x X coordinate of the first point of the line
+ * @param p1y Y coordinate of the first point of the line
+ * @param p2x X coordinate of the second point of the line
+ * @param p2y y coordinate of the second point of the line
+ * @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
+ * With `LV_DRAW_MASK_LINE_SIDE_TOP/BOTTOM` and vertical line all pixels are kept
+ */
+void lv_draw_mask_line_points_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t p1y, lv_coord_t p2x,
+                                   lv_coord_t p2y, lv_draw_mask_line_side_t side);
+
+/**
+ *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 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
+ * With `LV_DRAW_MASK_LINE_SIDE_TOP/BOTTOM` and vertical line all pixels are kept
+ */
+void lv_draw_mask_line_angle_init(lv_draw_mask_line_param_t * param, lv_coord_t p1x, lv_coord_t py, int16_t angle,
+                                  lv_draw_mask_line_side_t side);
+
+/**
+ * Initialize an angle mask.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param vertex_x X coordinate of the angle vertex (absolute coordinates)
+ * @param vertex_y Y coordinate of the angle vertex (absolute coordinates)
+ * @param start_angle start angle in degrees. 0 deg on the right, 90 deg, on the bottom
+ * @param end_angle end angle
+ */
+void lv_draw_mask_angle_init(lv_draw_mask_angle_param_t * param, lv_coord_t vertex_x, lv_coord_t vertex_y,
+                             lv_coord_t start_angle, lv_coord_t end_angle);
+
+/**
+ * Initialize a fade mask.
+ * @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 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);
+
+/**
+ * Initialize a fade mask.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param coords coordinates of the area to affect (absolute coordinates)
+ * @param opa_top opacity on the top
+ * @param y_top at which coordinate start to change to opacity to `opa_bottom`
+ * @param opa_bottom opacity at the bottom
+ * @param y_bottom at which coordinate reach `opa_bottom`.
+ */
+void lv_draw_mask_fade_init(lv_draw_mask_fade_param_t * param, const lv_area_t * coords, lv_opa_t opa_top,
+                            lv_coord_t y_top,
+                            lv_opa_t opa_bottom, lv_coord_t y_bottom);
+
+/**
+ * Initialize a map mask.
+ * @param param pointer to a `lv_draw_mask_param_t` to initialize
+ * @param coords coordinates of the map (absolute coordinates)
+ * @param map array of bytes with the mask values
+ */
+void lv_draw_mask_map_init(lv_draw_mask_map_param_t * param, const lv_area_t * coords, const lv_opa_t * map);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_MASK_H*/

src/lv_draw/lv_draw_rect.h

@@ -13,7 +13,7 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_draw.h"
+#include "../lv_core/lv_style.h"
 
 /*********************
  *      DEFINES
@@ -23,18 +23,86 @@ extern "C" {
  *      TYPEDEFS
  **********************/
 
+typedef struct {
+    lv_style_int_t radius;
+
+    /*Background*/
+    lv_color_t bg_color;
+    lv_color_t bg_grad_color;
+    lv_grad_dir_t bg_grad_dir;
+    lv_style_int_t bg_main_color_stop;
+    lv_style_int_t bg_grad_color_stop;
+    lv_opa_t bg_opa;
+    lv_blend_mode_t bg_blend_mode;
+
+    /*Border*/
+    lv_color_t border_color;
+    lv_style_int_t border_width;
+    lv_style_int_t border_side;
+    lv_opa_t border_opa;
+    lv_blend_mode_t border_blend_mode;
+
+    /*Outline*/
+    lv_color_t outline_color;
+    lv_style_int_t outline_width;
+    lv_style_int_t outline_pad;
+    lv_opa_t outline_opa;
+    lv_blend_mode_t outline_blend_mode;
+
+    /*Shadow*/
+    lv_color_t shadow_color;
+    lv_style_int_t shadow_width;
+    lv_style_int_t shadow_ofs_x;
+    lv_style_int_t shadow_ofs_y;
+    lv_style_int_t shadow_spread;
+    lv_opa_t shadow_opa;
+    lv_blend_mode_t shadow_blend_mode;
+
+    /*Pattern*/
+    const void * pattern_image;
+    const lv_font_t * pattern_font;
+    lv_color_t pattern_recolor;
+    lv_opa_t pattern_opa;
+    lv_opa_t pattern_recolor_opa;
+    uint8_t pattern_repeat : 1;
+    lv_blend_mode_t pattern_blend_mode;
+
+    /*Value*/
+    const char * value_str;
+    const lv_font_t * value_font;
+    lv_opa_t value_opa;
+    lv_color_t value_color;
+    lv_style_int_t value_ofs_x;
+    lv_style_int_t value_ofs_y;
+    lv_style_int_t value_letter_space;
+    lv_style_int_t value_line_space;
+    lv_align_t value_align;
+    lv_blend_mode_t value_blend_mode;
+} lv_draw_rect_dsc_t;
+
 /**********************
  * GLOBAL PROTOTYPES
  **********************/
 
+LV_ATTRIBUTE_FAST_MEM void lv_draw_rect_dsc_init(lv_draw_rect_dsc_t * dsc);
+
+//! @endcond
+
 /**
  * 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 opa_scale scale down all opacities by the factor
  */
-void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa_scale);
+void lv_draw_rect(const lv_area_t * coords, const lv_area_t * mask, lv_draw_rect_dsc_t * dsc);
+
+/**
+ * Draw a pixel
+ * @param point the coordinates of the point to draw
+ * @param mask the pixel will be drawn only in this mask
+ * @param style pointer to a style
+ */
+void lv_draw_px(const lv_point_t * point, const lv_area_t * clip_area, const lv_style_t * style);
 
 /**********************
  *      MACROS

src/lv_draw/lv_draw_triangle.c

@@ -8,6 +8,7 @@
  *********************/
 #include "lv_draw_triangle.h"
 #include "../lv_misc/lv_math.h"
+#include "../lv_misc/lv_mem.h"
 
 /*********************
  *      DEFINES
@@ -20,9 +21,6 @@
 /**********************
  *  STATIC PROTOTYPES
  **********************/
-void tri_draw_flat(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa);
-void tri_draw_tall(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa);
-static void point_swap(lv_point_t * p1, lv_point_t * p2);
 
 /**********************
  *  STATIC VARIABLES
@@ -37,307 +35,131 @@ static void point_swap(lv_point_t * p1, lv_point_t * p2);
  **********************/
 
 /**
- *
+ * Draw a triangle
  * @param points pointer to an array with 3 points
- * @param mask the triangle will be drawn only in this mask
- * @param style style for of the triangle
- * @param opa_scale scale down all opacities by the factor (0..255)
+ * @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 * mask, const lv_style_t * style, lv_opa_t opa_scale)
+void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip_area, lv_draw_rect_dsc_t * draw_dsc)
 {
-    /*Return if the triangle is degenerated*/
-    if(points[0].x == points[1].x && points[0].y == points[1].y) return;
-    if(points[1].x == points[2].x && points[1].y == points[2].y) return;
-    if(points[0].x == points[2].x && points[0].y == points[2].y) return;
-
-    if(points[0].x == points[1].x && points[1].x == points[2].x) return;
-    if(points[0].y == points[1].y && points[1].y == points[2].y) return;
-
-    lv_opa_t opa = opa_scale == LV_OPA_COVER ? style->body.opa : (uint16_t)((uint16_t)style->body.opa * opa_scale) >> 8;
-
-    /*Is the triangle flat or tall?*/
-    lv_coord_t x_min = LV_MATH_MIN(LV_MATH_MIN(points[0].x, points[1].x), points[2].x);
-    lv_coord_t x_max = LV_MATH_MAX(LV_MATH_MAX(points[0].x, points[1].x), points[2].x);
-    lv_coord_t y_min = LV_MATH_MIN(LV_MATH_MIN(points[0].y, points[1].y), points[2].y);
-    lv_coord_t y_max = LV_MATH_MAX(LV_MATH_MAX(points[0].y, points[1].y), points[2].y);
-
-    /* Draw the tall rectangles from vertical lines
-     * and from the flat triangles from horizontal lines
-     * to minimize the number of lines.
-     * Some pixels are overdrawn on the common edges of the triangles
-     * so use it only if the triangle has no opacity*/
-
-    /* Draw from horizontal lines*/
-    if(x_max - x_min < y_max - y_min) {
-        tri_draw_tall(points, mask, style, opa);
-    }
-    /*Else flat so draw from vertical lines*/
-    else {
-        tri_draw_flat(points, mask, style, opa);
-    }
+    lv_draw_polygon(points, 3, clip_area, draw_dsc);
 }
 
 /**
- * Draw a polygon from triangles. Only convex polygons are supported
+ * Draw a polygon. Only convex polygons are supported
  * @param points an array of points
  * @param point_cnt number of points
- * @param mask polygon will be drawn only in this mask
- * @param style style of the polygon
- * @param opa_scale scale down all opacities by the factor (0..255)
+ * @param clip_area polygon will be drawn only in this area
+ * @param draw_dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
-void lv_draw_polygon(const lv_point_t * points, uint32_t point_cnt, const lv_area_t * mask, const lv_style_t * style,
-                     lv_opa_t opa_scale)
+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)
 {
     if(point_cnt < 3) return;
     if(points == NULL) return;
 
-    uint32_t i;
-    lv_point_t tri[3];
-    tri[0].x = points[0].x;
-    tri[0].y = points[0].y;
-    for(i = 0; i < point_cnt - 1; i++) {
-        tri[1].x = points[i].x;
-        tri[1].y = points[i].y;
-        tri[2].x = points[i + 1].x;
-        tri[2].y = points[i + 1].y;
-        lv_draw_triangle(tri, mask, style, opa_scale);
+    int16_t i;
+    lv_area_t poly_coords = {.x1 = LV_COORD_MAX, .y1 = LV_COORD_MAX, .x2 = LV_COORD_MIN, .y2 = LV_COORD_MIN};
+
+    for(i = 0; i < point_cnt; i++) {
+        poly_coords.x1 = LV_MATH_MIN(poly_coords.x1, points[i].x);
+        poly_coords.y1 = LV_MATH_MIN(poly_coords.y1, points[i].y);
+        poly_coords.x2 = LV_MATH_MAX(poly_coords.x2, points[i].x);
+        poly_coords.y2 = LV_MATH_MAX(poly_coords.y2, points[i].y);
     }
+
+
+    bool is_common;
+    lv_area_t poly_mask;
+    is_common = _lv_area_intersect(&poly_mask, &poly_coords, clip_area);
+    if(!is_common) return;
+
+    /*Find the lowest point*/
+    lv_coord_t y_min = points[0].y;
+    int16_t y_min_i = 0;
+
+    for(i = 1; i < point_cnt; i++) {
+        if(points[i].y < y_min) {
+            y_min = points[i].y;
+            y_min_i = i;
+        }
+    }
+
+    lv_draw_mask_line_param_t * mp = _lv_mem_buf_get(sizeof(lv_draw_mask_line_param_t) * point_cnt);
+    lv_draw_mask_line_param_t * mp_next = mp;
+
+    int32_t i_prev_left = y_min_i;
+    int32_t i_prev_right = y_min_i;
+    int32_t i_next_left;
+    int32_t i_next_right;
+    uint32_t mask_cnt = 0;
+
+    /* Check if the order of points is inverted or not.
+     * The normal case is when the left point is on `y_min_i - 1`*/
+    i_next_left = y_min_i - 1;
+    if(i_next_left < 0) i_next_left = point_cnt + i_next_left;
+
+    i_next_right = y_min_i + 1;
+    if(i_next_right > point_cnt - 1) i_next_right = 0;
+
+    bool inv = false;
+    if(points[i_next_left].x > points[i_next_right].x && points[i_next_left].y < points[i_next_right].y) inv = true;
+
+    do {
+        if(!inv) {
+            i_next_left = i_prev_left - 1;
+            if(i_next_left < 0) i_next_left = point_cnt + i_next_left;
+
+            i_next_right = i_prev_right + 1;
+            if(i_next_right > point_cnt - 1) i_next_right = 0;
+        }
+        else {
+            i_next_left = i_prev_left + 1;
+            if(i_next_left > point_cnt - 1) i_next_left = 0;
+
+            i_next_right = i_prev_right - 1;
+            if(i_next_right < 0) i_next_right = point_cnt + i_next_right;
+        }
+
+        if(points[i_next_left].y >=  points[i_prev_left].y) {
+            if(points[i_next_left].y != points[i_prev_left].y &&
+               points[i_next_left].x !=  points[i_prev_left].x) {
+                lv_draw_mask_line_points_init(mp_next, points[i_prev_left].x, points[i_prev_left].y,
+                                              points[i_next_left].x, points[i_next_left].y,
+                                              LV_DRAW_MASK_LINE_SIDE_RIGHT);
+                lv_draw_mask_add(mp_next, mp);
+                mp_next++;
+            }
+            mask_cnt++;
+            i_prev_left = i_next_left;
+        }
+
+        if(mask_cnt == point_cnt) break;
+
+        if(points[i_next_right].y >=  points[i_prev_right].y) {
+            if(points[i_next_right].y != points[i_prev_right].y &&
+               points[i_next_right].x !=  points[i_prev_right].x) {
+
+                lv_draw_mask_line_points_init(mp_next, points[i_prev_right].x, points[i_prev_right].y,
+                                              points[i_next_right].x, points[i_next_right].y,
+                                              LV_DRAW_MASK_LINE_SIDE_LEFT);
+                lv_draw_mask_add(mp_next, mp);
+                mp_next++;
+            }
+            mask_cnt++;
+            i_prev_right = i_next_right;
+        }
+
+    } while(mask_cnt < point_cnt);
+
+    lv_draw_rect(&poly_coords, clip_area, draw_dsc);
+
+    lv_draw_mask_remove_custom(mp);
+
+    _lv_mem_buf_release(mp);
+
 }
 
 /**********************
  *   STATIC FUNCTIONS
  **********************/
-
-void tri_draw_flat(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa)
-{
-    /*Return if the points are out of the mask*/
-    if(points[0].x < mask->x1 && points[1].x < mask->x1 && points[2].x < mask->x1) {
-        return;
-    }
-
-    if(points[0].x > mask->x2 && points[1].x > mask->x2 && points[2].x > mask->x2) {
-        return;
-    }
-
-    if(points[0].y < mask->y1 && points[1].y < mask->y1 && points[2].y < mask->y1) {
-        return;
-    }
-
-    if(points[0].y > mask->y2 && points[1].y > mask->y2 && points[2].y > mask->y2) {
-        return;
-    }
-
-    lv_point_t tri[3];
-
-    memcpy(tri, points, sizeof(tri));
-
-    /*Sort the vertices according to their y coordinate (0: y max, 1: y mid, 2:y min)*/
-    if(tri[1].y < tri[0].y) point_swap(&tri[1], &tri[0]);
-    if(tri[2].y < tri[1].y) point_swap(&tri[2], &tri[1]);
-    if(tri[1].y < tri[0].y) point_swap(&tri[1], &tri[0]);
-
-    /*Draw the triangle*/
-    lv_point_t edge1;
-    lv_coord_t dx1  = LV_MATH_ABS(tri[0].x - tri[1].x);
-    lv_coord_t sx1  = tri[0].x < tri[1].x ? 1 : -1;
-    lv_coord_t dy1  = LV_MATH_ABS(tri[0].y - tri[1].y);
-    lv_coord_t sy1  = tri[0].y < tri[1].y ? 1 : -1;
-    lv_coord_t err1 = (dx1 > dy1 ? dx1 : -dy1) / 2;
-    lv_coord_t err_tmp1;
-
-    lv_point_t edge2;
-    lv_coord_t dx2  = LV_MATH_ABS(tri[0].x - tri[2].x);
-    lv_coord_t sx2  = tri[0].x < tri[2].x ? 1 : -1;
-    lv_coord_t dy2  = LV_MATH_ABS(tri[0].y - tri[2].y);
-    lv_coord_t sy2  = tri[0].y < tri[2].y ? 1 : -1;
-    lv_coord_t err2 = (dx1 > dy2 ? dx2 : -dy2) / 2;
-    lv_coord_t err_tmp2;
-
-    lv_coord_t y1_tmp;
-    lv_coord_t y2_tmp;
-
-    edge1.x = tri[0].x;
-    edge1.y = tri[0].y;
-    edge2.x = tri[0].x;
-    edge2.y = tri[0].y;
-    lv_area_t act_area;
-    lv_area_t draw_area;
-
-    while(1) {
-        act_area.x1 = edge1.x;
-        act_area.x2 = edge2.x;
-        act_area.y1 = edge1.y;
-        act_area.y2 = edge2.y;
-
-        /* Get the area of a line.
-         * Adjust it a little bit to perfectly match (no redrawn pixels) with the adjacent triangles*/
-        draw_area.x1 = LV_MATH_MIN(act_area.x1, act_area.x2) + 1;
-        draw_area.x2 = LV_MATH_MAX(act_area.x1, act_area.x2);
-        draw_area.y1 = LV_MATH_MIN(act_area.y1, act_area.y2) - 1;
-        draw_area.y2 = LV_MATH_MAX(act_area.y1, act_area.y2) - 1;
-
-        lv_draw_fill(&draw_area, mask, style->body.main_color, opa);
-
-        /*Calc. the next point of edge1*/
-        y1_tmp = edge1.y;
-        do {
-            if(edge1.x == tri[1].x && edge1.y == tri[1].y) {
-
-                dx1  = LV_MATH_ABS(tri[1].x - tri[2].x);
-                sx1  = tri[1].x < tri[2].x ? 1 : -1;
-                dy1  = LV_MATH_ABS(tri[1].y - tri[2].y);
-                sy1  = tri[1].y < tri[2].y ? 1 : -1;
-                err1 = (dx1 > dy1 ? dx1 : -dy1) / 2;
-            } else if(edge1.x == tri[2].x && edge1.y == tri[2].y) {
-                return;
-            }
-            err_tmp1 = err1;
-            if(err_tmp1 > -dx1) {
-                err1 -= dy1;
-                edge1.x += sx1;
-            }
-            if(err_tmp1 < dy1) {
-                err1 += dx1;
-                edge1.y += sy1;
-            }
-        } while(edge1.y == y1_tmp);
-
-        /*Calc. the next point of edge2*/
-        y2_tmp = edge2.y;
-        do {
-            if(edge2.x == tri[2].x && edge2.y == tri[2].y) return;
-            err_tmp2 = err2;
-            if(err_tmp2 > -dx2) {
-                err2 -= dy2;
-                edge2.x += sx2;
-            }
-            if(err_tmp2 < dy2) {
-                err2 += dx2;
-                edge2.y += sy2;
-            }
-        } while(edge2.y == y2_tmp);
-    }
-}
-
-void tri_draw_tall(const lv_point_t * points, const lv_area_t * mask, const lv_style_t * style, lv_opa_t opa)
-{
-    /*
-     * Better to draw from vertical lines
-     * |\
-     * | |
-     * | |
-     * |  \
-     * |   |
-     * |___|
-     */
-
-    lv_point_t tri[3];
-
-    memcpy(tri, points, sizeof(tri));
-
-    /*Sort the vertices according to their x coordinate (0: x max, 1: x mid, 2:x min)*/
-    if(tri[1].x < tri[0].x) point_swap(&tri[1], &tri[0]);
-    if(tri[2].x < tri[1].x) point_swap(&tri[2], &tri[1]);
-    if(tri[1].x < tri[0].x) point_swap(&tri[1], &tri[0]);
-
-    /*Draw the triangle*/
-    lv_point_t edge1;
-    lv_coord_t dx1  = LV_MATH_ABS(tri[0].x - tri[1].x);
-    lv_coord_t sx1  = tri[0].x < tri[1].x ? 1 : -1;
-    lv_coord_t dy1  = LV_MATH_ABS(tri[0].y - tri[1].y);
-    lv_coord_t sy1  = tri[0].y < tri[1].y ? 1 : -1;
-    lv_coord_t err1 = (dx1 > dy1 ? dx1 : -dy1) / 2;
-    lv_coord_t err_tmp1;
-
-    lv_point_t edge2;
-    lv_coord_t dx2  = LV_MATH_ABS(tri[0].x - tri[2].x);
-    lv_coord_t sx2  = tri[0].x < tri[2].x ? 1 : -1;
-    lv_coord_t dy2  = LV_MATH_ABS(tri[0].y - tri[2].y);
-    lv_coord_t sy2  = tri[0].y < tri[2].y ? 1 : -1;
-    lv_coord_t err2 = (dx1 > dy2 ? dx2 : -dy2) / 2;
-    lv_coord_t err_tmp2;
-
-    lv_coord_t x1_tmp;
-    lv_coord_t x2_tmp;
-
-    edge1.x = tri[0].x;
-    edge1.y = tri[0].y;
-    edge2.x = tri[0].x;
-    edge2.y = tri[0].y;
-    lv_area_t act_area;
-    lv_area_t draw_area;
-
-    while(1) {
-        act_area.x1 = edge1.x;
-        act_area.x2 = edge2.x;
-        act_area.y1 = edge1.y;
-        act_area.y2 = edge2.y;
-
-        draw_area.x1 = LV_MATH_MIN(act_area.x1, act_area.x2);
-        draw_area.x2 = LV_MATH_MAX(act_area.x1, act_area.x2);
-        draw_area.y1 = LV_MATH_MIN(act_area.y1, act_area.y2);
-        draw_area.y2 = LV_MATH_MAX(act_area.y1, act_area.y2) - 1;
-
-        lv_draw_fill(&draw_area, mask, style->body.main_color, opa);
-
-        /*Calc. the next point of edge1*/
-        x1_tmp = edge1.x;
-        do {
-            if(edge1.y == tri[1].y && edge1.x == tri[1].x) {
-
-                dx1  = LV_MATH_ABS(tri[1].x - tri[2].x);
-                sx1  = tri[1].x < tri[2].x ? 1 : -1;
-                dy1  = LV_MATH_ABS(tri[1].y - tri[2].y);
-                sy1  = tri[1].y < tri[2].y ? 1 : -1;
-                err1 = (dx1 > dy1 ? dx1 : -dy1) / 2;
-            } else if(edge1.y == tri[2].y && edge1.x == tri[2].x) {
-                return;
-            }
-            err_tmp1 = err1;
-            if(err_tmp1 > -dx1) {
-                err1 -= dy1;
-                edge1.x += sx1;
-            }
-            if(err_tmp1 < dy1) {
-                err1 += dx1;
-                edge1.y += sy1;
-            }
-        } while(edge1.x == x1_tmp);
-
-        /*Calc. the next point of edge2*/
-        x2_tmp = edge2.x;
-        do {
-            if(edge2.y == tri[2].y && edge2.x == tri[2].x) {
-                return;
-            }
-
-            err_tmp2 = err2;
-            if(err_tmp2 > -dx2) {
-                err2 -= dy2;
-                edge2.x += sx2;
-            }
-            if(err_tmp2 < dy2) {
-                err2 += dx2;
-                edge2.y += sy2;
-            }
-        } while(edge2.x == x2_tmp);
-    }
-}
-
-/**
- * Swap two points
- * p1 pointer to the first point
- * p2 pointer to the second point
- */
-static void point_swap(lv_point_t * p1, lv_point_t * p2)
-{
-    lv_point_t tmp;
-    tmp.x = p1->x;
-    tmp.y = p1->y;
-
-    p1->x = p2->x;
-    p1->y = p2->y;
-
-    p2->x = tmp.x;
-    p2->y = tmp.y;
-}

src/lv_draw/lv_draw_triangle.h

@@ -13,7 +13,7 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#include "lv_draw.h"
+#include "lv_draw_rect.h"
 
 /*********************
  *      DEFINES
@@ -28,24 +28,22 @@ extern "C" {
  **********************/
 
 /**
- *
+ * Draw a triangle
  * @param points pointer to an array with 3 points
- * @param mask the triangle will be drawn only in this mask
- * @param style style for of the triangle
- * @param opa_scale scale down all opacities by the factor (0..255)
+ * @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 * mask, const lv_style_t * style, lv_opa_t opa_scale);
+void lv_draw_triangle(const lv_point_t points[], const lv_area_t * clip, lv_draw_rect_dsc_t * draw_dsc);
 
 /**
- * Draw a polygon from triangles. Only convex polygons are supported
+ * Draw a polygon. Only convex polygons are supported.
  * @param points an array of points
  * @param point_cnt number of points
- * @param mask polygon will be drawn only in this mask
- * @param style style of the polygon
- * @param opa_scale scale down all opacities by the factor (0..255)
+ * @param clip_area polygon will be drawn only in this area
+ * @param draw_dsc pointer to an initialized `lv_draw_rect_dsc_t` variable
  */
-void lv_draw_polygon(const lv_point_t * points, uint32_t point_cnt, const lv_area_t * mask, const lv_style_t * style,
-                     lv_opa_t opa_scale);
+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);
 
 /**********************
  *      MACROS

src/lv_draw/lv_img_buf.c

@@ -0,0 +1,669 @@
+/**
+ * @file lv_img_buf.c
+ *
+ */
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stddef.h>
+#include <string.h>
+#include "lv_img_buf.h"
+#include "lv_draw_img.h"
+#include "../lv_misc/lv_math.h"
+#include "../lv_misc/lv_log.h"
+#include "../lv_misc/lv_mem.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+
+/**
+ * Get the color of an image's pixel
+ * @param dsc an image descriptor
+ * @param x x coordinate of the point to get
+ * @param y x coordinate of the point to get
+ * @param color the color of the image. In case of `LV_IMG_CF_ALPHA_1/2/4/8` this color is used.
+ * Not used in other cases.
+ * @param safe true: check out of bounds
+ * @return color of the point
+ */
+lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_color_t color)
+{
+    lv_color_t p_color = LV_COLOR_BLACK;
+    uint8_t * buf_u8 = (uint8_t *)dsc->data;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED ||
+       dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
+        uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3;
+        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 default alpha value*/
+#endif
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) {
+        buf_u8 += 4 * 2;
+        uint8_t bit = x & 0x7;
+        x           = x >> 3;
+
+        /* Get the current pixel.
+         * dsc->header.w + 7 means rounding up to 8 because the lines are byte aligned
+         * so the possible real width are 8, 16, 24 ...*/
+        uint32_t px  = ((dsc->header.w + 7) >> 3) * y + x;
+        p_color.full = (buf_u8[px] & (1 << (7 - bit))) >> (7 - bit);
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_2BIT) {
+        buf_u8 += 4 * 4;
+        uint8_t bit = (x & 0x3) * 2;
+        x           = x >> 2;
+
+        /* Get the current pixel.
+         * dsc->header.w + 3 means rounding up to 4 because the lines are byte aligned
+         * so the possible real width are 4, 8, 12 ...*/
+        uint32_t px  = ((dsc->header.w + 3) >> 2) * y + x;
+        p_color.full = (buf_u8[px] & (3 << (6 - bit))) >> (6 - bit);
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_4BIT) {
+        buf_u8 += 4 * 16;
+        uint8_t bit = (x & 0x1) * 4;
+        x           = x >> 1;
+
+        /* Get the current pixel.
+         * dsc->header.w + 1 means rounding up to 2 because the lines are byte aligned
+         * so the possible real width are 2, 4, 6 ...*/
+        uint32_t px  = ((dsc->header.w + 1) >> 1) * y + x;
+        p_color.full = (buf_u8[px] & (0xF << (4 - bit))) >> (4 - bit);
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
+        buf_u8 += 4 * 256;
+        uint32_t px  = dsc->header.w * y + x;
+        p_color.full = buf_u8[px];
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT || dsc->header.cf == LV_IMG_CF_ALPHA_2BIT ||
+            dsc->header.cf == LV_IMG_CF_ALPHA_4BIT || dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
+        p_color = color;
+    }
+    return p_color;
+}
+
+/**
+ * Get the alpha value of an image's pixel
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param safe true: check out of bounds
+ * @return alpha value of the point
+ */
+lv_opa_t lv_img_buf_get_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y)
+{
+    uint8_t * buf_u8 = (uint8_t *)dsc->data;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
+        uint32_t px = dsc->header.w * y * LV_IMG_PX_SIZE_ALPHA_BYTE + x * LV_IMG_PX_SIZE_ALPHA_BYTE;
+        return buf_u8[px + LV_IMG_PX_SIZE_ALPHA_BYTE - 1];
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT) {
+        uint8_t bit = x & 0x7;
+        x           = x >> 3;
+
+        /* Get the current pixel.
+         * dsc->header.w + 7 means rounding up to 8 because the lines are byte aligned
+         * so the possible real width are 8 ,16, 24 ...*/
+        uint32_t px    = ((dsc->header.w + 7) >> 3) * y + x;
+        uint8_t px_opa = (buf_u8[px] & (1 << (7 - bit))) >> (7 - bit);
+        return px_opa ? LV_OPA_TRANSP : LV_OPA_COVER;
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_2BIT) {
+        const uint8_t opa_table[4] = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/
+
+        uint8_t bit = (x & 0x3) * 2;
+        x           = x >> 2;
+
+        /* Get the current pixel.
+         * dsc->header.w + 4 means rounding up to 8 because the lines are byte aligned
+         * so the possible real width are 4 ,8, 12 ...*/
+        uint32_t px    = ((dsc->header.w + 3) >> 2) * y + x;
+        uint8_t px_opa = (buf_u8[px] & (3 << (6 - bit))) >> (6 - bit);
+        return opa_table[px_opa];
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_4BIT) {
+        const uint8_t opa_table[16] = {0,  17, 34,  51, /*Opacity mapping with bpp = 4*/
+                                       68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255
+                                      };
+
+        uint8_t bit = (x & 0x1) * 4;
+        x           = x >> 1;
+
+        /* Get the current pixel.
+         * dsc->header.w + 1 means rounding up to 8 because the lines are byte aligned
+         * so the possible real width are 2 ,4, 6 ...*/
+        uint32_t px    = ((dsc->header.w + 1) >> 1) * y + x;
+        uint8_t px_opa = (buf_u8[px] & (0xF << (4 - bit))) >> (4 - bit);
+        return opa_table[px_opa];
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
+        uint32_t px = dsc->header.w * y + x;
+        return buf_u8[px];
+    }
+
+    return LV_OPA_COVER;
+}
+
+/**
+ * Set the alpha value of a pixel of an image. The color won't be affected
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param opa the desired opacity
+ * @param safe true: check out of bounds
+ */
+void lv_img_buf_set_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_opa_t opa)
+{
+    uint8_t * buf_u8 = (uint8_t *)dsc->data;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
+        uint8_t px_size          = lv_img_cf_get_px_size(dsc->header.cf) >> 3;
+        uint32_t px              = dsc->header.w * y * px_size + x * px_size;
+        buf_u8[px + px_size - 1] = opa;
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT) {
+        opa         = opa >> 7; /*opa -> [0,1]*/
+        uint8_t bit = x & 0x7;
+        x           = x >> 3;
+
+        /* Get the current pixel.
+         * dsc->header.w + 7 means rounding up to 8 because the lines are byte aligned
+         * so the possible real width are 8 ,16, 24 ...*/
+        uint32_t px = ((dsc->header.w + 7) >> 3) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(1 << (7 - bit));
+        buf_u8[px]  = buf_u8[px] | ((opa & 0x1) << (7 - bit));
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_2BIT) {
+        opa         = opa >> 6; /*opa -> [0,3]*/
+        uint8_t bit = (x & 0x3) * 2;
+        x           = x >> 2;
+
+        /* Get the current pixel.
+         * dsc->header.w + 4 means rounding up to 8 because the lines are byte aligned
+         * so the possible real width are 4 ,8, 12 ...*/
+        uint32_t px = ((dsc->header.w + 3) >> 2) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(3 << (6 - bit));
+        buf_u8[px]  = buf_u8[px] | ((opa & 0x3) << (6 - bit));
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_4BIT) {
+        opa         = opa >> 4; /*opa -> [0,15]*/
+        uint8_t bit = (x & 0x1) * 4;
+        x           = x >> 1;
+
+        /* Get the current pixel.
+         * dsc->header.w + 1 means rounding up to 8 because the lines are byte aligned
+         * so the possible real width are 2 ,4, 6 ...*/
+        uint32_t px = ((dsc->header.w + 1) >> 1) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(0xF << (4 - bit));
+        buf_u8[px]  = buf_u8[px] | ((opa & 0xF) << (4 - bit));
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
+        uint32_t px = dsc->header.w * y + x;
+        buf_u8[px]  = opa;
+    }
+}
+
+/**
+ * Set the color of a pixel of an image. The alpha channel won't be affected.
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param c color of the point
+ * @param safe true: check out of bounds
+ */
+void lv_img_buf_set_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_color_t c)
+{
+    uint8_t * buf_u8 = (uint8_t *)dsc->data;
+
+    if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR || dsc->header.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) {
+        uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3;
+        uint32_t px     = dsc->header.w * y * px_size + x * px_size;
+        _lv_memcpy_small(&buf_u8[px], &c, px_size);
+    }
+    else if(dsc->header.cf == LV_IMG_CF_TRUE_COLOR_ALPHA) {
+        uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf) >> 3;
+        uint32_t px     = dsc->header.w * y * px_size + x * px_size;
+        _lv_memcpy_small(&buf_u8[px], &c, px_size - 1); /*-1 to not overwrite the alpha value*/
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT) {
+        buf_u8 += sizeof(lv_color32_t) * 2; /*Skip the palette*/
+
+        uint8_t bit = x & 0x7;
+        x           = x >> 3;
+
+        /* Get the current pixel.
+         * dsc->header.w + 7 means rounding up to 8 because the lines are byte aligned
+         * so the possible real width are 8 ,16, 24 ...*/
+        uint32_t px = ((dsc->header.w + 7) >> 3) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(1 << (7 - bit));
+        buf_u8[px]  = buf_u8[px] | ((c.full & 0x1) << (7 - bit));
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_2BIT) {
+        buf_u8 += sizeof(lv_color32_t) * 4; /*Skip the palette*/
+        uint8_t bit = (x & 0x3) * 2;
+        x           = x >> 2;
+
+        /* Get the current pixel.
+         * dsc->header.w + 3 means rounding up to 4 because the lines are byte aligned
+         * so the possible real width are 4, 8 ,12 ...*/
+        uint32_t px = ((dsc->header.w + 3) >> 2) * y + x;
+
+        buf_u8[px] = buf_u8[px] & ~(3 << (6 - bit));
+        buf_u8[px] = buf_u8[px] | ((c.full & 0x3) << (6 - bit));
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_4BIT) {
+        buf_u8 += sizeof(lv_color32_t) * 16; /*Skip the palette*/
+        uint8_t bit = (x & 0x1) * 4;
+        x           = x >> 1;
+
+        /* Get the current pixel.
+         * dsc->header.w + 1 means rounding up to 2 because the lines are byte aligned
+         * so the possible real width are 2 ,4, 6 ...*/
+        uint32_t px = ((dsc->header.w + 1) >> 1) * y + x;
+        buf_u8[px]  = buf_u8[px] & ~(0xF << (4 - bit));
+        buf_u8[px]  = buf_u8[px] | ((c.full & 0xF) << (4 - bit));
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
+        buf_u8 += sizeof(lv_color32_t) * 256; /*Skip the palette*/
+        uint32_t px = dsc->header.w * y + x;
+        buf_u8[px]  = c.full;
+    }
+}
+
+/**
+ * Set the palette color of an indexed image. Valid only for `LV_IMG_CF_INDEXED1/2/4/8`
+ * @param dsc pointer to an image descriptor
+ * @param id the palette color to set:
+ *   - for `LV_IMG_CF_INDEXED1`: 0..1
+ *   - for `LV_IMG_CF_INDEXED2`: 0..3
+ *   - for `LV_IMG_CF_INDEXED4`: 0..15
+ *   - for `LV_IMG_CF_INDEXED8`: 0..255
+ * @param c the color to set
+ */
+void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c)
+{
+    if((dsc->header.cf == LV_IMG_CF_ALPHA_1BIT && id > 1) || (dsc->header.cf == LV_IMG_CF_ALPHA_2BIT && id > 3) ||
+       (dsc->header.cf == LV_IMG_CF_ALPHA_4BIT && id > 15) || (dsc->header.cf == LV_IMG_CF_ALPHA_8BIT)) {
+        LV_LOG_WARN("lv_img_buf_set_px_alpha: invalid 'id'");
+        return;
+    }
+
+    lv_color32_t c32;
+    c32.full      = lv_color_to32(c);
+    uint8_t * buf = (uint8_t *)dsc->data;
+    _lv_memcpy_small(&buf[id * sizeof(c32)], &c32, sizeof(c32));
+}
+
+/**
+ * Allocate an image buffer in RAM
+ * @param w width of image
+ * @param h height of image
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return an allocated image, or NULL on failure
+ */
+lv_img_dsc_t * lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
+{
+    /* Allocate image descriptor */
+    lv_img_dsc_t * dsc = lv_mem_alloc(sizeof(lv_img_dsc_t));
+    if(dsc == NULL)
+        return NULL;
+
+    _lv_memset_00(dsc, sizeof(lv_img_dsc_t));
+
+    /* Get image data size */
+    dsc->data_size = lv_img_buf_get_img_size(w, h, cf);
+    if(dsc->data_size == 0) {
+        lv_mem_free(dsc);
+        return NULL;
+    }
+
+    /* Allocate raw buffer */
+    dsc->data = lv_mem_alloc(dsc->data_size);
+    if(dsc->data == NULL) {
+        lv_mem_free(dsc);
+        return NULL;
+    }
+    _lv_memset_00((uint8_t *)dsc->data, dsc->data_size);
+
+    /* Fill in header */
+    dsc->header.always_zero = 0;
+    dsc->header.w = w;
+    dsc->header.h = h;
+    dsc->header.cf = cf;
+    return dsc;
+}
+
+/**
+ * Free an allocated image buffer
+ * @param dsc image buffer to free
+ */
+void lv_img_buf_free(lv_img_dsc_t * dsc)
+{
+    if(dsc != NULL) {
+        if(dsc->data != NULL)
+            lv_mem_free(dsc->data);
+
+        lv_mem_free(dsc);
+    }
+}
+
+/**
+ * Get the memory consumption of a raw bitmap, given color format and dimensions.
+ * @param w width
+ * @param h height
+ * @param cf color format
+ * @return size in bytes
+ */
+uint32_t lv_img_buf_get_img_size(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf)
+{
+    switch(cf) {
+        case LV_IMG_CF_TRUE_COLOR:
+            return LV_IMG_BUF_SIZE_TRUE_COLOR(w, h);
+        case LV_IMG_CF_TRUE_COLOR_ALPHA:
+            return LV_IMG_BUF_SIZE_TRUE_COLOR_ALPHA(w, h);
+        case LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED:
+            return LV_IMG_BUF_SIZE_TRUE_COLOR_CHROMA_KEYED(w, h);
+        case LV_IMG_CF_ALPHA_1BIT:
+            return LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h);
+        case LV_IMG_CF_ALPHA_2BIT:
+            return LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h);
+        case LV_IMG_CF_ALPHA_4BIT:
+            return LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h);
+        case LV_IMG_CF_ALPHA_8BIT:
+            return LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h);
+        case LV_IMG_CF_INDEXED_1BIT:
+            return LV_IMG_BUF_SIZE_INDEXED_1BIT(w, h);
+        case LV_IMG_CF_INDEXED_2BIT:
+            return LV_IMG_BUF_SIZE_INDEXED_2BIT(w, h);
+        case LV_IMG_CF_INDEXED_4BIT:
+            return LV_IMG_BUF_SIZE_INDEXED_4BIT(w, h);
+        case LV_IMG_CF_INDEXED_8BIT:
+            return LV_IMG_BUF_SIZE_INDEXED_8BIT(w, h);
+        default:
+            return 0;
+    }
+}
+
+
+#if LV_USE_IMG_TRANSFORM
+/**
+ * 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)
+{
+    dsc->tmp.pivot_x_256 = dsc->cfg.pivot_x * 256;
+    dsc->tmp.pivot_y_256 = dsc->cfg.pivot_y * 256;
+
+    int32_t angle_low = dsc->cfg.angle / 10;
+    int32_t angle_hight = angle_low + 1;
+    int32_t angle_rem = dsc->cfg.angle  - (angle_low * 10);
+
+    int32_t s1 = _lv_trigo_sin(-angle_low);
+    int32_t s2 = _lv_trigo_sin(-angle_hight);
+
+    int32_t c1 = _lv_trigo_sin(-angle_low + 90);
+    int32_t c2 = _lv_trigo_sin(-angle_hight + 90);
+
+    dsc->tmp.sinma = (s1 * (10 - angle_rem) + s2 * angle_rem) / 10;
+    dsc->tmp.cosma = (c1 * (10 - angle_rem) + c2 * angle_rem) / 10;
+
+    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 ||
+       dsc->cfg.cf == LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED) {
+        dsc->tmp.native_color = 1;
+    }
+    else {
+        dsc->tmp.native_color = 0;
+    }
+
+    dsc->tmp.img_dsc.data = dsc->cfg.src;
+    dsc->tmp.img_dsc.header.always_zero = 0;
+    dsc->tmp.img_dsc.header.cf = dsc->cfg.cf;
+    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;
+
+    dsc->res.opa = LV_OPA_COVER;
+    dsc->res.color = dsc->cfg.color;
+}
+#endif
+
+/**
+ * Get the area of a rectangle if its rotated and scaled
+ * @param res store the coordinates here
+ * @param w width of the rectangle to transform
+ * @param h height of the rectangle to transform
+ * @param angle angle of rotation
+ * @param zoom zoom, (256 no zoom)
+ * @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)
+{
+#if LV_USE_IMG_TRANSFORM
+    if(angle == 0 && zoom == LV_IMG_ZOOM_NONE) {
+        res->x1 = 0;
+        res->y1 = 0;
+        res->x2 = w - 1;
+        res->y2 = h - 1;
+        return;
+
+    }
+
+    int32_t angle_low = angle / 10;
+    int32_t angle_hight = angle_low + 1;
+    int32_t angle_rem = angle  - (angle_low * 10);
+
+    int32_t s1 = _lv_trigo_sin(angle_low);
+    int32_t s2 = _lv_trigo_sin(angle_hight);
+
+    int32_t c1 = _lv_trigo_sin(angle_low + 90);
+    int32_t c2 = _lv_trigo_sin(angle_hight + 90);
+
+    int32_t sinma = (s1 * (10 - angle_rem) + s2 * angle_rem) / 10;
+    int32_t cosma = (c1 * (10 - angle_rem) + c2 * angle_rem) / 10;
+
+    lv_point_t lt;
+    lv_point_t rt;
+    lv_point_t lb;
+    lv_point_t rb;
+
+    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 = 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 = 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 = 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;
+
+    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);
+    res->y1 = LV_MATH_MIN4(lb.y, lt.y, rb.y, rt.y);
+    res->y2 = LV_MATH_MAX4(lb.y, lt.y, rb.y, rt.y);
+#else
+    LV_UNUSED(angle);
+    LV_UNUSED(zoom);
+    LV_UNUSED(pivot);
+    res->x1 = 0;
+    res->y1 = 0;
+    res->x2 = w - 1;
+    res->y2 = h - 1;
+#endif
+}
+
+#if LV_USE_IMG_TRANSFORM
+/**
+ * Continue transformation by taking the neighbors into account
+ * @param dsc pointer to the transformation descriptor
+ */
+bool _lv_img_buf_transform_anti_alias(lv_img_transform_dsc_t * dsc)
+{
+    const uint8_t * src_u8 = dsc->cfg.src;
+
+    /*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 neighbor*/
+    lv_opa_t xr; /*x mix ratio*/
+
+    if(xs_fract < 0x70) {
+        xn = - 1;
+        if(dsc->tmp.xs_int + xn < 0) xn = 0;
+        xr = xs_fract + 0x80;
+    }
+    else if(xs_fract > 0x90) {
+        xn =  1;
+        if(dsc->tmp.xs_int + xn >= dsc->cfg.src_w) xn = 0;
+        xr = (0xFF - xs_fract) + 0x80;
+    }
+    else {
+        xn = 0;
+        xr = 0xFF;
+    }
+
+    int32_t yn;      /*x neighbor*/
+    lv_opa_t yr; /*x mix ratio*/
+
+    if(ys_fract < 0x70) {
+        yn = - 1;
+        if(dsc->tmp.ys_int + yn < 0) yn = 0;
+
+        yr = ys_fract + 0x80;
+    }
+    else if(ys_fract > 0x90) {
+        yn =  1;
+        if(dsc->tmp.ys_int + yn >= dsc->cfg.src_h) yn = 0;
+
+        yr = (0xFF - ys_fract) + 0x80;
+    }
+    else {
+        yn = 0;
+        yr = 0xFF;
+    }
+
+    lv_color_t c00 = dsc->res.color;
+    lv_color_t c01;
+    lv_color_t c10;
+    lv_color_t c11;
+
+    lv_opa_t a00 = dsc->res.opa;
+    lv_opa_t a10 = 0;
+    lv_opa_t a01 = 0;
+    lv_opa_t a11 = 0;
+
+    if(dsc->tmp.native_color) {
+        _lv_memcpy_small(&c01, &src_u8[dsc->tmp.pxi + dsc->tmp.px_size * xn], sizeof(lv_color_t));
+        _lv_memcpy_small(&c10, &src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn], sizeof(lv_color_t));
+        _lv_memcpy_small(&c11, &src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn + dsc->tmp.px_size * xn],
+                         sizeof(lv_color_t));
+        if(dsc->tmp.has_alpha) {
+            a10 = src_u8[dsc->tmp.pxi + dsc->tmp.px_size * xn + dsc->tmp.px_size - 1];
+            a01 = src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn + dsc->tmp.px_size - 1];
+            a11 = src_u8[dsc->tmp.pxi + dsc->cfg.src_w * dsc->tmp.px_size * yn + dsc->tmp.px_size * xn + dsc->tmp.px_size - 1];
+        }
+    }
+    else {
+        c01 = lv_img_buf_get_px_color(&dsc->tmp.img_dsc, dsc->tmp.xs_int + xn, dsc->tmp.ys_int, dsc->cfg.color);
+        c10 = lv_img_buf_get_px_color(&dsc->tmp.img_dsc, dsc->tmp.xs_int, dsc->tmp.ys_int + yn, dsc->cfg.color);
+        c11 = lv_img_buf_get_px_color(&dsc->tmp.img_dsc, dsc->tmp.xs_int + xn, dsc->tmp.ys_int + yn, dsc->cfg.color);
+
+        if(dsc->tmp.has_alpha) {
+            a10 = lv_img_buf_get_px_alpha(&dsc->tmp.img_dsc, dsc->tmp.xs_int + xn, dsc->tmp.ys_int);
+            a01 = lv_img_buf_get_px_alpha(&dsc->tmp.img_dsc, dsc->tmp.xs_int, dsc->tmp.ys_int + yn);
+            a11 = lv_img_buf_get_px_alpha(&dsc->tmp.img_dsc, dsc->tmp.xs_int + xn, dsc->tmp.ys_int + yn);
+        }
+    }
+
+    lv_opa_t xr0 = xr;
+    lv_opa_t xr1 = xr;
+    if(dsc->tmp.has_alpha) {
+        lv_opa_t a0 = (a00 * xr + (a10 * (255 - xr))) >> 8;
+        lv_opa_t a1 = (a01 * xr + (a11 * (255 - xr))) >> 8;
+        dsc->res.opa = (a0 * yr + (a1 * (255 - yr))) >> 8;
+
+        if(a0 <= LV_OPA_MIN && a1 <= LV_OPA_MIN) return false;
+        if(a0 <= LV_OPA_MIN) yr = LV_OPA_TRANSP;
+        if(a1 <= LV_OPA_MIN) yr = LV_OPA_COVER;
+        if(a00 <= LV_OPA_MIN) xr0 = LV_OPA_TRANSP;
+        if(a10 <= LV_OPA_MIN) xr0 = LV_OPA_COVER;
+        if(a01 <= LV_OPA_MIN) xr1 = LV_OPA_TRANSP;
+        if(a11 <= LV_OPA_MIN) xr1 = LV_OPA_COVER;
+    }
+    else {
+        xr0 = xr;
+        xr1 = xr;
+        dsc->res.opa = LV_OPA_COVER;
+    }
+
+    lv_color_t c0;
+    if(xr0 == LV_OPA_TRANSP) c0 = c01;
+    else if(xr0 == LV_OPA_COVER) c0 = c00;
+    else c0 = lv_color_mix(c00, c01, xr0);
+
+    lv_color_t c1;
+    if(xr1 == LV_OPA_TRANSP) c1 = c11;
+    else if(xr1 == LV_OPA_COVER) c1 = c10;
+    else c1 = lv_color_mix(c10, c11, xr1);
+
+    if(yr == LV_OPA_TRANSP) dsc->res.color = c1;
+    else if(yr == LV_OPA_COVER) dsc->res.color = c0;
+    else dsc->res.color = lv_color_mix(c0, c1, yr);
+
+    return true;
+}
+#endif
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+

src/lv_draw/lv_img_buf.h

@@ -0,0 +1,393 @@
+/**
+ * @file lv_img_buf.h
+ *
+ */
+
+#ifndef LV_IMG_BUF_H
+#define LV_IMG_BUF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include <stdbool.h>
+#include "../lv_misc/lv_color.h"
+#include "../lv_misc/lv_area.h"
+
+
+/*********************
+ *      DEFINES
+ *********************/
+/*If image pixels contains alpha we need to know how much byte is a pixel*/
+#if LV_COLOR_DEPTH == 1 || LV_COLOR_DEPTH == 8
+#define LV_IMG_PX_SIZE_ALPHA_BYTE 2
+#elif LV_COLOR_DEPTH == 16
+#define LV_IMG_PX_SIZE_ALPHA_BYTE 3
+#elif LV_COLOR_DEPTH == 32
+#define LV_IMG_PX_SIZE_ALPHA_BYTE 4
+#endif
+
+#define LV_IMG_BUF_SIZE_TRUE_COLOR(w, h) ((LV_COLOR_SIZE / 8) * w * h)
+#define LV_IMG_BUF_SIZE_TRUE_COLOR_CHROMA_KEYED(w, h) ((LV_COLOR_SIZE / 8) * w * h)
+#define LV_IMG_BUF_SIZE_TRUE_COLOR_ALPHA(w, h) (LV_IMG_PX_SIZE_ALPHA_BYTE * w * h)
+
+/*+ 1: to be sure no fractional row*/
+#define LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h) ((((w / 8) + 1) * h))
+#define LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h) ((((w / 4) + 1) * h))
+#define LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h) ((((w / 2) + 1) * h))
+#define LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h) ((w * h))
+
+/*4 * X: for palette*/
+#define LV_IMG_BUF_SIZE_INDEXED_1BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_1BIT(w, h) + 4 * 2)
+#define LV_IMG_BUF_SIZE_INDEXED_2BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_2BIT(w, h) + 4 * 4)
+#define LV_IMG_BUF_SIZE_INDEXED_4BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_4BIT(w, h) + 4 * 16)
+#define LV_IMG_BUF_SIZE_INDEXED_8BIT(w, h) (LV_IMG_BUF_SIZE_ALPHA_8BIT(w, h) + 4 * 256)
+
+#define LV_IMG_ZOOM_NONE   256
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/*Image color format*/
+enum {
+    LV_IMG_CF_UNKNOWN = 0,
+
+    LV_IMG_CF_RAW,              /**< Contains the file as it is. Needs custom decoder function*/
+    LV_IMG_CF_RAW_ALPHA,        /**< Contains the file as it is. The image has alpha. Needs custom decoder
+                                   function*/
+    LV_IMG_CF_RAW_CHROMA_KEYED, /**< Contains the file as it is. The image is chroma keyed. Needs
+                                   custom decoder function*/
+
+    LV_IMG_CF_TRUE_COLOR,              /**< Color format and depth should match with LV_COLOR settings*/
+    LV_IMG_CF_TRUE_COLOR_ALPHA,        /**< Same as `LV_IMG_CF_TRUE_COLOR` but every pixel has an alpha byte*/
+    LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED, /**< Same as `LV_IMG_CF_TRUE_COLOR` but LV_COLOR_TRANSP pixels
+                                          will be transparent*/
+
+    LV_IMG_CF_INDEXED_1BIT, /**< Can have 2 different colors in a palette (always chroma keyed)*/
+    LV_IMG_CF_INDEXED_2BIT, /**< Can have 4 different colors in a palette (always chroma keyed)*/
+    LV_IMG_CF_INDEXED_4BIT, /**< Can have 16 different colors in a palette (always chroma keyed)*/
+    LV_IMG_CF_INDEXED_8BIT, /**< Can have 256 different colors in a palette (always chroma keyed)*/
+
+    LV_IMG_CF_ALPHA_1BIT, /**< Can have one color and it can be drawn or not*/
+    LV_IMG_CF_ALPHA_2BIT, /**< Can have one color but 4 different alpha value*/
+    LV_IMG_CF_ALPHA_4BIT, /**< Can have one color but 16 different alpha value*/
+    LV_IMG_CF_ALPHA_8BIT, /**< Can have one color but 256 different alpha value*/
+
+    LV_IMG_CF_RESERVED_15,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_16,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_17,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_18,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_19,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_20,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_21,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_22,              /**< Reserved for further use. */
+    LV_IMG_CF_RESERVED_23,              /**< Reserved for further use. */
+
+    LV_IMG_CF_USER_ENCODED_0,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_1,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_2,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_3,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_4,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_5,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_6,          /**< User holder encoding format. */
+    LV_IMG_CF_USER_ENCODED_7,          /**< User holder encoding format. */
+};
+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 {
+
+    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*/
+
+    uint32_t reserved : 2; /*Reserved to be used later*/
+
+    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*/
+typedef struct {
+    lv_img_header_t header;
+    uint32_t data_size;
+    const uint8_t * data;
+} lv_img_dsc_t;
+
+typedef struct {
+    struct {
+        const void * src;           /*image source (array of pixels)*/
+        lv_coord_t src_w;           /*width of the image source*/
+        lv_coord_t src_h;           /*height of the image source*/
+        lv_coord_t pivot_x;         /*pivot x*/
+        lv_coord_t pivot_y;         /* pivot y*/
+        int16_t angle;              /*angle to rotate*/
+        uint16_t zoom;              /*256 no zoom, 128 half size, 512 double size*/
+        lv_color_t color;           /*a color used for `LV_IMG_CF_INDEXED_1/2/4/8BIT` color formats*/
+        lv_img_cf_t cf;             /*color format of the image to rotate*/
+        bool antialias;
+    } cfg;
+
+    struct {
+        lv_color_t color;
+        lv_opa_t opa;
+    } res;
+
+
+    struct {
+        lv_img_dsc_t img_dsc;
+        int32_t pivot_x_256;
+        int32_t pivot_y_256;
+        int32_t sinma;
+        int32_t cosma;
+
+        uint8_t chroma_keyed : 1;
+        uint8_t has_alpha : 1;
+        uint8_t native_color : 1;
+
+        uint16_t zoom_inv;
+
+        /*Runtime data*/
+        lv_coord_t xs;
+        lv_coord_t ys;
+        lv_coord_t xs_int;
+        lv_coord_t ys_int;
+        uint32_t pxi;
+        uint8_t px_size;
+    } tmp;
+} lv_img_transform_dsc_t;
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**
+ * Allocate an image buffer in RAM
+ * @param w width of image
+ * @param h height of image
+ * @param cf a color format (`LV_IMG_CF_...`)
+ * @return an allocated image, or NULL on failure
+ */
+lv_img_dsc_t * lv_img_buf_alloc(lv_coord_t w, lv_coord_t h, lv_img_cf_t cf);
+
+/**
+ * Get the color of an image's pixel
+ * @param dsc an image descriptor
+ * @param x x coordinate of the point to get
+ * @param y x coordinate of the point to get
+ * @param color the color of the image. In case of `LV_IMG_CF_ALPHA_1/2/4/8` this color is used.
+ * Not used in other cases.
+ * @param safe true: check out of bounds
+ * @return color of the point
+ */
+lv_color_t lv_img_buf_get_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_color_t color);
+
+/**
+ * Get the alpha value of an image's pixel
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param safe true: check out of bounds
+ * @return alpha value of the point
+ */
+lv_opa_t lv_img_buf_get_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y);
+
+/**
+ * Set the color of a pixel of an image. The alpha channel won't be affected.
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param c color of the point
+ * @param safe true: check out of bounds
+ */
+void lv_img_buf_set_px_color(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_color_t c);
+
+/**
+ * Set the alpha value of a pixel of an image. The color won't be affected
+ * @param dsc pointer to an image descriptor
+ * @param x x coordinate of the point to set
+ * @param y x coordinate of the point to set
+ * @param opa the desired opacity
+ * @param safe true: check out of bounds
+ */
+void lv_img_buf_set_px_alpha(lv_img_dsc_t * dsc, lv_coord_t x, lv_coord_t y, lv_opa_t opa);
+
+/**
+ * Set the palette color of an indexed image. Valid only for `LV_IMG_CF_INDEXED1/2/4/8`
+ * @param dsc pointer to an image descriptor
+ * @param id the palette color to set:
+ *   - for `LV_IMG_CF_INDEXED1`: 0..1
+ *   - for `LV_IMG_CF_INDEXED2`: 0..3
+ *   - for `LV_IMG_CF_INDEXED4`: 0..15
+ *   - for `LV_IMG_CF_INDEXED8`: 0..255
+ * @param c the color to set
+ */
+void lv_img_buf_set_palette(lv_img_dsc_t * dsc, uint8_t id, lv_color_t c);
+
+/**
+ * Free an allocated image buffer
+ * @param dsc image buffer to free
+ */
+void lv_img_buf_free(lv_img_dsc_t * dsc);
+
+/**
+ * Get the memory consumption of a raw bitmap, given color format and dimensions.
+ * @param w width
+ * @param h height
+ * @param cf color format
+ * @return size in bytes
+ */
+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 rotate 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);
+
+/**
+ * Continue transformation by taking the neighbors into account
+ * @param dsc pointer to the transformation descriptor
+ */
+bool _lv_img_buf_transform_anti_alias(lv_img_transform_dsc_t * dsc);
+
+
+/**
+ * Get which color and opa would come to a pixel if it were rotated
+ * @param dsc a descriptor initialized by `lv_img_buf_rotate_init`
+ * @param x the coordinate which color and opa should be get
+ * @param y the coordinate which color and opa should be get
+ * @return true: there is valid pixel on these x/y coordinates; false: the rotated pixel was out of the image
+ * @note the result is written back to `dsc->res_color` and `dsc->res_opa`
+ */
+static inline bool _lv_img_buf_transform(lv_img_transform_dsc_t * dsc, lv_coord_t x, lv_coord_t y)
+{
+    const uint8_t * src_u8 = (const uint8_t *)dsc->cfg.src;
+
+    /*Get the target point relative coordinates to the pivot*/
+    int32_t xt = x - dsc->cfg.pivot_x;
+    int32_t yt = y - dsc->cfg.pivot_y;
+
+    int32_t xs;
+    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;
+    }
+    else if(dsc->cfg.angle == 0) {
+        xt *= dsc->tmp.zoom_inv;
+        yt *= dsc->tmp.zoom_inv;
+        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;
+    }
+
+    /*Get the integer part of the source pixel*/
+    int32_t xs_int = xs >> 8;
+    int32_t ys_int = ys >> 8;
+
+    if(xs_int >= dsc->cfg.src_w) return false;
+    else if(xs_int < 0) return false;
+
+    if(ys_int >= dsc->cfg.src_h) return false;
+    else if(ys_int < 0) return false;
+
+    uint8_t px_size;
+    uint32_t pxi;
+    if(dsc->tmp.native_color) {
+        if(dsc->tmp.has_alpha == 0) {
+            px_size = LV_COLOR_SIZE >> 3;
+
+            pxi     = dsc->cfg.src_w * ys_int * px_size + xs_int * px_size;
+            _lv_memcpy_small(&dsc->res.color, &src_u8[pxi], px_size);
+        }
+        else {
+            px_size = LV_IMG_PX_SIZE_ALPHA_BYTE;
+            pxi     = dsc->cfg.src_w * ys_int * px_size + xs_int * px_size;
+            _lv_memcpy_small(&dsc->res.color, &src_u8[pxi], px_size - 1);
+            dsc->res.opa = src_u8[pxi + px_size - 1];
+        }
+    }
+    else {
+        pxi = 0; /*unused*/
+        px_size = 0;    /*unused*/
+        dsc->res.color = lv_img_buf_get_px_color(&dsc->tmp.img_dsc, xs_int, ys_int, dsc->cfg.color);
+        dsc->res.opa = lv_img_buf_get_px_alpha(&dsc->tmp.img_dsc, xs_int, ys_int);
+    }
+
+    if(dsc->tmp.chroma_keyed) {
+        lv_color_t ct = LV_COLOR_TRANSP;
+        if(dsc->res.color.full == ct.full) return false;
+    }
+
+    if(dsc->cfg.antialias == false) return true;
+
+    dsc->tmp.xs = xs;
+    dsc->tmp.ys = ys;
+    dsc->tmp.xs_int = xs_int;
+    dsc->tmp.ys_int = ys_int;
+    dsc->tmp.pxi = pxi;
+    dsc->tmp.px_size = px_size;
+
+    bool ret;
+    ret = _lv_img_buf_transform_anti_alias(dsc);
+
+    return ret;
+}
+#endif
+/**
+ * Get the area of a rectangle if its rotated and scaled
+ * @param res store the coordinates here
+ * @param w width of the rectangle to transform
+ * @param h height of the rectangle to transform
+ * @param angle angle of rotation
+ * @param zoom zoom, (256 no zoom)
+ * @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);
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_IMG_BUF_H*/

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"
@@ -14,7 +14,7 @@
 #include "../lv_misc/lv_gc.h"
 
 #if defined(LV_GC_INCLUDE)
-#include LV_GC_INCLUDE
+    #include LV_GC_INCLUDE
 #endif /* LV_ENABLE_GC */
 /*********************
  *      DEFINES
@@ -30,7 +30,7 @@
 #define LV_IMG_CACHE_LIFE_LIMIT 1000
 
 #if LV_IMG_CACHE_DEF_SIZE < 1
-#error "LV_IMG_CACHE_DEF_SIZE must be >= 1. See lv_conf.h"
+    #error "LV_IMG_CACHE_DEF_SIZE must be >= 1. See lv_conf.h"
 #endif
 
 /**********************
@@ -62,7 +62,7 @@ static uint16_t entry_cnt;
  * @param style style of the image
  * @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, const lv_style_t * style)
+lv_img_cache_entry_t * _lv_img_cache_open(const void * src, lv_color_t color)
 {
     if(entry_cnt == 0) {
         LV_LOG_WARN("lv_img_cache_open: the cache size is 0");
@@ -85,8 +85,9 @@ lv_img_cache_entry_t * lv_img_cache_open(const void * src, const lv_style_t * st
         bool match = false;
         lv_img_src_t src_type = lv_img_src_get_type(cache[i].dec_dsc.src);
         if(src_type == LV_IMG_SRC_VARIABLE) {
-            if(cache[i].dec_dsc.src == src && cache[i].dec_dsc.style == style) match = true;
-        } else if(src_type == LV_IMG_SRC_FILE) {
+            if(cache[i].dec_dsc.src == src && cache[i].dec_dsc.color.full == color.full) match = true;
+        }
+        else if(src_type == LV_IMG_SRC_FILE) {
             if(strcmp(cache[i].dec_dsc.src, src) == 0) match = true;
         }
 
@@ -116,7 +117,8 @@ lv_img_cache_entry_t * lv_img_cache_open(const void * src, const lv_style_t * st
         if(cached_src->dec_dsc.src) {
             lv_img_decoder_close(&cached_src->dec_dsc);
             LV_LOG_INFO("image draw: cache miss, close and reuse an entry");
-        } else {
+        }
+        else {
             LV_LOG_INFO("image draw: cache miss, cached to an empty entry");
         }
 
@@ -124,12 +126,12 @@ lv_img_cache_entry_t * lv_img_cache_open(const void * src, const lv_style_t * st
         uint32_t t_start;
         t_start                          = lv_tick_get();
         cached_src->dec_dsc.time_to_open = 0;
-        lv_res_t open_res                = lv_img_decoder_open(&cached_src->dec_dsc, src, style);
+        lv_res_t open_res                = lv_img_decoder_open(&cached_src->dec_dsc, src, color);
         if(open_res == LV_RES_INV) {
             LV_LOG_WARN("Image draw cannot open the image resource");
             lv_img_decoder_close(&cached_src->dec_dsc);
-            memset(&cached_src->dec_dsc, 0, sizeof(lv_img_decoder_dsc_t));
-            memset(cached_src, 0, sizeof(lv_img_cache_entry_t));
+            _lv_memset_00(&cached_src->dec_dsc, sizeof(lv_img_decoder_dsc_t));
+            _lv_memset_00(cached_src, sizeof(lv_img_cache_entry_t));
             cached_src->life = INT32_MIN; /*Make the empty entry very "weak" to force its use  */
             return NULL;
         }
@@ -173,8 +175,8 @@ void lv_img_cache_set_size(uint16_t new_entry_cnt)
     /*Clean the cache*/
     uint16_t i;
     for(i = 0; i < entry_cnt; i++) {
-        memset(&LV_GC_ROOT(_lv_img_cache_array)[i].dec_dsc, 0, sizeof(lv_img_decoder_dsc_t));
-        memset(&LV_GC_ROOT(_lv_img_cache_array)[i], 0, sizeof(lv_img_cache_entry_t));
+        _lv_memset_00(&LV_GC_ROOT(_lv_img_cache_array)[i].dec_dsc, sizeof(lv_img_decoder_dsc_t));
+        _lv_memset_00(&LV_GC_ROOT(_lv_img_cache_array)[i], sizeof(lv_img_cache_entry_t));
     }
 }
 
@@ -195,8 +197,8 @@ void lv_img_cache_invalidate_src(const void * src)
                 lv_img_decoder_close(&cache[i].dec_dsc);
             }
 
-            memset(&cache[i].dec_dsc, 0, sizeof(lv_img_decoder_dsc_t));
-            memset(&cache[i], 0, sizeof(lv_img_cache_entry_t));
+            _lv_memset_00(&cache[i].dec_dsc, sizeof(lv_img_decoder_dsc_t));
+            _lv_memset_00(&cache[i], sizeof(lv_img_cache_entry_t));
         }
     }
 }

src/lv_draw/lv_img_cache.h

@@ -28,8 +28,7 @@ extern "C" {
  *
  * To avoid repeating this heavy load images can be cached.
  */
-typedef struct
-{
+typedef struct {
     lv_img_decoder_dsc_t dec_dsc; /**< Image information */
 
     /** Count the cache entries's life. Add `time_tio_open` to `life` when the entry is used.
@@ -50,7 +49,7 @@ typedef struct
  * @param style style of the image
  * @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, const lv_style_t * style);
+lv_img_cache_entry_t * _lv_img_cache_open(const void * src, lv_color_t color);
 
 /**
  * Set the number of images to be cached.

src/lv_draw/lv_img_decoder.c

@@ -7,14 +7,14 @@
  *      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"
 #include "../lv_misc/lv_gc.h"
 
 #if defined(LV_GC_INCLUDE)
-#include LV_GC_INCLUDE
+    #include LV_GC_INCLUDE
 #endif /* LV_ENABLE_GC */
 
 /*********************
@@ -26,8 +26,7 @@
 /**********************
  *      TYPEDEFS
  **********************/
-typedef struct
-{
+typedef struct {
 #if LV_USE_FILESYSTEM
     lv_fs_file_t * f;
 #endif
@@ -60,9 +59,9 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
 /**
  * Initialize the image decoder module
  * */
-void lv_img_decoder_init(void)
+void _lv_img_decoder_init(void)
 {
-    lv_ll_init(&LV_GC_ROOT(_lv_img_defoder_ll), sizeof(lv_img_decoder_t));
+    _lv_ll_init(&LV_GC_ROOT(_lv_img_defoder_ll), sizeof(lv_img_decoder_t));
 
     lv_img_decoder_t * decoder;
 
@@ -93,8 +92,7 @@ lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
 
     lv_res_t res = LV_RES_INV;
     lv_img_decoder_t * d;
-    LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d)
-    {
+    _LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d) {
         res = LV_RES_INV;
         if(d->info_cb) {
             res = d->info_cb(d, src, header);
@@ -117,9 +115,9 @@ lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header)
  * @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.
  */
-lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const lv_style_t * style)
+lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_color_t color)
 {
-    dsc->style     = style;
+    dsc->color     = color;
     dsc->src_type  = lv_img_src_get_type(src);
     dsc->user_data = NULL;
 
@@ -127,15 +125,15 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const
         size_t fnlen = strlen(src);
         dsc->src = lv_mem_alloc(fnlen + 1);
         strcpy((char *)dsc->src, src);
-    } else {
+    }
+    else {
         dsc->src       = src;
     }
 
     lv_res_t res = LV_RES_INV;
 
     lv_img_decoder_t * d;
-    LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d)
-    {
+    _LV_LL_READ(LV_GC_ROOT(_lv_img_defoder_ll), d) {
         /*Info an Open callbacks are required*/
         if(d->info_cb == NULL || d->open_cb == NULL) continue;
 
@@ -153,7 +151,7 @@ lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const
     }
 
     if(res == LV_RES_INV) {
-        memset(dsc, 0, sizeof(lv_img_decoder_dsc_t));
+        _lv_memset_00(dsc, sizeof(lv_img_decoder_dsc_t));
     }
 
     return res;
@@ -199,11 +197,11 @@ void lv_img_decoder_close(lv_img_decoder_dsc_t * dsc)
 lv_img_decoder_t * lv_img_decoder_create(void)
 {
     lv_img_decoder_t * decoder;
-    decoder = lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll));
+    decoder = _lv_ll_ins_head(&LV_GC_ROOT(_lv_img_defoder_ll));
     LV_ASSERT_MEM(decoder);
     if(decoder == NULL) return NULL;
 
-    memset(decoder, 0, sizeof(lv_img_decoder_t));
+    _lv_memset_00(decoder, sizeof(lv_img_decoder_t));
 
     return decoder;
 }
@@ -214,7 +212,7 @@ lv_img_decoder_t * lv_img_decoder_create(void)
  */
 void lv_img_decoder_delete(lv_img_decoder_t * decoder)
 {
-    lv_ll_rem(&LV_GC_ROOT(_lv_img_defoder_ll), decoder);
+    _lv_ll_remove(&LV_GC_ROOT(_lv_img_defoder_ll), decoder);
     lv_mem_free(decoder);
 }
 
@@ -287,6 +285,10 @@ lv_res_t lv_img_decoder_built_in_info(lv_img_decoder_t * decoder, const void * s
         if(res == LV_FS_RES_OK) {
             res = lv_fs_read(&file, header, sizeof(lv_img_header_t), &rn);
             lv_fs_close(&file);
+            if(res != LV_FS_RES_OK || rn != sizeof(lv_img_header_t)) {
+                LV_LOG_WARN("Image get info get read file header");
+                return LV_RES_INV;
+            }
         }
 
         if(header->cf < CF_BUILT_IN_FIRST || header->cf > CF_BUILT_IN_LAST) return LV_RES_INV;
@@ -301,7 +303,8 @@ lv_res_t lv_img_decoder_built_in_info(lv_img_decoder_t * decoder, const void * s
         /* Symbols always have transparent parts. Important because of cover check in the design
          * function. The actual value doesn't matter because lv_draw_label will draw it*/
         header->cf = LV_IMG_CF_ALPHA_1BIT;
-    } else {
+    }
+    else {
         LV_LOG_WARN("Image get info found unknown src type");
         return LV_RES_INV;
     }
@@ -333,27 +336,36 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
         /*If the file was open successfully save the file descriptor*/
         if(dsc->user_data == NULL) {
             dsc->user_data = lv_mem_alloc(sizeof(lv_img_decoder_built_in_data_t));
+            LV_ASSERT_MEM(dsc->user_data);
             if(dsc->user_data == NULL) {
                 LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
-                LV_ASSERT_MEM(dsc->user_data);
+                return LV_RES_INV;
             }
-            memset(dsc->user_data, 0, sizeof(lv_img_decoder_built_in_data_t));
+            _lv_memset_00(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t));
         }
 
         lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
-        user_data->f                               = lv_mem_alloc(sizeof(f));
+        user_data->f = lv_mem_alloc(sizeof(f));
+        LV_ASSERT_MEM(user_data->f);
         if(user_data->f == NULL) {
             LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
-            LV_ASSERT_MEM(user_data->f);
+            lv_img_decoder_built_in_close(decoder, dsc);
+            return LV_RES_INV;
         }
 
-        memcpy(user_data->f, &f, sizeof(f));
+        _lv_memcpy_small(user_data->f, &f, sizeof(f));
 
 #else
         LV_LOG_WARN("Image built-in decoder cannot read file because LV_USE_FILESYSTEM = 0");
         return LV_RES_INV;
 #endif
     }
+    else if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
+        /*The variables should have valid data*/
+        if(((lv_img_dsc_t *)dsc->src)->data == NULL) {
+            return LV_RES_INV;
+        }
+    }
 
     lv_img_cf_t cf = dsc->header.cf;
     /*Process true color formats*/
@@ -363,7 +375,8 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
              * So simply give its pointer*/
             dsc->img_data = ((lv_img_dsc_t *)dsc->src)->data;
             return LV_RES_OK;
-        } else {
+        }
+        else {
             /*If it's a file it need to be read line by line later*/
             dsc->img_data = NULL;
             return LV_RES_OK;
@@ -374,27 +387,30 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
             cf == LV_IMG_CF_INDEXED_8BIT) {
 
 #if LV_IMG_CF_INDEXED
-        uint8_t px_size       = lv_img_color_format_get_px_size(cf);
+        uint8_t px_size       = lv_img_cf_get_px_size(cf);
         uint32_t palette_size = 1 << px_size;
 
         /*Allocate the palette*/
         if(dsc->user_data == NULL) {
             dsc->user_data = lv_mem_alloc(sizeof(lv_img_decoder_built_in_data_t));
+            LV_ASSERT_MEM(dsc->user_data);
             if(dsc->user_data == NULL) {
                 LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
-                LV_ASSERT_MEM(dsc->user_data);
+                lv_img_decoder_built_in_close(decoder, dsc);
+                return LV_RES_INV;
             }
-            memset(dsc->user_data, 0, sizeof(lv_img_decoder_built_in_data_t));
+            _lv_memset_00(dsc->user_data, sizeof(lv_img_decoder_built_in_data_t));
         }
 
         lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
         user_data->palette                         = lv_mem_alloc(palette_size * sizeof(lv_color_t));
+        LV_ASSERT_MEM(user_data->palette);
         user_data->opa                             = lv_mem_alloc(palette_size * sizeof(lv_opa_t));
+        LV_ASSERT_MEM(user_data->opa);
         if(user_data->palette == NULL || user_data->opa == NULL) {
             LV_LOG_ERROR("img_decoder_built_in_open: out of memory");
-
-            LV_ASSERT_MEM(user_data->palette);
-            LV_ASSERT_MEM(user_data->opa);
+            lv_img_decoder_built_in_close(decoder, dsc);
+            return LV_RES_INV;
         }
 
         if(dsc->src_type == LV_IMG_SRC_FILE) {
@@ -412,10 +428,12 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
             LV_LOG_WARN("Image built-in decoder can read the palette because LV_USE_FILESYSTEM = 0");
             return LV_RES_INV;
 #endif
-        } else {
+        }
+        else {
             /*The palette begins in the beginning of the image data. Just point to it.*/
             lv_color32_t * palette_p = (lv_color32_t *)((lv_img_dsc_t *)dsc->src)->data;
 
+
             uint32_t i;
             for(i = 0; i < palette_size; i++) {
                 user_data->palette[i] = lv_color_make(palette_p[i].ch.red, palette_p[i].ch.green, palette_p[i].ch.blue);
@@ -463,7 +481,7 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
  * @return LV_RES_OK: ok; LV_RES_INV: failed
  */
 lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc, lv_coord_t x,
-                                                  lv_coord_t y, lv_coord_t len, uint8_t * buf)
+                                           lv_coord_t y, lv_coord_t len, uint8_t * buf)
 {
     (void)decoder; /*Unused*/
 
@@ -476,14 +494,17 @@ lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_de
         if(dsc->src_type == LV_IMG_SRC_FILE) {
             res = lv_img_decoder_built_in_line_true_color(dsc, x, y, len, buf);
         }
-    } else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT || dsc->header.cf == LV_IMG_CF_ALPHA_2BIT ||
-              dsc->header.cf == LV_IMG_CF_ALPHA_4BIT || dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
+    }
+    else if(dsc->header.cf == LV_IMG_CF_ALPHA_1BIT || dsc->header.cf == LV_IMG_CF_ALPHA_2BIT ||
+            dsc->header.cf == LV_IMG_CF_ALPHA_4BIT || dsc->header.cf == LV_IMG_CF_ALPHA_8BIT) {
 
         res = lv_img_decoder_built_in_line_alpha(dsc, x, y, len, buf);
-    } else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT || dsc->header.cf == LV_IMG_CF_INDEXED_2BIT ||
-              dsc->header.cf == LV_IMG_CF_INDEXED_4BIT || dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
+    }
+    else if(dsc->header.cf == LV_IMG_CF_INDEXED_1BIT || dsc->header.cf == LV_IMG_CF_INDEXED_2BIT ||
+            dsc->header.cf == LV_IMG_CF_INDEXED_4BIT || dsc->header.cf == LV_IMG_CF_INDEXED_8BIT) {
         res = lv_img_decoder_built_in_line_indexed(dsc, x, y, len, buf);
-    } else {
+    }
+    else {
         LV_LOG_WARN("Built-in image decoder read not supports the color format");
         return LV_RES_INV;
     }
@@ -528,7 +549,7 @@ static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * d
 #if LV_USE_FILESYSTEM
     lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
     lv_fs_res_t res;
-    uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf);
+    uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf);
 
     uint32_t pos = ((y * dsc->header.w + x) * px_size) >> 3;
     pos += 4; /*Skip the header*/
@@ -547,6 +568,11 @@ static lv_res_t lv_img_decoder_built_in_line_true_color(lv_img_decoder_dsc_t * d
 
     return LV_RES_OK;
 #else
+    LV_UNUSED(dsc);
+    LV_UNUSED(x);
+    LV_UNUSED(y);
+    LV_UNUSED(len);
+    LV_UNUSED(buf);
     LV_LOG_WARN("Image built-in decoder cannot read file because LV_USE_FILESYSTEM = 0");
     return LV_RES_INV;
 #endif
@@ -560,10 +586,11 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
     const lv_opa_t alpha1_opa_table[2]  = {0, 255};          /*Opacity mapping with bpp = 1 (Just for compatibility)*/
     const lv_opa_t alpha2_opa_table[4]  = {0, 85, 170, 255}; /*Opacity mapping with bpp = 2*/
     const lv_opa_t alpha4_opa_table[16] = {0,  17, 34,  51,  /*Opacity mapping with bpp = 4*/
-                                           68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
+                                           68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255
+                                          };
 
     /*Simply fill the buffer with the color. Later only the alpha value will be modified.*/
-    lv_color_t bg_color = dsc->style->image.color;
+    lv_color_t bg_color = dsc->color;
     lv_coord_t i;
     for(i = 0; i < len; i++) {
 #if LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
@@ -580,7 +607,7 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
     }
 
     const lv_opa_t * opa_table = NULL;
-    uint8_t px_size            = lv_img_color_format_get_px_size(dsc->header.cf);
+    uint8_t px_size            = lv_img_cf_get_px_size(dsc->header.cf);
     uint16_t mask              = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/
 
     lv_coord_t w = 0;
@@ -617,7 +644,7 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
 
 #if LV_USE_FILESYSTEM
     lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
-    uint8_t fs_buf[LV_HOR_RES_MAX];
+    uint8_t * fs_buf = _lv_mem_buf_get(w);
 #endif
 
     const uint8_t * data_tmp = NULL;
@@ -625,7 +652,8 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
         const lv_img_dsc_t * img_dsc = dsc->src;
 
         data_tmp = img_dsc->data + ofs;
-    } else {
+    }
+    else {
 #if LV_USE_FILESYSTEM
         lv_fs_seek(user_data->f, ofs + 4); /*+4 to skip the header*/
         lv_fs_read(user_data->f, fs_buf, w, NULL);
@@ -637,10 +665,8 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
 #endif
     }
 
-    uint8_t byte_act = 0;
-    uint8_t val_act;
     for(i = 0; i < len; i++) {
-        val_act = (data_tmp[byte_act] & (mask << pos)) >> pos;
+        uint8_t val_act = (*data_tmp & (mask << pos)) >> pos;
 
         buf[i * LV_IMG_PX_SIZE_ALPHA_BYTE + LV_IMG_PX_SIZE_ALPHA_BYTE - 1] =
             dsc->header.cf == LV_IMG_CF_ALPHA_8BIT ? val_act : opa_table[val_act];
@@ -651,7 +677,9 @@ static lv_res_t lv_img_decoder_built_in_line_alpha(lv_img_decoder_dsc_t * dsc, l
             data_tmp++;
         }
     }
-
+#if LV_USE_FILESYSTEM
+    _lv_mem_buf_release(fs_buf);
+#endif
     return LV_RES_OK;
 
 #else
@@ -665,7 +693,7 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
 {
 
 #if LV_IMG_CF_INDEXED
-    uint8_t px_size = lv_img_color_format_get_px_size(dsc->header.cf);
+    uint8_t px_size = lv_img_cf_get_px_size(dsc->header.cf);
     uint16_t mask   = (1 << px_size) - 1; /*E.g. px_size = 2; mask = 0x03*/
 
     lv_coord_t w = 0;
@@ -704,13 +732,14 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
     lv_img_decoder_built_in_data_t * user_data = dsc->user_data;
 
 #if LV_USE_FILESYSTEM
-    uint8_t fs_buf[LV_HOR_RES_MAX];
+    uint8_t * fs_buf = _lv_mem_buf_get(w);
 #endif
     const uint8_t * data_tmp = NULL;
     if(dsc->src_type == LV_IMG_SRC_VARIABLE) {
         const lv_img_dsc_t * img_dsc = dsc->src;
         data_tmp                     = img_dsc->data + ofs;
-    } else {
+    }
+    else {
 #if LV_USE_FILESYSTEM
         lv_fs_seek(user_data->f, ofs + 4); /*+4 to skip the header*/
         lv_fs_read(user_data->f, fs_buf, w, NULL);
@@ -722,10 +751,9 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
 #endif
     }
 
-    uint8_t val_act;
     lv_coord_t i;
     for(i = 0; i < len; i++) {
-        val_act = (*data_tmp & (mask << pos)) >> pos;
+        uint8_t val_act = (*data_tmp & (mask << pos)) >> pos;
 
         lv_color_t color = user_data->palette[val_act];
 #if LV_COLOR_DEPTH == 8 || LV_COLOR_DEPTH == 1
@@ -747,7 +775,9 @@ static lv_res_t lv_img_decoder_built_in_line_indexed(lv_img_decoder_dsc_t * dsc,
             data_tmp++;
         }
     }
-
+#if LV_USE_FILESYSTEM
+    _lv_mem_buf_release(fs_buf);
+#endif
     return LV_RES_OK;
 #else
     LV_LOG_WARN("Image built-in indexed line reader failed because LV_IMG_CF_INDEXED is 0 in lv_conf.h");

src/lv_draw/lv_img_decoder.h

@@ -13,13 +13,10 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#ifdef LV_CONF_INCLUDE_SIMPLE
-#include "lv_conf.h"
-#else
-#include "../../../lv_conf.h"
-#endif
+#include "../lv_conf_internal.h"
 
 #include <stdint.h>
+#include "lv_img_buf.h"
 #include "../lv_misc/lv_fs.h"
 #include "../lv_misc/lv_types.h"
 #include "../lv_misc/lv_area.h"
@@ -28,14 +25,6 @@ extern "C" {
 /*********************
  *      DEFINES
  *********************/
-/*If image pixels contains alpha we need to know how much byte is a pixel*/
-#if LV_COLOR_DEPTH == 1 || LV_COLOR_DEPTH == 8
-#define LV_IMG_PX_SIZE_ALPHA_BYTE 2
-#elif LV_COLOR_DEPTH == 16
-#define LV_IMG_PX_SIZE_ALPHA_BYTE 3
-#elif LV_COLOR_DEPTH == 32
-#define LV_IMG_PX_SIZE_ALPHA_BYTE 4
-#endif
 
 /**********************
  *      TYPEDEFS
@@ -51,78 +40,6 @@ enum {
 };
 
 typedef uint8_t lv_img_src_t;
-/**
- * LittlevGL image header
- */
-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*/
-
-    uint32_t reserved : 2; /*Reserved to be used later*/
-
-    uint32_t w : 11; /*Width of the image map*/
-    uint32_t h : 11; /*Height of the image map*/
-} lv_img_header_t;
-
-/*Image color format*/
-enum {
-    LV_IMG_CF_UNKNOWN = 0,
-
-    LV_IMG_CF_RAW,              /**< Contains the file as it is. Needs custom decoder function*/
-    LV_IMG_CF_RAW_ALPHA,        /**< Contains the file as it is. The image has alpha. Needs custom decoder
-                                   function*/
-    LV_IMG_CF_RAW_CHROMA_KEYED, /**< Contains the file as it is. The image is chroma keyed. Needs
-                                   custom decoder function*/
-
-    LV_IMG_CF_TRUE_COLOR,              /**< Color format and depth should match with LV_COLOR settings*/
-    LV_IMG_CF_TRUE_COLOR_ALPHA,        /**< Same as `LV_IMG_CF_TRUE_COLOR` but every pixel has an alpha byte*/
-    LV_IMG_CF_TRUE_COLOR_CHROMA_KEYED, /**< Same as `LV_IMG_CF_TRUE_COLOR` but LV_COLOR_TRANSP pixels
-                                          will be transparent*/
-
-    LV_IMG_CF_INDEXED_1BIT, /**< Can have 2 different colors in a palette (always chroma keyed)*/
-    LV_IMG_CF_INDEXED_2BIT, /**< Can have 4 different colors in a palette (always chroma keyed)*/
-    LV_IMG_CF_INDEXED_4BIT, /**< Can have 16 different colors in a palette (always chroma keyed)*/
-    LV_IMG_CF_INDEXED_8BIT, /**< Can have 256 different colors in a palette (always chroma keyed)*/
-
-    LV_IMG_CF_ALPHA_1BIT, /**< Can have one color and it can be drawn or not*/
-    LV_IMG_CF_ALPHA_2BIT, /**< Can have one color but 4 different alpha value*/
-    LV_IMG_CF_ALPHA_4BIT, /**< Can have one color but 16 different alpha value*/
-    LV_IMG_CF_ALPHA_8BIT, /**< Can have one color but 256 different alpha value*/
-
-    LV_IMG_CF_RESERVED_15,              /**< Reserved for further use. */
-    LV_IMG_CF_RESERVED_16,              /**< Reserved for further use. */
-    LV_IMG_CF_RESERVED_17,              /**< Reserved for further use. */
-    LV_IMG_CF_RESERVED_18,              /**< Reserved for further use. */
-    LV_IMG_CF_RESERVED_19,              /**< Reserved for further use. */
-    LV_IMG_CF_RESERVED_20,              /**< Reserved for further use. */
-    LV_IMG_CF_RESERVED_21,              /**< Reserved for further use. */
-    LV_IMG_CF_RESERVED_22,              /**< Reserved for further use. */
-    LV_IMG_CF_RESERVED_23,              /**< Reserved for further use. */
-
-    LV_IMG_CF_USER_ENCODED_0,          /**< User holder encoding format. */
-    LV_IMG_CF_USER_ENCODED_1,          /**< User holder encoding format. */
-    LV_IMG_CF_USER_ENCODED_2,          /**< User holder encoding format. */
-    LV_IMG_CF_USER_ENCODED_3,          /**< User holder encoding format. */
-    LV_IMG_CF_USER_ENCODED_4,          /**< User holder encoding format. */
-    LV_IMG_CF_USER_ENCODED_5,          /**< User holder encoding format. */
-    LV_IMG_CF_USER_ENCODED_6,          /**< User holder encoding format. */
-    LV_IMG_CF_USER_ENCODED_7,          /**< User holder encoding format. */
-};
-typedef uint8_t lv_img_cf_t;
-
-/** Image header it is compatible with
- * the result from image converter utility*/
-typedef struct
-{
-    lv_img_header_t header;
-    uint32_t data_size;
-    const uint8_t * data;
-} lv_img_dsc_t;
 
 /* Decoder function definitions */
 
@@ -167,8 +84,7 @@ typedef lv_res_t (*lv_img_decoder_read_line_f_t)(struct _lv_img_decoder * decode
  */
 typedef void (*lv_img_decoder_close_f_t)(struct _lv_img_decoder * decoder, struct _lv_img_decoder_dsc * dsc);
 
-typedef struct _lv_img_decoder
-{
+typedef struct _lv_img_decoder {
     lv_img_decoder_info_f_t info_cb;
     lv_img_decoder_open_f_t open_cb;
     lv_img_decoder_read_line_f_t read_line_cb;
@@ -180,8 +96,7 @@ typedef struct _lv_img_decoder
 } lv_img_decoder_t;
 
 /**Describe an image decoding session. Stores data about the decoding*/
-typedef struct _lv_img_decoder_dsc
-{
+typedef struct _lv_img_decoder_dsc {
     /**The decoder which was able to open the image source*/
     lv_img_decoder_t * decoder;
 
@@ -189,7 +104,7 @@ typedef struct _lv_img_decoder_dsc
     const void * src;
 
     /**Style to draw the image.*/
-    const lv_style_t * style;
+    lv_color_t color;
 
     /**Type of the source: file or variable. Can be set in `open` function if required*/
     lv_img_src_t src_type;
@@ -220,7 +135,7 @@ typedef struct _lv_img_decoder_dsc
 /**
  * Initialize the image decoder module
  */
-void lv_img_decoder_init(void);
+void _lv_img_decoder_init(void);
 
 /**
  * Get information about an image.
@@ -246,7 +161,7 @@ lv_res_t lv_img_decoder_get_info(const char * src, lv_img_header_t * header);
  * @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.
  */
-lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, const lv_style_t * style);
+lv_res_t lv_img_decoder_open(lv_img_decoder_dsc_t * dsc, const void * src, lv_color_t color);
 
 /**
  * Read a line from an opened image
@@ -306,8 +221,6 @@ void lv_img_decoder_set_read_line_cb(lv_img_decoder_t * decoder, lv_img_decoder_
  */
 void lv_img_decoder_set_close_cb(lv_img_decoder_t * decoder, lv_img_decoder_close_f_t close_cb);
 
-
-
 /**
  * Get info about a built-in image
  * @param decoder the decoder where this function belongs
@@ -337,7 +250,7 @@ lv_res_t lv_img_decoder_built_in_open(lv_img_decoder_t * decoder, lv_img_decoder
  * @return LV_RES_OK: ok; LV_RES_INV: failed
  */
 lv_res_t lv_img_decoder_built_in_read_line(lv_img_decoder_t * decoder, lv_img_decoder_dsc_t * dsc, lv_coord_t x,
-                                                  lv_coord_t y, lv_coord_t len, uint8_t * buf);
+                                           lv_coord_t y, lv_coord_t len, uint8_t * buf);
 
 /**
  * Close the pending decoding. Free resources etc.

src/lv_font/lv_font.c

@@ -58,7 +58,8 @@ const uint8_t * lv_font_get_glyph_bitmap(const lv_font_t * font_p, uint32_t lett
  * @return true: descriptor is successfully loaded into `dsc_out`.
  *         false: the letter was not found, no data is loaded to `dsc_out`
  */
-bool lv_font_get_glyph_dsc(const lv_font_t * font_p, lv_font_glyph_dsc_t * dsc_out, uint32_t letter, uint32_t letter_next)
+bool lv_font_get_glyph_dsc(const lv_font_t * font_p, lv_font_glyph_dsc_t * dsc_out, uint32_t letter,
+                           uint32_t letter_next)
 {
     return font_p->get_glyph_dsc(font_p, dsc_out, letter, letter_next);
 }

src/lv_font/lv_font.h

@@ -13,17 +13,13 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#ifdef LV_CONF_INCLUDE_SIMPLE
-#include "lv_conf.h"
-#else
-#include "../../../lv_conf.h"
-#endif
-
+#include "../lv_conf_internal.h"
 #include <stdint.h>
 #include <stddef.h>
 #include <stdbool.h>
 
 #include "lv_symbol_def.h"
+#include "../lv_misc/lv_area.h"
 
 /*********************
  *      DEFINES
@@ -43,15 +39,14 @@ extern "C" {
  *-----------------*/
 
 /** Describes the properties of a glyph. */
-typedef struct
-{
+typedef struct {
     uint16_t adv_w; /**< The glyph needs this space. Draw the next glyph after this width. 8 bit integer, 4 bit fractional */
-    uint8_t box_w;  /**< Width of the glyph's bounding box*/
-    uint8_t box_h;  /**< Height of the glyph's bounding box*/
-    int8_t ofs_x;   /**< x offset of the bounding box*/
-    int8_t ofs_y;  /**< y offset of the bounding box*/
+    uint16_t box_w;  /**< Width of the glyph's bounding box*/
+    uint16_t box_h;  /**< Height of the glyph's bounding box*/
+    int16_t ofs_x;   /**< x offset of the bounding box*/
+    int16_t ofs_y;  /**< y offset of the bounding box*/
     uint8_t bpp;   /**< Bit-per-pixel: 1, 2, 4, 8*/
-}lv_font_glyph_dsc_t;
+} lv_font_glyph_dsc_t;
 
 
 /** The bitmaps might be upscaled by 3 to achieve subpixel rendering. */
@@ -65,8 +60,7 @@ enum {
 typedef uint8_t lv_font_subpx_t;
 
 /** Describe the properties of a font*/
-typedef struct _lv_font_struct
-{
+typedef struct _lv_font_struct {
     /** Get a glyph's  descriptor from a font*/
     bool (*get_glyph_dsc)(const struct _lv_font_struct *, lv_font_glyph_dsc_t *, uint32_t letter, uint32_t letter_next);
 
@@ -74,12 +68,12 @@ typedef struct _lv_font_struct
     const uint8_t * (*get_glyph_bitmap)(const struct _lv_font_struct *, uint32_t);
 
     /*Pointer to the font in a font pack (must have the same line height)*/
-    uint8_t line_height;      /**< The real line height where any text fits*/
-    int8_t base_line;        /**< Base line measured from the top of the line_height*/
-    uint8_t subpx  :2;        /**< An element of `lv_font_subpx_t`*/
-    void * dsc;               /**< Store implementation specific or run_time data or caching here*/
+    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`*/
+    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. */
+    lv_font_user_data_t user_data;  /**< Custom user data for font. */
 #endif
 
 
@@ -105,7 +99,8 @@ const uint8_t * lv_font_get_glyph_bitmap(const lv_font_t * font_p, uint32_t lett
  * @return true: descriptor is successfully loaded into `dsc_out`.
  *         false: the letter was not found, no data is loaded to `dsc_out`
  */
-bool lv_font_get_glyph_dsc(const lv_font_t * font_p, lv_font_glyph_dsc_t * dsc_out, uint32_t letter, uint32_t letter_next);
+bool lv_font_get_glyph_dsc(const lv_font_t * font_p, lv_font_glyph_dsc_t * dsc_out, uint32_t letter,
+                           uint32_t letter_next);
 
 /**
  * Get the width of a glyph with kerning
@@ -121,7 +116,7 @@ uint16_t lv_font_get_glyph_width(const lv_font_t * font, uint32_t letter, uint32
  * @param font_p pointer to a font
  * @return the height of a font
  */
-static inline uint8_t lv_font_get_line_height(const lv_font_t * font_p)
+static inline lv_coord_t lv_font_get_line_height(const lv_font_t * font_p)
 {
     return font_p->line_height;
 }
@@ -132,26 +127,102 @@ static inline uint8_t lv_font_get_line_height(const lv_font_t * font_p)
 
 #define LV_FONT_DECLARE(font_name) extern lv_font_t font_name;
 
-#if LV_FONT_ROBOTO_12
-LV_FONT_DECLARE(lv_font_roboto_12)
+#if LV_FONT_MONTSERRAT_12
+LV_FONT_DECLARE(lv_font_montserrat_12)
 #endif
 
-#if LV_FONT_ROBOTO_16
-LV_FONT_DECLARE(lv_font_roboto_16)
+#if LV_FONT_MONTSERRAT_14
+LV_FONT_DECLARE(lv_font_montserrat_14)
 #endif
 
-#if LV_FONT_ROBOTO_22
-LV_FONT_DECLARE(lv_font_roboto_22)
+#if LV_FONT_MONTSERRAT_16
+LV_FONT_DECLARE(lv_font_montserrat_16)
 #endif
 
-#if LV_FONT_ROBOTO_28
-LV_FONT_DECLARE(lv_font_roboto_28)
+#if LV_FONT_MONTSERRAT_18
+LV_FONT_DECLARE(lv_font_montserrat_18)
+#endif
+
+#if LV_FONT_MONTSERRAT_20
+LV_FONT_DECLARE(lv_font_montserrat_20)
+#endif
+
+#if LV_FONT_MONTSERRAT_22
+LV_FONT_DECLARE(lv_font_montserrat_22)
+#endif
+
+#if LV_FONT_MONTSERRAT_24
+LV_FONT_DECLARE(lv_font_montserrat_24)
+#endif
+
+#if LV_FONT_MONTSERRAT_26
+LV_FONT_DECLARE(lv_font_montserrat_26)
+#endif
+
+#if LV_FONT_MONTSERRAT_28
+LV_FONT_DECLARE(lv_font_montserrat_28)
+#endif
+
+#if LV_FONT_MONTSERRAT_30
+LV_FONT_DECLARE(lv_font_montserrat_30)
+#endif
+
+#if LV_FONT_MONTSERRAT_32
+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
+
+#if LV_FONT_MONTSERRAT_38
+LV_FONT_DECLARE(lv_font_montserrat_38)
+#endif
+
+#if LV_FONT_MONTSERRAT_40
+LV_FONT_DECLARE(lv_font_montserrat_40)
+#endif
+
+#if LV_FONT_MONTSERRAT_42
+LV_FONT_DECLARE(lv_font_montserrat_42)
+#endif
+
+#if LV_FONT_MONTSERRAT_44
+LV_FONT_DECLARE(lv_font_montserrat_44)
+#endif
+
+#if LV_FONT_MONTSERRAT_46
+LV_FONT_DECLARE(lv_font_montserrat_46)
+#endif
+
+#if LV_FONT_MONTSERRAT_48
+LV_FONT_DECLARE(lv_font_montserrat_48)
+#endif
+
+#if LV_FONT_MONTSERRAT_28_COMPRESSED
+LV_FONT_DECLARE(lv_font_montserrat_28_compressed)
+#endif
+
+#if LV_FONT_MONTSERRAT_12_SUBPX
+LV_FONT_DECLARE(lv_font_montserrat_12_subpx)
 #endif
 
 #if LV_FONT_UNSCII_8
 LV_FONT_DECLARE(lv_font_unscii_8)
 #endif
 
+#if LV_FONT_DEJAVU_16_PERSIAN_HEBREW
+LV_FONT_DECLARE(lv_font_dejavu_16_persian_hebrew)
+#endif
+
+#if LV_FONT_SIMSUN_16_CJK
+LV_FONT_DECLARE(lv_font_simsun_16_cjk)
+#endif
+
 /*Declare the custom (user defined) fonts*/
 #ifdef LV_FONT_CUSTOM_DECLARE
 LV_FONT_CUSTOM_DECLARE

src/lv_font/lv_font.mk

@@ -1,12 +1,30 @@
 CSRCS += lv_font.c
 CSRCS += lv_font_fmt_txt.c
-CSRCS += lv_font_roboto_12.c
-CSRCS += lv_font_roboto_16.c
-CSRCS += lv_font_roboto_22.c
-CSRCS += lv_font_roboto_28.c
+CSRCS += lv_font_montserrat_12.c
+CSRCS += lv_font_montserrat_14.c
+CSRCS += lv_font_montserrat_16.c
+CSRCS += lv_font_montserrat_18.c
+CSRCS += lv_font_montserrat_20.c
+CSRCS += lv_font_montserrat_22.c
+CSRCS += lv_font_montserrat_24.c
+CSRCS += lv_font_montserrat_26.c
+CSRCS += lv_font_montserrat_28.c
+CSRCS += lv_font_montserrat_30.c
+CSRCS += lv_font_montserrat_32.c
+CSRCS += lv_font_montserrat_34.c
+CSRCS += lv_font_montserrat_36.c
+CSRCS += lv_font_montserrat_38.c
+CSRCS += lv_font_montserrat_40.c
+CSRCS += lv_font_montserrat_42.c
+CSRCS += lv_font_montserrat_44.c
+CSRCS += lv_font_montserrat_46.c
+CSRCS += lv_font_montserrat_48.c
+CSRCS += lv_font_montserrat_12_subpx.c
+CSRCS += lv_font_montserrat_28_compressed.c
 CSRCS += lv_font_unscii_8.c
+CSRCS += lv_font_dejavu_16_persian_hebrew.c
 
-DEPPATH += --dep-path $(LVGL_DIR)/lvgl/src/lv_font
-VPATH += :$(LVGL_DIR)/lvgl/src/lv_font
+DEPPATH += --dep-path $(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_font
+VPATH += :$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_font
 
-CFLAGS += "-I$(LVGL_DIR)/lvgl/src/lv_font"
+CFLAGS += "-I$(LVGL_DIR)/$(LVGL_DIR_NAME)/src/lv_font"

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"
@@ -26,7 +26,7 @@ typedef enum {
     RLE_STATE_SINGLE = 0,
     RLE_STATE_REPEATE,
     RLE_STATE_COUNTER,
-}rle_state_t;
+} rle_state_t;
 
 /**********************
  *  STATIC PROTOTYPES
@@ -38,17 +38,17 @@ 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_line(uint8_t * out, lv_coord_t w);
-static uint8_t get_bits(const uint8_t * in, uint32_t bit_pos, uint8_t len);
-static void bits_write(uint8_t * out, uint32_t bit_pos, uint8_t val, uint8_t len);
-static void rle_init(const uint8_t * in,  uint8_t bpp);
-static uint8_t rle_next(void);
+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
  **********************/
-
+static uint8_t * decompr_buf;
 static uint32_t rle_rdp;
 static const uint8_t * rle_in;
 static uint8_t rle_bpp;
@@ -76,6 +76,8 @@ static rle_state_t rle_state;
  */
 const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t unicode_letter)
 {
+    if(unicode_letter == '\t') unicode_letter = ' ';
+
     lv_font_fmt_txt_dsc_t * fdsc = (lv_font_fmt_txt_dsc_t *) font->dsc;
     uint32_t gid = get_glyph_dsc_id(font, unicode_letter);
     if(!gid) return NULL;
@@ -86,30 +88,35 @@ const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t unic
         if(gdsc) return &fdsc->glyph_bitmap[gdsc->bitmap_index];
     }
     /*Handle compressed bitmap*/
-    else
-    {
-        static uint8_t * buf = NULL;
-
+    else {
         uint32_t gsize = gdsc->box_w * gdsc->box_h;
         if(gsize == 0) return NULL;
 
         uint32_t buf_size = gsize;
         /*Compute memory size needed to hold decompressed glyph, rounding up*/
         switch(fdsc->bpp) {
-        case 1: buf_size = (gsize + 7) >> 3;  break;
-        case 2: buf_size = (gsize + 3) >> 2;  break;
-        case 3: buf_size = (gsize + 1) >> 1;  break;
-        case 4: buf_size = (gsize + 1) >> 1;  break;
+            case 1:
+                buf_size = (gsize + 7) >> 3;
+                break;
+            case 2:
+                buf_size = (gsize + 3) >> 2;
+                break;
+            case 3:
+                buf_size = (gsize + 1) >> 1;
+                break;
+            case 4:
+                buf_size = (gsize + 1) >> 1;
+                break;
         }
 
-        if(lv_mem_get_size(buf) < buf_size) {
-            buf = lv_mem_realloc(buf, buf_size);
-            LV_ASSERT_MEM(buf);
-            if(buf == NULL) return NULL;
+        if(_lv_mem_get_size(decompr_buf) < buf_size) {
+            decompr_buf = lv_mem_realloc(decompr_buf, buf_size);
+            LV_ASSERT_MEM(decompr_buf);
+            if(decompr_buf == NULL) return NULL;
         }
 
-        decompress(&fdsc->glyph_bitmap[gdsc->bitmap_index], buf, gdsc->box_w , gdsc->box_h, (uint8_t)fdsc->bpp);
-        return buf;
+        decompress(&fdsc->glyph_bitmap[gdsc->bitmap_index], decompr_buf, gdsc->box_w, gdsc->box_h, (uint8_t)fdsc->bpp);
+        return decompr_buf;
     }
 
     /*If not returned earlier then the letter is not found in this font*/
@@ -124,8 +131,14 @@ const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t unic
  * @return true: descriptor is successfully loaded into `dsc_out`.
  *         false: the letter was not found, no data is loaded to `dsc_out`
  */
-bool lv_font_get_glyph_dsc_fmt_txt(const lv_font_t * font, lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter, uint32_t unicode_letter_next)
+bool lv_font_get_glyph_dsc_fmt_txt(const lv_font_t * font, lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter,
+                                   uint32_t unicode_letter_next)
 {
+    bool is_tab = false;
+    if(unicode_letter == '\t') {
+        unicode_letter = ' ';
+        is_tab = true;
+    }
     lv_font_fmt_txt_dsc_t * fdsc = (lv_font_fmt_txt_dsc_t *) font->dsc;
     uint32_t gid = get_glyph_dsc_id(font, unicode_letter);
     if(!gid) return false;
@@ -143,7 +156,10 @@ bool lv_font_get_glyph_dsc_fmt_txt(const lv_font_t * font, lv_font_glyph_dsc_t *
 
     int32_t kv = ((int32_t)((int32_t)kvalue * fdsc->kern_scale) >> 4);
 
-    uint32_t adv_w = gdsc->adv_w + kv;
+    uint32_t adv_w = gdsc->adv_w;
+    if(is_tab) adv_w *= 2;
+
+    adv_w += kv;
     adv_w  = (adv_w + (1 << 3)) >> 4;
 
     dsc_out->adv_w = adv_w;
@@ -153,9 +169,23 @@ bool lv_font_get_glyph_dsc_fmt_txt(const lv_font_t * font, lv_font_glyph_dsc_t *
     dsc_out->ofs_y = gdsc->ofs_y;
     dsc_out->bpp   = (uint8_t)fdsc->bpp;
 
+    if(is_tab) dsc_out->box_w = dsc_out->box_w * 2;
+
     return true;
 }
 
+/**
+ * Free the allocated memories.
+ */
+void _lv_font_clean_up_fmt_txt(void)
+{
+    if(decompr_buf) {
+        lv_mem_free(decompr_buf);
+        decompr_buf = NULL;
+    }
+}
+
+
 /**********************
  *   STATIC FUNCTIONS
  **********************/
@@ -184,7 +214,9 @@ 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, sizeof(fdsc->cmaps[i].unicode_list[0]), unicode_list_compare);
+            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) {
                 lv_uintptr_t ofs = (lv_uintptr_t)(p - (uint8_t *) fdsc->cmaps[i].unicode_list);
@@ -193,10 +225,12 @@ 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, sizeof(fdsc->cmaps[i].unicode_list[0]), unicode_list_compare);
+            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) {
-                lv_uintptr_t ofs = (lv_uintptr_t)(p - (uint8_t*) fdsc->cmaps[i].unicode_list);
+                lv_uintptr_t ofs = (lv_uintptr_t)(p - (uint8_t *) fdsc->cmaps[i].unicode_list);
                 ofs = ofs >> 1;     /*The list stores `uint16_t` so the get the index divide by 2*/
                 const uint8_t * gid_ofs_16 = fdsc->cmaps[i].glyph_id_ofs_list;
                 glyph_id = fdsc->cmaps[i].glyph_id_start + gid_ofs_16[ofs];
@@ -229,7 +263,7 @@ static int8_t get_kern_value(const lv_font_t * font, uint32_t gid_left, uint32_t
              * The pairs are ordered left_id first, then right_id secondly. */
             const uint8_t * g_ids = kdsc->glyph_ids;
             uint16_t g_id_both = (gid_right << 8) + gid_left; /*Create one number from the ids*/
-            uint8_t * kid_p = lv_utils_bsearch(&g_id_both, g_ids, kdsc->pair_cnt, 2, kern_pair_8_compare);
+            uint8_t * kid_p = _lv_utils_bsearch(&g_id_both, g_ids, kdsc->pair_cnt, 2, kern_pair_8_compare);
 
             /*If the `g_id_both` were found get its index from the pointer*/
             if(kid_p) {
@@ -237,24 +271,27 @@ static int8_t get_kern_value(const lv_font_t * font, uint32_t gid_left, uint32_t
                 ofs = ofs >> 1;     /*ofs is for pair, divide by 2 to refer as a single value*/
                 value = kdsc->values[ofs];
             }
-        } else if(kdsc->glyph_ids_size == 1) {
+        }
+        else if(kdsc->glyph_ids_size == 1) {
             /* Use binary search to find the kern value.
              * The pairs are ordered left_id first, then right_id secondly. */
             const uint16_t * g_ids = kdsc->glyph_ids;
             lv_uintptr_t g_id_both = (uint32_t)((uint32_t)gid_right << 8) + gid_left; /*Create one number from the ids*/
-            uint8_t * kid_p = lv_utils_bsearch(&g_id_both, g_ids, kdsc->pair_cnt, 4, kern_pair_16_compare);
+            uint8_t * kid_p = _lv_utils_bsearch(&g_id_both, g_ids, kdsc->pair_cnt, 4, kern_pair_16_compare);
 
             /*If the `g_id_both` were found get its index from the pointer*/
             if(kid_p) {
-                lv_uintptr_t ofs = (lv_uintptr_t) (kid_p - (const uint8_t *)g_ids);
+                lv_uintptr_t ofs = (lv_uintptr_t)(kid_p - (const uint8_t *)g_ids);
                 ofs = ofs >> 4;     /*ofs is 4 byte pairs, divide by 4 to refer as a single value*/
                 value = kdsc->values[ofs];
             }
 
-        } else {
+        }
+        else {
             /*Invalid value*/
         }
-    } else {
+    }
+    else {
         /*Kern classes*/
         const lv_font_fmt_txt_kern_classes_t * kdsc = fdsc->kern_dsc;
         uint8_t left_class = kdsc->left_class_mapping[gid_left];
@@ -263,7 +300,7 @@ static int8_t get_kern_value(const lv_font_t * font, uint32_t gid_left, uint32_t
         /* If class = 0, kerning not exist for that glyph
          * else got the value form `class_pair_values` 2D array*/
         if(left_class > 0 && right_class > 0) {
-            value = kdsc->class_pair_values[(left_class-1)* kdsc->right_class_cnt + (right_class-1)];
+            value = kdsc->class_pair_values[(left_class - 1) * kdsc->right_class_cnt + (right_class - 1)];
         }
 
     }
@@ -306,16 +343,16 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord
 
     rle_init(in, bpp);
 
-    uint8_t * line_buf = lv_draw_get_buf(w * 2);
-    uint8_t * line_buf1 = line_buf;
-    uint8_t * line_buf2 = line_buf + w;
+    uint8_t * line_buf1 = _lv_mem_buf_get(w);
+    uint8_t * line_buf2 = _lv_mem_buf_get(w);
 
     decompress_line(line_buf1, w);
 
     lv_coord_t y;
     lv_coord_t x;
+
     for(x = 0; x < w; x++) {
-        bits_write(out,wrp, line_buf1[x], bpp);
+        bits_write(out, wrp, line_buf1[x], bpp);
         wrp += wr_size;
     }
 
@@ -324,10 +361,13 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord
 
         for(x = 0; x < w; x++) {
             line_buf1[x] = line_buf2[x] ^ line_buf1[x];
-            bits_write(out,wrp, line_buf1[x], bpp);
+            bits_write(out, wrp, line_buf1[x], bpp);
             wrp += wr_size;
         }
     }
+
+    _lv_mem_buf_release(line_buf1);
+    _lv_mem_buf_release(line_buf2);
 }
 
 /**
@@ -335,7 +375,7 @@ static void decompress(const uint8_t * in, uint8_t * out, lv_coord_t w, lv_coord
  * @param out output buffer
  * @param w width of the line in pixel count
  */
-static void decompress_line(uint8_t * out, lv_coord_t w)
+static inline void decompress_line(uint8_t * out, lv_coord_t w)
 {
     lv_coord_t i;
     for(i = 0; i < w; i++) {
@@ -346,20 +386,43 @@ static 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
  */
-static uint8_t get_bits(const uint8_t * in, uint32_t bit_pos, uint8_t len)
+static inline uint8_t get_bits(const uint8_t * in, uint32_t bit_pos, uint8_t len)
 {
-    uint8_t res = 0;
+    uint8_t bit_mask;
+    switch(len) {
+        case 1:
+            bit_mask = 0x1;
+            break;
+        case 2:
+            bit_mask = 0x3;
+            break;
+        case 3:
+            bit_mask = 0x7;
+            break;
+        case 4:
+            bit_mask = 0xF;
+            break;
+        case 8:
+            bit_mask = 0xFF;
+            break;
+        default:
+            bit_mask = (uint16_t)((uint16_t) 1 << len) - 1;
+    }
+
     uint32_t byte_pos = bit_pos >> 3;
     bit_pos = bit_pos & 0x7;
-    uint8_t bit_mask = (uint16_t)((uint16_t) 1 << len) - 1;
-    uint16_t in16 = (in[byte_pos] << 8) + in[byte_pos + 1];
 
-    res = (in16 >> (16 - bit_pos - len)) & bit_mask;
-    return res;
+    if(bit_pos + len >= 8) {
+        uint16_t in16 = (in[byte_pos] << 8) + in[byte_pos + 1];
+        return (in16 >> (16 - bit_pos - len)) & bit_mask;
+    }
+    else {
+        return (in[byte_pos] >> (8 - bit_pos - len)) & bit_mask;
+    }
 }
 
 /**
@@ -370,19 +433,35 @@ static uint8_t get_bits(const uint8_t * in, uint32_t bit_pos, uint8_t len)
  * @param len length of bits to write from `val`. (Counted from the LSB).
  * @note `len == 3` will be converted to `len = 4` and `val` will be upscaled too
  */
-static void bits_write(uint8_t * out, uint32_t bit_pos, uint8_t val, uint8_t len)
+static inline void bits_write(uint8_t * out, uint32_t bit_pos, uint8_t val, uint8_t len)
 {
     if(len == 3) {
         len = 4;
         switch(val) {
-        case 0: val = 0; break;
-        case 1: val = 2; break;
-        case 2: val = 4; break;
-        case 3: val = 6; break;
-        case 4: val = 9; break;
-        case 5: val = 11; break;
-        case 6: val = 13; break;
-        case 7: val = 15; break;
+            case 0:
+                val = 0;
+                break;
+            case 1:
+                val = 2;
+                break;
+            case 2:
+                val = 4;
+                break;
+            case 3:
+                val = 6;
+                break;
+            case 4:
+                val = 9;
+                break;
+            case 5:
+                val = 11;
+                break;
+            case 6:
+                val = 13;
+                break;
+            case 7:
+                val = 15;
+                break;
         }
     }
 
@@ -395,7 +474,7 @@ static void bits_write(uint8_t * out, uint32_t bit_pos, uint8_t val, uint8_t len
     out[byte_pos] |= (val << bit_pos);
 }
 
-static void rle_init(const uint8_t * in,  uint8_t bpp)
+static inline void rle_init(const uint8_t * in,  uint8_t bpp)
 {
     rle_in = in;
     rle_bpp = bpp;
@@ -405,7 +484,7 @@ static void rle_init(const uint8_t * in,  uint8_t bpp)
     rle_cnt = 0;
 }
 
-static uint8_t rle_next(void)
+static inline uint8_t rle_next(void)
 {
     uint8_t v = 0;
     uint8_t ret = 0;
@@ -431,14 +510,16 @@ static uint8_t rle_next(void)
                 rle_rdp += 6;
                 if(rle_cnt != 0) {
                     rle_state = RLE_STATE_COUNTER;
-                } else {
+                }
+                else {
                     ret = get_bits(rle_in, rle_rdp, rle_bpp);
                     rle_prev_v = ret;
                     rle_rdp += rle_bpp;
                     rle_state = RLE_STATE_SINGLE;
                 }
             }
-        } else {
+        }
+        else {
             ret = get_bits(rle_in, rle_rdp, rle_bpp);
             rle_prev_v = ret;
             rle_rdp += rle_bpp;

src/lv_font/lv_font_fmt_txt.h

@@ -13,12 +13,6 @@ extern "C" {
 /*********************
  *      INCLUDES
  *********************/
-#ifdef LV_CONF_INCLUDE_SIMPLE
-#include "lv_conf.h"
-#else
-#include "../../../lv_conf.h"
-#endif
-
 #include <stdint.h>
 #include <stddef.h>
 #include <stdbool.h>
@@ -33,20 +27,23 @@ extern "C" {
  **********************/
 
 /** This describes a glyph. */
-typedef struct
-{
+typedef struct {
 #if LV_FONT_FMT_TXT_LARGE == 0
     uint32_t bitmap_index : 20;     /**< Start index of the bitmap. A font can be max 1 MB. */
-    uint32_t adv_w :12;             /**< Draw the next glyph after this width. 8.4 format (real_value * 16 is stored). */
-#else
-    uint32_t bitmap_index;          /**< Start index of the bitmap. A font can be max 4 GB. */
-    uint32_t adv_w;                 /**< Draw the next glyph after this width. 28.4 format (real_value * 16 is stored). */
-#endif
+    uint32_t adv_w : 12;            /**< Draw the next glyph after this width. 8.4 format (real_value * 16 is stored). */
     uint8_t box_w;                  /**< Width of the glyph's bounding box*/
     uint8_t box_h;                  /**< Height of the glyph's bounding box*/
     int8_t ofs_x;                   /**< x offset of the bounding box*/
     int8_t ofs_y;                  /**< y offset of the bounding box. Measured from the top of the line*/
-}lv_font_fmt_txt_glyph_dsc_t;
+#else
+    uint32_t bitmap_index;          /**< Start index of the bitmap. A font can be max 4 GB. */
+    uint32_t adv_w;                 /**< Draw the next glyph after this width. 28.4 format (real_value * 16 is stored). */
+    uint16_t box_w;                  /**< Width of the glyph's bounding box*/
+    uint16_t box_h;                  /**< Height of the glyph's bounding box*/
+    int16_t ofs_x;                   /**< x offset of the bounding box*/
+    int16_t ofs_y;                  /**< y offset of the bounding box. Measured from the top of the line*/
+#endif
+} lv_font_fmt_txt_glyph_dsc_t;
 
 
 /** Format of font character map. */
@@ -62,7 +59,7 @@ typedef uint8_t lv_font_fmt_txt_cmap_type_t;
 
 /* Map codepoints to a `glyph_dsc`s
  * Several formats are supported to optimize memory usage
- * See https://github.com/littlevgl/lv_font_conv/blob/master/doc/font_spec.md
+ * See https://github.com/lvgl/lv_font_conv/blob/master/doc/font_spec.md
  */
 typedef struct {
     /** First Unicode character for this range */
@@ -77,7 +74,7 @@ typedef struct {
 
     /*
     According the specification there are 4 formats:
-        https://github.com/littlevgl/lv_font_conv/blob/master/doc/font_spec.md
+        https://github.com/lvgl/lv_font_conv/blob/master/doc/font_spec.md
 
     For simplicity introduce "relative code point":
         rcp = codepoint - range_start
@@ -114,7 +111,7 @@ typedef struct {
 
     /** Type of this character map*/
     lv_font_fmt_txt_cmap_type_t type;
-}lv_font_fmt_txt_cmap_t;
+} lv_font_fmt_txt_cmap_t;
 
 /** A simple mapping of kern values from pairs*/
 typedef struct {
@@ -127,9 +124,9 @@ typedef struct {
      */
     const void * glyph_ids;
     const int8_t * values;
-    uint32_t pair_cnt   :24;
-    uint32_t glyph_ids_size :2;     /*0: `glyph_ids` is stored as `uint8_t`; 1: as `uint16_t`*/
-}lv_font_fmt_txt_kern_pair_t;
+    uint32_t pair_cnt   : 24;
+    uint32_t glyph_ids_size : 2;    /*0: `glyph_ids` is stored as `uint8_t`; 1: as `uint16_t`*/
+} lv_font_fmt_txt_kern_pair_t;
 
 /** More complex but more optimal class based kern value storage*/
 typedef struct {
@@ -138,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*/
@@ -146,19 +143,19 @@ typedef struct {
     const uint8_t * right_class_mapping;  /*Map the glyph_ids to classes: index -> glyph_id -> class_id*/
     uint8_t left_class_cnt;
     uint8_t right_class_cnt;
-}lv_font_fmt_txt_kern_classes_t;
+} lv_font_fmt_txt_kern_classes_t;
 
 
 /** Bitmap formats*/
 typedef enum {
     LV_FONT_FMT_TXT_PLAIN      = 0,
     LV_FONT_FMT_TXT_COMPRESSED = 1,
-}lv_font_fmt_txt_bitmap_format_t;
+} 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*/
@@ -178,25 +175,25 @@ typedef struct {
     uint16_t kern_scale;
 
     /*Number of cmap tables*/
-    uint16_t cmap_num       :10;
+    uint16_t cmap_num       : 10;
 
-    /*Bit per pixel: 1, 2, 3, 4*/
-    uint16_t bpp            :3;
+    /*Bit per pixel: 1, 2, 3, 4, 8*/
+    uint16_t bpp            : 4;
 
     /*Type of `kern_dsc`*/
-    uint16_t kern_classes   :1;
+    uint16_t kern_classes   : 1;
 
     /*
      * storage format of the bitmap
      * from `lv_font_fmt_txt_bitmap_format_t`
      */
-    uint16_t bitmap_format  :2;
+    uint16_t bitmap_format  : 2;
 
     /*Cache the last letter and is glyph id*/
     uint32_t last_letter;
     uint32_t last_glyph_id;
 
-}lv_font_fmt_txt_dsc_t;
+} lv_font_fmt_txt_dsc_t;
 
 /**********************
  * GLOBAL PROTOTYPES
@@ -218,7 +215,13 @@ const uint8_t * lv_font_get_bitmap_fmt_txt(const lv_font_t * font, uint32_t lett
  * @return true: descriptor is successfully loaded into `dsc_out`.
  *         false: the letter was not found, no data is loaded to `dsc_out`
  */
-bool lv_font_get_glyph_dsc_fmt_txt(const lv_font_t * font, lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter, uint32_t unicode_letter_next);
+bool lv_font_get_glyph_dsc_fmt_txt(const lv_font_t * font, lv_font_glyph_dsc_t * dsc_out, uint32_t unicode_letter,
+                                   uint32_t unicode_letter_next);
+
+/**
+ * Free the allocated memories.
+ */
+void _lv_font_clean_up_fmt_txt(void);
 
 /**********************
  *      MACROS