Release v7.10.1

* fix(theme): the minor typo error

* fix(style): make lv_style_reset work with zerod memory

* fix(theme): fix the memory leak when lv_theme_xxx_init is called twice

due to inited variable forget to set to 1

* fix(theme): empty theme should call lv_obj_refresh_style too

and remove lv_obj_clean_style_list since the same thing is
already done in the common code(clear_styles)

.editorconfig

@@ -0,0 +1,6 @@
+[*.{c,h}]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true

.github/FUNDING.yml

@@ -0,0 +1 @@
+open_collective: lvgl

.github/ISSUE_TEMPLATE/bug-report.md

@@ -0,0 +1,43 @@
+---
+name: Bug report
+about: Create a bug report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+<!--
+IMPORTANT
+Issues that don't use this template will be ignored and closed.
+-->
+
+### Perform all steps below and tick them with [x]
+- [ ] Check the related part of the [Documentation](https://docs.lvgl.io/)
+- [ ] Update lvgl to the latest version
+- [ ] Reproduce the issue in a [Simulator](https://docs.lvgl.io/latest/en/html/get-started/pc-simulator.html)
+
+### Describe the bug
+<!--
+A clear and concise description of what the bug is.
+-->
+
+### To Reproduce
+<!--
+Provide a small, independent code sample that can be used to reproduce the issue.
+Ideally this should work in the PC simulator unless the problem is specific to a platform.
+Format the code like this:
+```c
+your code here
+```
+-->
+
+### Expected behavior
+<!--
+A clear and concise description of what you expected to happen.
+-->
+
+### Screenshots or video
+<!--
+If applicable, add screenshots to help explain your problem.
+-->

.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 topics like How-to, Getting started, Feature request
+  - 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/ISSUE_TEMPLATE/dev-discussion.md

@@ -0,0 +1,29 @@
+---
+name: Development discussion
+about: Discussion strictly related to the development of the LVGL.
+title: ''
+labels: ''
+assignees: ''
+
+---
+<!--
+IMPORTANT
+Issues that don't use this template will be ignored and closed.
+
+Normal Feature requests should go to the Forum: https://forum.lvgl.io/c/feature-request/9
+-->
+
+### Introduce the problem
+<!--
+A clear and concise description of the problem.
+-->
+
+### Examples and cases
+<!--
+Mention some examples and cases where the problem or the missing feature is relevant
+-->
+
+### Suggested solution
+<!--
+If you already have an idea about the solution share it here
+-->

.github/auto-comment.yml

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

.github/pull_request_template.md

@@ -0,0 +1,8 @@
+### Description of the feature or fix
+
+A clear and concise description of what the bug or new feature is.
+
+### Checkpoints
+- [ ] Follow the [styling guide](https://github.com/lvgl/lvgl/blob/master/docs/CODING_STYLE.md)
+- [ ] Update CHANGELOG.md
+- [ ] Update the documentation

.github/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 21
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - architecture
+  - pinned
+# Label to use when marking an issue as stale
+staleLabel: stale
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue or pull request has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: false

.github/workflows/build_micropython.yml

@@ -0,0 +1,41 @@
+name: Build Micropython with LVGL submodule
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    branches: [ master, dev ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Install SDL
+      run: |
+        sudo add-apt-repository -y "deb http://archive.ubuntu.com/ubuntu `lsb_release -sc` main universe restricted multiverse"
+        sudo apt-get update -y -qq
+        sudo apt-get install libsdl2-dev
+    - name: Clone lv_micropython
+      run: git clone https://github.com/lvgl/lv_micropython.git .
+    - name: Update submodules
+      run: git submodule update --init --recursive
+    - name: Checkout LVGL submodule
+      working-directory: ./lib/lv_bindings/lvgl
+      run: |
+        git fetch --force ${{ github.event.repository.git_url }} "+refs/heads/*:refs/remotes/origin/*"
+        git fetch --force ${{ github.event.repository.git_url }} "+refs/pull/*:refs/remotes/origin/pr/*"
+        git checkout ${{ github.sha }} || git checkout ${{ github.event.pull_request.head.sha }}
+        git submodule update --init --recursive
+    - name: Build mpy-cross
+      run: make -j $(nproc) -C mpy-cross
+    - name: Build the unix port
+      run: make -j $(nproc) -C ports/unix
+    - name: Run advanced_demo
+      run: >
+        echo "import gc,utime;
+        utime.sleep(5);
+        gc.collect();
+        utime.sleep(5)" |
+        ports/unix/micropython -i lib/lv_bindings/examples/advanced_demo.py

.github/workflows/ccpp.yml

@@ -0,0 +1,18 @@
+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
+    - uses: ammaraskar/gcc-problem-matcher@master
+    - name: Run tests
+      run: sudo apt-get install libpng-dev; cd tests; python ./build.py

.github/workflows/main.yml

@@ -0,0 +1,16 @@
+on:
+  issues:
+    types: [opened, edited]
+
+jobs:
+  auto_close_issues:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+      - name: Automatically close issues that don't follow the issue template
+        uses: lucasbento/auto-close-issues@v1.0.2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          issue-close-message: "@${issue.user.login}: hello! :wave:\n\nThis issue is being automatically closed because it does not follow the issue template." # optional property
+          closed-issues-label: "not-template"

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

.github/workflows/release.yml

@@ -0,0 +1,27 @@
+on:
+  push:
+    # Sequence of patterns matched against refs/tags
+    tags:
+      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+
+name: Create Release
+
+jobs:
+  build:
+    name: Create Release
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # This token is provided by Actions, you do not need to create your own token
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ github.ref }}
+          body: |
+            See the [CHANGELOG](https://github.com/lvgl/lvgl/blob/master/CHANGELOG.md)
+          draft: false
+          prerelease: false

.gitignore

@@ -0,0 +1,9 @@
+scripts/release/__pycache__
+**/*.o
+**/*bin
+**/*.swp
+**/*.swo
+tags
+docs/api_doc
+scripts/cppcheck_res.txt
+scripts/built_in_font/lv_font_*

CHANGELOG.md

@@ -0,0 +1,405 @@
+# Changelog
+
+## v7.10.1 (Planned for 16.02.2021)
+
+### Bugfixes
+- fix(draw) overlap outline with background to prevent aliasing artifacts
+- fix(indev) clear the indev's `act_obj` in `lv_indev_reset`
+- fix(text) fix out of bounds read in `_lv_txt_get_width`
+- fix(text) improve Arabic contextual analysis by adding hyphen processing and proper handling of lam-alef sequence
+- fix(delete) delete animation after the children are deleted
+
+## v7.10.0
+
+### New features
+- feat(indev) allow input events to be passed to disabled objects
+- feat(spinbox) add inline get_step function for MicroPython support
+
+### Bugfixes
+- fix(btnmatrix) fix lv_btnmatrix_get_active_btn_text() when used in a group
+
+## v7.9.1
+
+### Bugfixes
+- fix(cpicker) fix division by zero
+- fix(dropdown) fix selecting options after the last one
+- fix(msgbox) use the animation time provided
+- fix(gpu_nxp_pxp) fix incorrect define name
+- fix(indev) don't leave edit mode if there is only one object in the group
+- fix(draw_rect) fix draw pattern stack-use-after-scope error
+
+
+## v7.9.0
+
+### New features
+- feat(chart) add lv_chart_remove_series and lv_chart_hide_series
+- feat(img_cahce) allow disabling image caching
+- calendar: make get_day_of_week() public
+- Added support for Zephyr integration
+
+### Bugfixes
+- fix(draw_rect) free buffer used for arabic processing
+- fix(win) arabic process the title of the window
+- fix(dropdown) arabic process the option in lv_dropdown_add_option
+- fix(textarea) buffer overflow in password mode with UTF-8 characters
+- fix(textarea) cursor position after hiding character in password mode
+- fix(linemeter) draw critical lines with correct color
+- fix(kconfig) handle disable sprintf float correctly.
+- fix(layout) stop layout after recursion threshold is reached
+- fix(gauge) fix redraw with image needle
+
+## v7.8.1
+
+### Bugfixes
+- fix(lv_scr_load_anim) fix when multiple screen are loaded at tsame time with delay
+- fix(page) fix LV_SCOLLBAR_MODE_DRAG
+
+## v7.8.0 (01.12.2020)
+
+### New features
+- make DMA2D non blocking
+- add unscii-16 built-in font
+- add KConfig
+- add lv_refr_get_fps_avg()
+
+### Bugfixes
+- fix(btnmatrix) handle arabic texts in button matrices
+- fix(indev) disabled object shouldn't absorb clicks but let the parent to be clicked
+- fix(arabic) support processing again already processed texts with _lv_txt_ap_proc
+- fix(textarea) support Arabic letter connections
+- fix(dropdown) support Arabic letter connections
+- fix(value_str) support Arabic letter connections in value string property
+- fix(indev) in LV_INDEV_TYPE_BUTTON recognize 1 cycle long presses too
+- fix(arc) make arc work with encoder
+- fix(slider) adjusting the left knob too with encoder
+- fix reference to LV_DRAW_BUF_MAX_NUM in lv_mem.c
+- fix(polygon draw) join adjacent points if they are on the same coordinate
+- fix(linemeter) fix invalidation when setting new value
+- fix(table) add missing invalidation when changing cell type
+- refactor(roller) rename LV_ROLLER_MODE_INIFINITE -> LV_ROLLER_MODE_INFINITE
+
+## v7.7.2 (17.11.2020)
+### Bugfixes
+- fix(draw_triangle): fix polygon/triangle drawing when the order of points is counter-clockwise
+- fix(btnmatrix): fix setting the same map with modified pointers
+- fix(arc) fix and improve arc dragging
+- label: Repair calculate back `dot` character logical error which cause infinite loop.
+- fix(theme_material): remove the bottom border from tabview header
+- fix(imgbtn) guess a the closest available state with valid src
+- fix(spinbox) update cursor position in lv_spinbox_set_step
+
+## v7.7.1 (03.11.2020)
+### Bugfixes
+- Respect btnmatrix's `one_check` in `lv_btnmatrix_set_btn_ctrl`
+- Gauge: make the needle images to use the styles from `LV_GAUGE_PART_PART`
+- Group: fix in `lv_group_remove_obj` to handle deleting hidden obejcts correctly
+
+## v7.7.0 (20.10.2020)
+
+### New features
+- Add PXP GPU support (for NXP MCUs)
+- Add VG-Lite GPU support (for NXP MCUs)
+- Allow max. 16 cell types for table
+- Add `lv_table_set_text_fmt()`
+- Use margin on calendar header to set distances and padding to the size of the header
+- Add `text_sel_bg` style property
+
+### Bugfixes
+- Theme update to support text selection background
+- Fix imgbtn state change
+- Support RTL in table (draw columns right to left)
+- Support RTL in pretty layout (draw columns right to left)
+- Skip objects in groups if they are in disabled state
+- Fix dropdown selection with RTL basedirection
+- Fix rectangle border drawing with large width
+- Fix `lv_win_clean()`
+
+## v7.6.1 (06.10.2020)
+
+### Bugfixes
+- Fix BIDI support in dropdown list
+- Fix copying base dir in `lv_obj_create`
+- Handle sub pixel rendering in font loader
+- Fix transitions with style caching
+- Fix click focus
+- Fix imgbtn image switching with empty style
+- Material theme: do not set the text font to allow easy global font change
+
+## v7.6.0 (22.09.2020)
+
+### New features
+- Check whether any style property has changed on a state change to decide if any redraw is required
+
+### Bugfixes
+- Fix selection of options with non-ASCII letters in dropdown list
+- Fix font loader to support LV_FONT_FMT_TXT_LARGE
+
+## v7.5.0 (15.09.2020)
+
+### New features
+- Add `clean_dcache_cb` and `lv_disp_clean_dcache` to enable users to use their own cache management function
+- Add `gpu_wait_cb` to wait until the GPU is working. It allows to run CPU a wait only when the rendered data is needed.
+- Add 10px and 8ox built in fonts
+
+### Bugfixes
+- Fix unexpected DEFOCUS on lv_page when clicking to bg after the scrollable
+- Fix `lv_obj_del` and `lv_obj_clean` if the children list changed during deletion.
+- Adjust button matrix button width to include padding when spanning multiple units.
+- Add rounding to btnmatrix line height calculation
+- Add `decmopr_buf` to GC roots
+- Fix divisioin by zero in draw_pattern (lv_draw_rect.c) if the image or letter is not found
+- Fix drawing images with 1 px height or width
+
+## v7.4.0 (01.09.2020)
+
+The main new features of v7.4 are run-time font loading, style caching and arc knob with value setting by click.
+
+### New features
+- Add `lv_font_load()` function - Loads a `lv_font_t` object from a binary font file
+- Add `lv_font_free()` function - Frees the memory allocated by the `lv_font_load()` function
+- Add style caching to reduce access time of properties with default value
+- arc: add set value by click feature
+- arc: add `LV_ARC_PART_KNOB` similarly to slider
+- send gestures event if the object was dragged. User can check dragging with `lv_indev_is_dragging(lv_indev_act())` in the event function.
+
+### Bugfixes
+- Fix color bleeding on border drawing
+- Fix using 'LV_SCROLLBAR_UNHIDE' after 'LV_SCROLLBAR_ON'
+- Fix croping of last column/row if an image is zoomed
+- Fix zooming and rotateing mosaic images
+- Fix deleting tabview with LEFT/RIGHT tab position
+- Fix btnmatrix to not send event when CLICK_TRIG = true and the cursor slid from a pressed button
+- Fix roller width if selected text is larger than the normal
+
+## v7.3.1 (18.08.2020)
+
+### Bugfixes
+- Fix drawing value string twice
+- Rename  `lv_chart_clear_serie` to `lv_chart_clear_series` and `lv_obj_align_origo` to `lv_obj_align_mid`
+- Add linemeter's mirror feature again
+- Fix text decor (udnerline strikethrough) with older versions of font converter
+- Fix setting local style property multiple times
+- Add missing background drawing and radius handling to image button
+- Allow adding extra label to list buttons
+- Fix crash if `lv_table_set_col_cnt` is called before `lv_table_set_row_cnt` for the first time
+- Fix overflow in large image transformations
+- Limit extra button click area of button matrix's buttons. With large paddings it was counter intuitive. (Gaps are mapped to button when clicked).
+- Fix `lv_btnmatrix_set_one_check` not forcing exactly one button to be checked
+- Fix color picker invalidation in rectangle mode
+- Init disabled days to gray color in calendar
+
+## v7.3.0 (04.08.2020)
+
+### New features
+- Add `lv_task_get_next`
+- Add `lv_event_send_refresh`, `lv_event_send_refresh_recursive` to easily send `LV_EVENT_REFRESH` to object
+- Add `lv_tabview_set_tab_name()` function - used to change a tab's name
+- Add `LV_THEME_MATERIAL_FLAG_NO_TRANSITION` and `LV_THEME_MATERIAL_FLAG_NO_FOCUS` flags
+- Reduce code size by adding: `LV_USE_FONT_COMPRESSED` and `LV_FONT_USE_SUBPX` and applying some optimization
+- Add `LV_MEMCPY_MEMSET_STD` to use standard `memcpy` and `memset`
+
+### Bugfixes
+- Do not print warning for missing glyph if its height OR width is zero.
+- Prevent duplicated sending of `LV_EVENT_INSERT` from text area
+- Tidy outer edges of cpicker widget.
+- Remove duplicated lines from `lv_tabview_add_tab`
+- btnmatrix: hadle combined states of buttons (e.g. chacked + disabled)
+- textarea: fix typo in lv_textarea_set_sscrollbar_mode
+- gauge: fix image needle drawing
+- fix using freed memory in _lv_style_list_remove_style
+
+## v7.2.0 (21.07.2020)
+
+### New features
+- Add screen transitions with `lv_scr_load_anim()`
+- Add display background color, wallpaper and opacity. Shown when the screen is transparent. Can be used with `lv_disp_set_bg_opa/color/image()`.
+- Add `LV_CALENDAR_WEEK_STARTS_MONDAY`
+- Add `lv_chart_set_x_start_point()` function - Set the index of the x-axis start point in the data array
+- Add `lv_chart_set_ext_array()` function - Set an external array of data points to use for the chart
+- Add `lv_chart_set_point_id()` function - Set an individual point value in the chart series directly based on index
+- Add `lv_chart_get_x_start_point()` function - Get the current index of the x-axis start point in the data array
+- Add `lv_chart_get_point_id()` function - Get an individual point value in the chart series directly based on index
+- Add `ext_buf_assigned` bit field to `lv_chart_series_t` structure - it's true if external buffer is assigned to series
+- Add `lv_chart_set_series_axis()` to assign series to primary or secondary axis
+- Add `lv_chart_set_y_range()` to allow setting range of secondary y axis (based on `lv_chart_set_range` but extended with an axis parameter)
+- Allow setting different font for the selected text in `lv_roller`
+- Add `theme->apply_cb` to replace `theme->apply_xcb` to make it compatible with the MicroPython binding
+- Add `lv_theme_set_base()` to allow easy extension of built-in (or any) themes
+- Add `lv_obj_align_x()` and `lv_obj_align_y()` functions
+- Add `lv_obj_align_origo_x()` and `lv_obj_align_origo_y()` functions
+
+### Bugfixes
+- `tileview` fix navigation when not screen sized
+- Use 14px font by default to for better compatibility with smaller displays
+- `linemeter` fix conversation of current value to "level"
+- Fix drawing on right border
+- Set the cursor image non clickable by default
+- Improve mono theme when used with keyboard or encoder
+
+## v7.1.0 (07.07.2020)
+
+### New features
+- Add `focus_parent` attribute to `lv_obj`
+- Allow using buttons in encoder input device
+- Add lv_btnmatrix_set/get_align capability
+- DMA2D: Remove dependency on ST CubeMX HAL
+- Added `max_used` propriety to `lv_mem_monitor_t` struct
+- In `lv_init` test if the strings are UTF-8 encoded.
+- Add `user_data` to themes
+- Add LV_BIG_ENDIAN_SYSTEM flag to lv_conf.h in order to fix displaying images on big endian systems.
+- Add inline function lv_checkbox_get_state(const lv_obj_t * cb) to extend the checkbox functionality.
+- Add inline function lv_checkbox_set_state(const lv_obj_t * cb, lv_btn_state_t state ) to extend the checkbox functionality.
+
+### Bugfixes
+- `lv_img` fix invalidation area when angle or zoom changes
+- Update the style handling to support Big endian MCUs
+- Change some methods to support big endian hardware.
+- remove use of c++ keyword 'new' in parameter of function lv_theme_set_base().
+- Add LV_BIG_ENDIAN_SYSTEM flag to lv_conf.h in order to fix displaying images on big endian systems.
+- Fix inserting chars in text area in big endian hardware.
+
+## v7.0.2 (16.06.2020)
+
+### Bugfixes
+- `lv_textarea` fix wrong cursor position when clicked after the last character
+- Change all text related indices from 16-bit to 32-bit integers throughout whole library. #1545
+- Fix gestures
+- Do not call `set_px_cb` for transparent pixel
+- Fix list button focus in material theme
+- Fix crash when the a text area is cleared with the backspace of a keyboard
+- Add version number to `lv_conf_template.h`
+- Add log in true double buffering mode with `set_px_cb`
+- `lv_dropdown`: fix missing `LV_EVENT_VALUE_CHANGED` event when used with encoder
+- `lv_tileview`: fix if not the {0;0} tile is created first
+- `lv_debug`: restructure to allow asserting in from `lv_misc` too
+- add assert if `_lv_mem_buf_get()` fails
+- `lv_textarea`: fix character delete in password mode
+- Update `LV_OPA_MIN` and `LV_OPA_MAX` to widen the opacity processed range
+- `lv_btnm` fix sending events for hidden buttons
+- `lv_gaguge` make `lv_gauge_set_angle_offset` offset the labels and needles too
+- Fix typo in the API `scrllable` -> `scrollable`
+- `tabview` by default allow auto expanding the page only to right and bottom (#1573)
+- fix crash when drawing gradient to the same color
+- chart: fix memory leak
+- `img`: improve hit test for transformed images
+
+## v7.0.1 (01.06.2020)
+
+### Bugfixes
+- Make the Microptyhon working by adding the required variables as GC_ROOT
+- Prefix some internal API functions with `_` to reduce the API of LVGL
+- Fix built-in SimSun CJK font
+- Fix UTF-8 encoding when `LV_USE_ARABIC_PERSIAN_CHARS` is enabled
+- Fix DMA2D usage when 32 bit images directly blended
+- 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 additional 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_template.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.

CMakeLists.txt

@@ -0,0 +1,64 @@
+if(ESP_PLATFORM)
+
+file(GLOB_RECURSE SOURCES src/*.c)
+
+idf_component_register(SRCS ${SOURCES}
+                       INCLUDE_DIRS . src
+                       REQUIRES main)
+
+target_compile_definitions(${COMPONENT_LIB} PUBLIC "-DLV_CONF_INCLUDE_SIMPLE")
+
+if (CONFIG_LV_MEM_CUSTOM)
+    if (CONFIG_LV_MEM_CUSTOM_ALLOC)
+        target_compile_definitions(${COMPONENT_LIB} PUBLIC "-DLV_MEM_CUSTOM_ALLOC=${CONFIG_LV_MEM_CUSTOM_ALLOC}")
+    endif()
+
+    if (CONFIG_LV_MEM_CUSTOM_FREE)
+        target_compile_definitions(${COMPONENT_LIB} PUBLIC "-DLV_MEM_CUSTOM_FREE=${CONFIG_LV_MEM_CUSTOM_FREE}")
+    endif()
+endif()
+
+if (CONFIG_LV_TICK_CUSTOM)
+    if (CONFIG_LV_TICK_CUSTOM_SYS_TIME_EXPR)
+        target_compile_definitions(${COMPONENT_LIB} PUBLIC "-DLV_TICK_CUSTOM_SYS_TIME_EXPR=${CONFIG_LV_TICK_CUSTOM_SYS_TIME_EXPR}")
+    endif()
+endif()
+
+if (CONFIG_LV_USER_DATA_FREE)
+    target_compile_definitions(${COMPONENT_LIB} PUBLIC "-DLV_USER_DATA_FREE=${CONFIG_LV_USER_DATA_FREE}")
+endif()
+
+if (CONFIG_LV_ATTRIBUTE_FAST_MEM_USE_IRAM)
+    target_compile_definitions(${COMPONENT_LIB} PUBLIC "-DLV_ATTRIBUTE_FAST_MEM=IRAM_ATTR")
+endif()
+
+elseif(ZEPHYR_BASE)
+
+if(CONFIG_LVGL)
+
+zephyr_include_directories(${ZEPHYR_BASE}/lib/gui/lvgl)
+
+target_include_directories(lvgl INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})
+
+zephyr_compile_definitions(LV_CONF_KCONFIG_EXTERNAL_INCLUDE=<autoconf.h>)
+
+zephyr_compile_definitions_ifdef(CONFIG_LV_MEM_CUSTOM
+    LV_MEM_CUSTOM_ALLOC=${CONFIG_LV_MEM_CUSTOM_ALLOC}
+    )
+zephyr_compile_definitions_ifdef(CONFIG_LV_MEM_CUSTOM
+    LV_MEM_CUSTOM_FREE=${CONFIG_LV_MEM_CUSTOM_FREE}
+    )
+zephyr_compile_definitions_ifdef(CONFIG_LV_TICK_CUSTOM
+    LV_TICK_CUSTOM_SYS_TIME_EXPR=${CONFIG_LV_TICK_CUSTOM_SYS_TIME_EXPR}
+    )
+
+zephyr_library()
+
+file(GLOB_RECURSE SOURCES src/*.c)
+zephyr_library_sources(${SOURCES})
+
+endif() # CONFIG_LVGL
+
+else()
+message(FATAL_ERROR "Unknown platform.")
+endif()

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,89 +1,161 @@
-# LittleV Graphics Libraray
+<h1 align="center"> LVGL - Light and Versatile Graphics Library</h1>
 
-![LittlevGL cover](http://www.gl.littlev.hu/home/main_cover.png)
+<p align="center">
+<img src="https://lvgl.io/assets/images/img_1.png">
+</p>
 
-The LittlevGL is a graphics library which allows you to create graphical user interfaces (GUI) from the most simple monochrome designs to amazing GUIs for high resolution TFTs. No double buffering is required to use transparency and smooth animations.
+<p align="center">
+LVGL provides everything you need to create embedded GUI with easy-to-use graphical elements, beautiful visual effects and low memory footprint.
+</p>
 
-The graphics library is written in C and it is completely hardware independent. You can even run it in a PC simulator without any embedded hardware.
+<h4 align="center">
+<a href="https://lvgl.io">Website </a> &middot;
+<a href="https://lvgl.io/demos">Online demo</a> &middot;
+<a href="https://lvgl.github.io/lv_examples/">Nightly demos</a> &middot;
+<a href="https://docs.lvgl.io/">Docs</a> &middot;
+<a href="https://forum.lvgl.io">Forum</a>
+</h4>
 
-Visit the http://gl.littlev.hu
+---
 
-## Key features
-* Hardware independent
-* Support any modern microcontroller
-* No external RAM, FPU or GPU required
-* High resolution TFTs and monochrome displays are also supported
-* Scalable and modular
-* Clear and well-structured source code
-* Color depth options: 24 bit, 16 bit, 8 bot or 1 bit
-* Build GUI from simple graphical objects
-  * Buttons, Labels, Images
-  * Charts, Lists, Bars, Sliders, Text areas etc.
-* High level graphical features:
-  * Antialiassing (font or full screen)
-  * Animations
-  * Transparency
-  * Gradient colors
-  * Smooth dragging and scrolling
-* Layers
-* Customizable appearance with styles
-* Applications for complex tasks
-* Can run in a PC simulator
-* Actively developed
-
-## Porting
-The following functions has to be provided
-* hal/disp `disp_fill(x1, y1, x2, y2, color)` to fill area with a color
-* hal/disp `disp_map(x1, y1, x2, y2, &color_array)` copy a color map to an area
-* hal/indev `indev_get(id, &x, &y)` get the *x* and *y* coordinates from an input device (e.g. touch pad)
-* hal/systick `systick_get()` get a system tick with 1 ms resolution
-* hal/systick `systick_elapse(prev_time)` get the elapsed milliseconds sience *prev_time*
-
-See the [example HAL](https://github.com/littlevgl/hal) repository!
+## Features
+* Powerful [building blocks](https://docs.lvgl.io/latest/en/html/widgets/index.html): buttons, charts, lists, sliders, images, etc.
+* Advanced graphics: animations, anti-aliasing, opacity, smooth scrolling
+* Use [various input devices](https://docs.lvgl.io/latest/en/html/overview/indev.html): touchscreen, mouse, keyboard, encoder, buttons, etc.
+* Use [multiple displays](https://docs.lvgl.io/latest/en/html/overview/display.html): e.g. monochrome and color display
+* Hardware independent to use with any microcontroller or display
+* Scalable to operate with little memory (64 kB Flash, 10 kB RAM)
+* Multi-language support with UTF-8 handling, Bidirectional and Arabic script support
+* Fully customizable graphical elements via [CSS-like styles](https://docs.lvgl.io/latest/en/html/overview/style.html)
+* OS, External memory and GPU are supported but not required
+* Smooth rendering even with a [single frame buffer](https://docs.lvgl.io/latest/en/html/porting/display.html)
+* Written in C for maximal compatibility (C++ compatible)
+* Micropython Binding exposes [LVGL API in Micropython](https://blog.lvgl.io/2019-02-20/micropython-bindings)
+* [Simulator](https://docs.lvgl.io/latest/en/html/get-started/pc-simulator.html) to develop on PC without embedded hardware
+* [Examples](lv_examples) and tutorials for rapid development
+* [Documentation](http://docs.lvgl.io/) and API references
 
 ## Requirements
-* [Misc. library](https://github.com/littlevgl/misc) is used by the graphics library
+Basically, every modern controller (which is able to drive a display) is suitable to run LVGL. The minimal requirements are:
 
-## Project set-up
-1. Clone or download the following repositories:
-   * lvgl:`git clone https://github.com/littlevgl/lvgl.git`  
-   * misc: `git clone https://github.com/littlevgl/misc.git` 
-   * hal: `git clone https://github.com/littlevgl/hal.git`
-2. Create project with your prefered IDE and add the **lvgl**, **misc** and **hal** folders 
-3. Add your projects **root directory as include path** 
-4. Write your display, touch pad and system tick **drivers in hal**
-5. Copy *lvgl/lv_conf_templ.h* as **lv_conf.h** and *misc/misc_conf_templ.h* as **misc_conf.h** to the projects root folder
-6. In the *_conf.h files delete the first `#if 0` and its `#endif`. Let the default configurations at first.
-7. In your *main.c* file include: 
-   * #include "misc/misc.h" 
-   * #include "misc/os/ptask.h"
-   * #include "lvgl/lvgl.h"   
-8. In your *main.c* intialize:
-   * **misc_init()**;
-   * your_systick_init();
-   * your_disp_init();
-   * your_indev_init();
-   * **lvgl_init()**;
-10. To **test** create a label: `lv_obj_t * label = lv_label_create(lv_scr_act(), NULL);`  
-11. In the main *while(1)* call `ptask_handler();` and make a few milliseconds delay (e.g. `your_delay_ms(5);`) 
-12. Compile the code and load it to your embedded hardware
+<table>
+  <tr>
+    <td> <strong>Name</strong> </td>
+    <td><strong>Minimal</strong></td>
+    <td><strong>Recommended</strong></td>
+  </tr>
+  <tr>
+    <td><strong>Architecture</strong></td>
+    <td colspan="2">16, 32 or 64 bit microcontroller or processor</td>
+  </tr>
+  <tr>
+    <td> <strong>Clock</strong></td>
+    <td> &gt; 16 MHz </td>
+    <td> &gt; 48 MHz</td>
+  </tr>
 
-## PC Simulator
-If you don't have got an embedded hardware you can test the graphics library in a PC simulator. The simulator uses [SDL2](https://www.libsdl.org/) to emulate a display on your monitor and a touch pad with your mouse.
+  <tr>
+    <td> <strong>Flash/ROM</strong></td>
+    <td> &gt; 64 kB </td>
+    <td> &gt; 180 kB</td>
+  </tr>
 
-There is a pre-configured PC project for **Eclipse CDT** in this repository: https://github.com/littlevgl/proj_pc
+  <tr>
+    <td> <strong>Static RAM</strong></td>
+    <td> &gt; 2 kB </td>
+    <td> &gt; 4 kB</td>
+  </tr>
+
+  <tr>
+    <td> <strong>Stack</strong></td>
+    <td> &gt; 2 kB </td>
+    <td> &gt; 8 kB</td>
+  </tr>
+
+  <tr>
+    <td> <strong>Heap</strong></td>
+    <td> &gt; 2 kB </td>
+    <td> &gt; 8 kB</td>
+  </tr>
+
+  <tr>
+    <td> <strong>Display buffer</strong></td>
+    <td> &gt; 1 &times; <em>hor. res.</em> pixels </td>
+    <td> &gt; 10 &times; <em>hor. res.</em> pixels </td>
+  </tr>
+
+  <tr>
+    <td> <strong>Compiler</strong></td>
+    <td colspan="2"> C99 or newer </td>
+  </tr>
+</table>
+
+*Note that the memory usage might vary depending on the architecture, compiler and build options.*
+
+Just to mention some platforms:
+- STM32F1, STM32F3, STM32F4, STM32F7, STM32L4, STM32L5, STM32H7
+- Microchip dsPIC33, PIC24, PIC32MX, PIC32MZ
+- 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/lvgl/lv_port_esp32)
+- [Infineon Aurix](https://github.com/lvgl/lv_port_aurix)
+- Nordic NRF52 Bluetooth modules
+- Quectel modems
+
+## Get started
+This list shows the recommended way of learning the library:
+1. Check the [Online demos](https://lvgl.io/demos) to see LVGL in action (3 minutes)
+2. Read the [Introduction](https://docs.lvgl.io/latest/en/html/intro/index.html) page of the documentation (5 minutes)
+3. Get familiar with the basics on the [Quick overview](https://docs.lvgl.io/latest/en/html/get-started/quick-overview.html) page (15 minutes)
+4. Set up a [Simulator](https://docs.lvgl.io/latest/en/html/get-started/pc-simulator.html) (10 minutes)
+5. Try out some [Examples](https://github.com/lvgl/lv_examples/)
+6. Port LVGL to a board. See the [Porting](https://docs.lvgl.io/latest/en/html/porting/index.html) guide or check the ready to use [Projects](https://github.com/lvgl?q=lv_port_&type=&language=)
+7. Read the [Overview](https://docs.lvgl.io/latest/en/html/overview/index.html) page to get a better understanding of the library (2-3 hours)
+8. Check the documentation of the [Widgets](https://docs.lvgl.io/latest/en/html/widgets/index.html) to see their features and usage
+9. If you have questions go to the [Forum](http://forum.lvgl.io/)
+10. Read the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) guide to see how you can help to improve LVGL (15 minutes)
+
+## Examples
+
+For more examples see the [lv_examples](https://github.com/lvgl/lv_examples) repository.
+
+### Button with label
+```c
+lv_obj_t * btn = lv_btn_create(lv_scr_act(), NULL);     /*Add a button to the current screen*/
+lv_obj_set_pos(btn, 10, 10);                            /*Set its position*/
+lv_obj_set_size(btn, 100, 50);                          /*Set its size*/
+lv_obj_set_event_cb(btn, btn_event_cb);                 /*Assign a callback to the button*/
+
+lv_obj_t * label = lv_label_create(btn, NULL);          /*Add a label to the button*/
+lv_label_set_text(label, "Button");                     /*Set the labels text*/
+
+...
+
+void btn_event_cb(lv_obj_t * btn, lv_event_t event)
+{
+    if(event == LV_EVENT_CLICKED) {
+        printf("Clicked\n");
+    }
+}
+```
+![LVGL button with label example](https://raw.githubusercontent.com/lvgl/docs/latest/misc/simple_button_example.gif)
+
+### LVGL from Micropython
+Learn more about [Micropython](https://docs.lvgl.io/latest/en/html/get-started/micropython.html).
+```python
+# Create a Button and a Label
+scr = lv.obj()
+btn = lv.btn(scr)
+btn.align(lv.scr_act(), lv.ALIGN.CENTER, 0, 0)
+label = lv.label(btn)
+label.set_text("Button")
+
+# Load the screen
+lv.scr_load(scr)
+```
 
 ## Contributing
-1. Fork it!
-2. Create your feature branch: `git checkout -b my-new-feature`
-3. Commit your changes: `git commit -am 'Add some feature'`
-4. Push to the branch: `git push origin my-new-feature`
-5. Submit a pull request!
-
-If you find an issue, please report it via GitHub!
-
-## Donate
-If you are pleased with the graphics library and found it useful pleas support its further development:
-
-[![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=LWHHAQYZMRQJS)
+LVGL is an open project and contribution is very welcome. There are many ways to contribute from simply speaking about your project, through writing examples, improving the documentation, fixing bugs to hosing your own project under in LVGL.
 
+For a detailed description of contribution opportunities visit the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) section of the documentation.

component.mk

@@ -0,0 +1,8 @@
+# ESP-IDF component file for make based commands
+
+ifdef $(IDF_VER)
+
+COMPONENT_SRCDIRS := .
+COMPONENT_ADD_INCLUDEDIRS := .
+
+endif

docs/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at [atom@github.com](mailto:atom@github.com). All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

docs/CODING_STYLE.md

@@ -0,0 +1,89 @@
+# Coding style
+
+## File format
+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 '_'
+* In variable and function names use only lower case letters (e.g. *height_tmp*)
+* In enums and defines use only upper case letters (e.g. *e.g. MAX_LINE_NUM*)
+* Global names (API):
+  * starts with *lv*
+  * followed by module name: *btn*, *label*, *style* etc.
+  * followed by the action (for functions): *set*, *get*, *refr* etc.
+  * closed with the subject: *name*, *size*, *state* etc.
+* Typedefs
+  * 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:
+  * 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 200 lines (except very straightforwards)
+* Variables:
+  * One line, one declaration (BAD: char x, y;)
+  * Use `<stdint.h>` (*uint8_t*, *int32_t* etc)
+  * 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)
+
+## Comments
+Before every function have a comment like this:
+
+```c
+/**
+ * Return with the screen of an object
+ * @param obj pointer to an object
+ * @return pointer to a screen
+ */
+lv_obj_t * lv_obj_get_scr(lv_obj_t * obj);
+```
+
+Always use `/* Something */` format and NOT `//Something`
+
+Write readable code to avoid descriptive comments like:
+`x++; /* Add 1 to x */`.
+The code should show clearly what you are doing.
+
+You should write **why** have you done this:
+`x++; /*Because of closing '\0' of the string */`
+
+Short "code summaries" of a few lines are accepted. E.g. `/*Calculate the new coordinates*/`
+
+In comments use \` \` when referring to a variable. E.g. ``/*Update the value of `x_act`*/``
+
+### Formatting
+Here is example to show bracket placing and using of white spaces:
+```c
+/**
+ * Set a new text for a label. Memory will be allocated to store the text by the label.
+ * @param label pointer to a label object
+ * @param text '\0' terminated character string. NULL to refresh with the current text.
+ */
+void lv_label_set_text(lv_obj_t * label, const char * text)
+{   /* Main brackets of functions in new line*/
+
+    if(label == NULL) return; /*No bracket only if the command is inline with the if statement*/
+
+    lv_obj_inv(label);
+
+    lv_label_ext_t * ext = lv_obj_get_ext(label);
+
+    /*Comment before a section */
+    if(text == ext->txt || text == NULL) {  /*Bracket of statements start inline*/
+        lv_label_refr_text(label);
+        return;
+    }
+
+    ...
+}
+```
+
+Use 4 spaces indentation instead of tab.
+
+You can use **astyle** to format the code. Run `code-formatter.sh` from the `scrips` folder.

docs/CONTRIBUTING.md

@@ -0,0 +1,5 @@
+# Contributing to LVGL
+
+Thank you for considering contributing to LVGL.
+
+For a detailed description of contribution opportunities, please visit the [Contributing](https://docs.lvgl.io/latest/en/html/contributing/index.html) section of the documentation.

docs/ROADMAP.md

@@ -0,0 +1,63 @@
+# Roadmap
+
+This is a summary for thenew fatures of the major releases and a collection of ideas.
+
+This list indicates only the current intention and can be changed.
+
+## v8
+Planned to November/December 2020
+- Create an `lv_components` repository for compley widgets
+   - It makes the core LVGL leaner
+   - In `lv_components` we can have a lot and specific widgets
+   - Good place for contribution
+- New scrolling:
+  - See [feat/new-scroll](https://github.com/lvgl/lvgl/tree/feat/new-scroll) branch and  [#1614](https://github.com/lvgl/lvgl/issues/1614)) issue.
+  - Remove `lv_page` and support scrolling on `lv_obj`
+  - Support "elastic" scrolling when scrolled in
+  - Support scroll chaining among any objects types (not only `lv_pages`s)
+  - Remove `lv_drag`. Similar effect can be achieved by setting the position in `LV_EVENT_PRESSING`
+  - Add snapping
+  - Add snap stop to scroll max 1 snap point
+  - Already working
+- New layouts:
+  - See [#1615](https://github.com/lvgl/lvgl/issues/1615) issue
+  - [CSS Grid](https://css-tricks.com/snippets/css/a-guide-to-grid/)-like layout support
+  - [CSS Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/)-like layout support
+  - Remove `lv_cont` and support layouts on `lv_obj`
+- Simplified File system interface ([feat/new_fs_api](https://github.com/lvgl/lvgl/tree/feat/new-fs-api) branch) to make porting easier
+  - Work in progress
+- Remove the align parameter from `lv_canvas_draw_text`
+- Make the copy parameter obsolate in create functions
+- Optimize and simplifie styles [#1832](https://github.com/lvgl/lvgl/issues/1832)
+- Use a more generic inheritenace [#1919](https://github.com/lvgl/lvgl/issues/1919)
+
+## v8.x
+- Add radio button widget
+- Unit testing (gtest?). See [#1658](https://github.com/lvgl/lvgl/issues/1658)
+- Benchmarking (gem5?). See [#1660](https://github.com/lvgl/lvgl/issues/1660)
+- chart: pre-delete `X` pint after the lastly set
+- chart: autoscroll to the right
+
+## v9
+- Simplify `group`s. Discussion is [here](https://forum.lvgl.io/t/lv-group-tabindex/2927/3).
+- Consider direct binary font format support
+- Optimize line and circle drawing and masking
+- Reconsider color format management for run time color format setting, and custom color format usage. (Also [RGB888](https://github.com/lvgl/lvgl/issues/1722))
+- 9-patch support for `lv_imgbtn`.
+- Handle stride. See [#1858](https://github.com/lvgl/lvgl/issues/1858)
+- Make gradients more versatile
+- Make image transformations more versatile
+- Allow snapshoting object to tranfrom them to images
+
+## Ideas
+- Use [generate-changelog](https://github.com/lob/generate-changelog) to automatically generate changelog
+- lv_mem_alloc_aligned(size, align)
+- Text node. See [#1701](https://github.com/lvgl/lvgl/issues/1701#issuecomment-699479408)
+- CPP binding. See [Forum](https://forum.lvgl.io/t/is-it-possible-to-officially-support-optional-cpp-api/2736)
+- Optimize font decompression
+- Switch to RGBA colors in styles
+- Need coverage report for tests
+- Need static analyze (via coverity.io or somehing else)
+- Support dot_begin and dot_middle long modes for labels
+- Add new label alignment modes. [#1656](https://github.com/lvgl/lvgl/issues/1656)
+- Support larger images: [#1892](https://github.com/lvgl/lvgl/issues/1892)

examples/LVGL_Arduino.ino

@@ -0,0 +1,102 @@
+#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;
+    } else {
+      data->state = LV_INDEV_STATE_PR;
+	
+      /*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/porting/lv_port_disp_template.c

@@ -0,0 +1,196 @@
+/**
+ * @file lv_port_disp_templ.c
+ *
+ */
+
+ /*Copy this file as "lv_port_disp.c" and set this value to "1" to enable content*/
+#if 0
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_port_disp_template.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void disp_init(void);
+
+static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p);
+#if LV_USE_GPU
+static void gpu_blend(lv_disp_drv_t * disp_drv, lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa);
+static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
+        const lv_area_t * fill_area, lv_color_t color);
+#endif
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_port_disp_init(void)
+{
+    /*-------------------------
+     * Initialize your display
+     * -----------------------*/
+    disp_init();
+
+    /*-----------------------------
+     * Create a buffer for drawing
+     *----------------------------*/
+
+    /* LVGL requires a buffer where it internally draws the widgets.
+     * Later this buffer will passed your display drivers `flush_cb` to copy its content to your display.
+     * The buffer has to be greater than 1 display row
+     *
+     * There are three buffering configurations:
+     * 1. Create ONE buffer with some rows:
+     *      LVGL will draw the display's content here and writes it to your display
+     *
+     * 2. Create TWO buffer with some rows:
+     *      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 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 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.
+     * */
+
+    /* Example for 1) */
+    static lv_disp_buf_t draw_buf_dsc_1;
+    static lv_color_t draw_buf_1[LV_HOR_RES_MAX * 10];                          /*A buffer for 10 rows*/
+    lv_disp_buf_init(&draw_buf_dsc_1, draw_buf_1, NULL, LV_HOR_RES_MAX * 10);   /*Initialize the display buffer*/
+
+    /* Example for 2) */
+    static lv_disp_buf_t draw_buf_dsc_2;
+    static lv_color_t draw_buf_2_1[LV_HOR_RES_MAX * 10];                        /*A buffer for 10 rows*/
+    static lv_color_t draw_buf_2_1[LV_HOR_RES_MAX * 10];                        /*An other buffer for 10 rows*/
+    lv_disp_buf_init(&draw_buf_dsc_2, draw_buf_2_1, draw_buf_2_1, LV_HOR_RES_MAX * 10);   /*Initialize the display buffer*/
+
+    /* Example for 3) */
+    static lv_disp_buf_t draw_buf_dsc_3;
+    static lv_color_t draw_buf_3_1[LV_HOR_RES_MAX * LV_VER_RES_MAX];            /*A screen sized buffer*/
+    static lv_color_t draw_buf_3_1[LV_HOR_RES_MAX * LV_VER_RES_MAX];            /*An other screen sized buffer*/
+    lv_disp_buf_init(&draw_buf_dsc_3, draw_buf_3_1, draw_buf_3_2, LV_HOR_RES_MAX * LV_VER_RES_MAX);   /*Initialize the display buffer*/
+
+    /*-----------------------------------
+     * Register the display in LVGL
+     *----------------------------------*/
+
+    lv_disp_drv_t disp_drv;                         /*Descriptor of a display driver*/
+    lv_disp_drv_init(&disp_drv);                    /*Basic initialization*/
+
+    /*Set up the functions to access to your display*/
+
+    /*Set the resolution of the display*/
+    disp_drv.hor_res = 480;
+    disp_drv.ver_res = 320;
+
+    /*Used to copy the buffer's content to the display*/
+    disp_drv.flush_cb = disp_flush;
+
+    /*Set a display buffer*/
+    disp_drv.buffer = &draw_buf_dsc_1;
+
+#if LV_USE_GPU
+    /*Optionally add functions to access the GPU. (Only in buffered mode, LV_VDB_SIZE != 0)*/
+
+    /*Blend two color array using opacity*/
+    disp_drv.gpu_blend_cb = gpu_blend;
+
+    /*Fill a memory array with a color*/
+    disp_drv.gpu_fill_cb = gpu_fill;
+#endif
+
+    /*Finally register the driver*/
+    lv_disp_drv_register(&disp_drv);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/* Initialize your display and the required peripherals. */
+static void disp_init(void)
+{
+    /*You code here*/
+}
+
+/* Flush the content of the internal buffer the specific area on the display
+ * You can use DMA or any hardware acceleration to do this operation in the background but
+ * 'lv_disp_flush_ready()' has to be called when finished. */
+static void disp_flush(lv_disp_drv_t * disp_drv, const lv_area_t * area, lv_color_t * color_p)
+{
+    /*The most simple case (but also the slowest) to put all pixels to the screen one-by-one*/
+
+    int32_t x;
+    int32_t y;
+    for(y = area->y1; y <= area->y2; y++) {
+        for(x = area->x1; x <= area->x2; x++) {
+            /* Put a pixel to the display. For example: */
+            /* put_px(x, y, *color_p)*/
+            color_p++;
+        }
+    }
+
+    /* IMPORTANT!!!
+     * Inform the graphics library that you are ready with the flushing*/
+    lv_disp_flush_ready(disp_drv);
+}
+
+/*OPTIONAL: GPU INTERFACE*/
+#if LV_USE_GPU
+
+/* If your MCU has hardware accelerator (GPU) then you can use it to blend to memories using opacity
+ * It can be used only in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/
+static void gpu_blend(lv_disp_drv_t * disp_drv, lv_color_t * dest, const lv_color_t * src, uint32_t length, lv_opa_t opa)
+{
+    /*It's an example code which should be done by your GPU*/
+    uint32_t i;
+    for(i = 0; i < length; i++) {
+        dest[i] = lv_color_mix(dest[i], src[i], opa);
+    }
+}
+
+/* If your MCU has hardware accelerator (GPU) then you can use it to fill a memory with a color
+ * It can be used only in buffered mode (LV_VDB_SIZE != 0 in lv_conf.h)*/
+static void gpu_fill(lv_disp_drv_t * disp_drv, lv_color_t * dest_buf, lv_coord_t dest_width,
+                    const lv_area_t * fill_area, lv_color_t color)
+{
+    /*It's an example code which should be done by your GPU*/
+    int32_t x, y;
+    dest_buf += dest_width * fill_area->y1; /*Go to the first line*/
+
+    for(y = fill_area->y1; y <= fill_area->y2; y++) {
+        for(x = fill_area->x1; x <= fill_area->x2; x++) {
+            dest_buf[x] = color;
+        }
+        dest_buf+=dest_width;    /*Go to the next line*/
+    }
+}
+
+#endif  /*LV_USE_GPU*/
+
+#else /* Enable this file at the top */
+
+/* This dummy typedef exists purely to silence -Wpedantic. */
+typedef int keep_pedantic_happy;
+#endif

examples/porting/lv_port_disp_template.h

@@ -0,0 +1,43 @@
+/**
+ * @file lv_port_disp_templ.h
+ *
+ */
+
+ /*Copy this file as "lv_port_disp.h" and set this value to "1" to enable content*/
+#if 0
+
+#ifndef LV_PORT_DISP_TEMPL_H
+#define LV_PORT_DISP_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lvgl/lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_PORT_DISP_TEMPL_H*/
+
+#endif /*Disable/Enable content*/

examples/porting/lv_port_fs_template.c

@@ -0,0 +1,377 @@
+/**
+ * @file lv_port_fs_templ.c
+ *
+ */
+
+ /*Copy this file as "lv_port_fs.c" and set this value to "1" to enable content*/
+#if 0
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_port_fs_template.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/* Create a type to store the required data about your file.
+ * If you are using a File System library
+ * it already should have a File type.
+ * For example FatFS has `FIL`. In this case use `typedef FIL file_t`*/
+typedef struct {
+    /*Add the data you need to store about a file*/
+    uint32_t dummy1;
+    uint32_t dummy2;
+}file_t;
+
+/*Similarly to `file_t` create a type for directory reading too */
+typedef struct {
+    /*Add the data you need to store about directory reading*/
+    uint32_t dummy1;
+    uint32_t dummy2;
+}dir_t;
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+static void fs_init(void);
+
+static lv_fs_res_t fs_open (lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode);
+static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p);
+static lv_fs_res_t fs_read (lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+static lv_fs_res_t fs_seek (lv_fs_drv_t * drv, void * file_p, uint32_t pos);
+static lv_fs_res_t fs_size (lv_fs_drv_t * drv, void * file_p, uint32_t * size_p);
+static lv_fs_res_t fs_tell (lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
+static lv_fs_res_t fs_remove (lv_fs_drv_t * drv, const char *path);
+static lv_fs_res_t fs_trunc (lv_fs_drv_t * drv, void * file_p);
+static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const char * newname);
+static lv_fs_res_t fs_free (lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * free_p);
+static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * rddir_p, const char *path);
+static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * rddir_p, char *fn);
+static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * rddir_p);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_port_fs_init(void)
+{
+    /*----------------------------------------------------
+     * Initialize your storage device and File System
+     * -------------------------------------------------*/
+    fs_init();
+
+    /*---------------------------------------------------
+     * Register the file system interface in LVGL
+     *--------------------------------------------------*/
+
+    /* Add a simple drive to open images */
+    lv_fs_drv_t fs_drv;
+    lv_fs_drv_init(&fs_drv);
+
+    /*Set up fields...*/
+    fs_drv.file_size = sizeof(file_t);
+    fs_drv.letter = 'P';
+    fs_drv.open_cb = fs_open;
+    fs_drv.close_cb = fs_close;
+    fs_drv.read_cb = fs_read;
+    fs_drv.write_cb = fs_write;
+    fs_drv.seek_cb = fs_seek;
+    fs_drv.tell_cb = fs_tell;
+    fs_drv.free_space_cb = fs_free;
+    fs_drv.size_cb = fs_size;
+    fs_drv.remove_cb = fs_remove;
+    fs_drv.rename_cb = fs_rename;
+    fs_drv.trunc_cb = fs_trunc;
+
+    fs_drv.rddir_size = sizeof(dir_t);
+    fs_drv.dir_close_cb = fs_dir_close;
+    fs_drv.dir_open_cb = fs_dir_open;
+    fs_drv.dir_read_cb = fs_dir_read;
+
+    lv_fs_drv_register(&fs_drv);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/* Initialize your Storage device and File system. */
+static void fs_init(void)
+{
+    /*E.g. for FatFS initialize the SD card and FatFS itself*/
+
+    /*You code here*/
+}
+
+/**
+ * Open a file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a file_t variable
+ * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
+ * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_open (lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    if(mode == LV_FS_MODE_WR)
+    {
+        /*Open a file for write*/
+
+        /* Add your code here*/
+    }
+    else if(mode == LV_FS_MODE_RD)
+    {
+        /*Open a file for read*/
+
+        /* Add your code here*/
+    }
+    else if(mode == (LV_FS_MODE_WR | LV_FS_MODE_RD))
+    {
+        /*Open a file for read and write*/
+
+        /* Add your code here*/
+    }
+
+    return res;
+}
+
+/**
+ * Close an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a file_t variable. (opened with lv_ufs_open)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Read data from an opened file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a file_t variable.
+ * @param buf pointer to a memory block where to store the read data
+ * @param btr number of Bytes To Read
+ * @param br the real number of read bytes (Byte Read)
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_read (lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Write into a file
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a file_t variable
+ * @param buf pointer to a buffer with the bytes to write
+ * @param btr Bytes To Write
+ * @param br the number of real written bytes (Bytes Written). NULL if unused.
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Set the read write pointer. Also expand the file size if necessary.
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a file_t variable. (opened with lv_ufs_open )
+ * @param pos the new position of read write pointer
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_seek (lv_fs_drv_t * drv, void * file_p, uint32_t pos)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Give the size of a file bytes
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a file_t variable
+ * @param size pointer to a variable to store the size
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_size (lv_fs_drv_t * drv, void * file_p, uint32_t * size_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+/**
+ * Give the position of the read write pointer
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to a file_t variable.
+ * @param pos_p pointer to to store the result
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_tell (lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Delete a file
+ * @param drv pointer to a driver where this function belongs
+ * @param path path of the file to delete
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_remove (lv_fs_drv_t * drv, const char *path)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Truncate the file size to the current position of the read write pointer
+ * @param drv pointer to a driver where this function belongs
+ * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_fs_open )
+ * @return LV_FS_RES_OK: no error, the file is read
+ *         any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_trunc (lv_fs_drv_t * drv, void * file_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Rename a file
+ * @param drv pointer to a driver where this function belongs
+ * @param oldname path to the file
+ * @param newname path with the new name
+ * @return LV_FS_RES_OK or any error from 'fs_res_t'
+ */
+static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const char * newname)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Get the free and total size of a driver in kB
+ * @param drv pointer to a driver where this function belongs
+ * @param letter the driver letter
+ * @param total_p pointer to store the total size [kB]
+ * @param free_p pointer to store the free size [kB]
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_free (lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * free_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Initialize a 'lv_fs_dir_t' variable for directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param rddir_p pointer to a 'lv_fs_dir_t' variable
+ * @param path path to a directory
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * rddir_p, const char *path)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Read the next filename form a directory.
+ * The name of the directories will begin with '/'
+ * @param drv pointer to a driver where this function belongs
+ * @param rddir_p pointer to an initialized 'lv_fs_dir_t' variable
+ * @param fn pointer to a buffer to store the filename
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * rddir_p, char *fn)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+/**
+ * Close the directory reading
+ * @param drv pointer to a driver where this function belongs
+ * @param rddir_p pointer to an initialized 'lv_fs_dir_t' variable
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
+ */
+static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * rddir_p)
+{
+    lv_fs_res_t res = LV_FS_RES_NOT_IMP;
+
+    /* Add your code here*/
+
+    return res;
+}
+
+#else /* Enable this file at the top */
+
+/* This dummy typedef exists purely to silence -Wpedantic. */
+typedef int keep_pedantic_happy;
+#endif

examples/porting/lv_port_fs_template.h

@@ -0,0 +1,43 @@
+/**
+ * @file lv_port_fs_templ.h
+ *
+ */
+
+ /*Copy this file as "lv_port_fs.h" and set this value to "1" to enable content*/
+#if 0
+
+#ifndef LV_PORT_FS_TEMPL_H
+#define LV_PORT_FS_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lvgl/lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_PORT_FS_TEMPL_H*/
+
+#endif /*Disable/Enable content*/

examples/porting/lv_port_indev_template.c

@@ -0,0 +1,423 @@
+/**
+ * @file lv_port_indev_templ.c
+ *
+ */
+
+ /*Copy this file as "lv_port_indev.c" and set this value to "1" to enable content*/
+#if 0
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lv_port_indev_template.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ *  STATIC PROTOTYPES
+ **********************/
+
+static void touchpad_init(void);
+static bool touchpad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
+static bool touchpad_is_pressed(void);
+static void touchpad_get_xy(lv_coord_t * x, lv_coord_t * y);
+
+static void mouse_init(void);
+static bool mouse_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
+static bool mouse_is_pressed(void);
+static void mouse_get_xy(lv_coord_t * x, lv_coord_t * y);
+
+static void keypad_init(void);
+static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
+static uint32_t keypad_get_key(void);
+
+static void encoder_init(void);
+static bool encoder_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
+static void encoder_handler(void);
+
+static void button_init(void);
+static bool button_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data);
+static int8_t button_get_pressed_id(void);
+static bool button_is_pressed(uint8_t id);
+
+/**********************
+ *  STATIC VARIABLES
+ **********************/
+lv_indev_t * indev_touchpad;
+lv_indev_t * indev_mouse;
+lv_indev_t * indev_keypad;
+lv_indev_t * indev_encoder;
+lv_indev_t * indev_button;
+
+static int32_t encoder_diff;
+static lv_indev_state_t encoder_state;
+
+/**********************
+ *      MACROS
+ **********************/
+
+/**********************
+ *   GLOBAL FUNCTIONS
+ **********************/
+
+void lv_port_indev_init(void)
+{
+    /* Here you will find example implementation of input devices supported by LittelvGL:
+     *  - Touchpad
+     *  - Mouse (with cursor support)
+     *  - Keypad (supports GUI usage only with key)
+     *  - Encoder (supports GUI usage only with: left, right, push)
+     *  - Button (external buttons to press points on the screen)
+     *
+     *  The `..._read()` function are only examples.
+     *  You should shape them according to your hardware
+     */
+
+    lv_indev_drv_t indev_drv;
+
+    /*------------------
+     * Touchpad
+     * -----------------*/
+
+    /*Initialize your touchpad if you have*/
+    touchpad_init();
+
+    /*Register a touchpad input device*/
+    lv_indev_drv_init(&indev_drv);
+    indev_drv.type = LV_INDEV_TYPE_POINTER;
+    indev_drv.read_cb = touchpad_read;
+    indev_touchpad = lv_indev_drv_register(&indev_drv);
+
+    /*------------------
+     * Mouse
+     * -----------------*/
+
+    /*Initialize your touchpad if you have*/
+    mouse_init();
+
+    /*Register a mouse input device*/
+    lv_indev_drv_init(&indev_drv);
+    indev_drv.type = LV_INDEV_TYPE_POINTER;
+    indev_drv.read_cb = mouse_read;
+    indev_mouse = lv_indev_drv_register(&indev_drv);
+
+    /*Set cursor. For simplicity set a HOME symbol now.*/
+    lv_obj_t * mouse_cursor = lv_img_create(lv_disp_get_scr_act(NULL), NULL);
+    lv_img_set_src(mouse_cursor, LV_SYMBOL_HOME);
+    lv_indev_set_cursor(indev_mouse, mouse_cursor);
+
+    /*------------------
+     * Keypad
+     * -----------------*/
+
+    /*Initialize your keypad or keyboard if you have*/
+    keypad_init();
+
+    /*Register a keypad input device*/
+    lv_indev_drv_init(&indev_drv);
+    indev_drv.type = LV_INDEV_TYPE_KEYPAD;
+    indev_drv.read_cb = keypad_read;
+    indev_keypad = lv_indev_drv_register(&indev_drv);
+
+    /* Later you should create group(s) with `lv_group_t * group = lv_group_create()`,
+     * add objects to the group with `lv_group_add_obj(group, obj)`
+     * and assign this input device to group to navigate in it:
+     * `lv_indev_set_group(indev_keypad, group);` */
+
+    /*------------------
+     * Encoder
+     * -----------------*/
+
+    /*Initialize your encoder if you have*/
+    encoder_init();
+
+    /*Register a encoder input device*/
+    lv_indev_drv_init(&indev_drv);
+    indev_drv.type = LV_INDEV_TYPE_ENCODER;
+    indev_drv.read_cb = encoder_read;
+    indev_encoder = lv_indev_drv_register(&indev_drv);
+
+    /* Later you should create group(s) with `lv_group_t * group = lv_group_create()`,
+     * add objects to the group with `lv_group_add_obj(group, obj)`
+     * and assign this input device to group to navigate in it:
+     * `lv_indev_set_group(indev_encoder, group);` */
+
+    /*------------------
+     * Button
+     * -----------------*/
+
+    /*Initialize your button if you have*/
+    button_init();
+
+    /*Register a button input device*/
+    lv_indev_drv_init(&indev_drv);
+    indev_drv.type = LV_INDEV_TYPE_BUTTON;
+    indev_drv.read_cb = button_read;
+    indev_button = lv_indev_drv_register(&indev_drv);
+
+    /*Assign buttons to points on the screen*/
+    static const lv_point_t btn_points[2] = {
+            {10, 10},   /*Button 0 -> x:10; y:10*/
+            {40, 100},  /*Button 1 -> x:40; y:100*/
+    };
+    lv_indev_set_button_points(indev_button, btn_points);
+}
+
+/**********************
+ *   STATIC FUNCTIONS
+ **********************/
+
+/*------------------
+ * Touchpad
+ * -----------------*/
+
+/*Initialize your touchpad*/
+static void touchpad_init(void)
+{
+    /*Your code comes here*/
+}
+
+/* Will be called by the library to read the touchpad */
+static bool touchpad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
+{
+    static lv_coord_t last_x = 0;
+    static lv_coord_t last_y = 0;
+
+    /*Save the pressed coordinates and the state*/
+    if(touchpad_is_pressed()) {
+        touchpad_get_xy(&last_x, &last_y);
+        data->state = LV_INDEV_STATE_PR;
+    } else {
+        data->state = LV_INDEV_STATE_REL;
+    }
+
+    /*Set the last pressed coordinates*/
+    data->point.x = last_x;
+    data->point.y = last_y;
+
+    /*Return `false` because we are not buffering and no more data to read*/
+    return false;
+}
+
+/*Return true is the touchpad is pressed*/
+static bool touchpad_is_pressed(void)
+{
+    /*Your code comes here*/
+
+    return false;
+}
+
+/*Get the x and y coordinates if the touchpad is pressed*/
+static void touchpad_get_xy(lv_coord_t * x, lv_coord_t * y)
+{
+    /*Your code comes here*/
+
+    (*x) = 0;
+    (*y) = 0;
+}
+
+/*------------------
+ * Mouse
+ * -----------------*/
+
+/* Initialize your mouse */
+static void mouse_init(void)
+{
+    /*Your code comes here*/
+}
+
+/* Will be called by the library to read the mouse */
+static bool mouse_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
+{
+    /*Get the current x and y coordinates*/
+    mouse_get_xy(&data->point.x, &data->point.y);
+
+    /*Get whether the mouse button is pressed or released*/
+    if(mouse_is_pressed()) {
+        data->state = LV_INDEV_STATE_PR;
+    } else {
+        data->state = LV_INDEV_STATE_REL;
+    }
+
+    /*Return `false` because we are not buffering and no more data to read*/
+    return false;
+}
+
+/*Return true is the mouse button is pressed*/
+static bool mouse_is_pressed(void)
+{
+    /*Your code comes here*/
+
+    return false;
+}
+
+/*Get the x and y coordinates if the mouse is pressed*/
+static void mouse_get_xy(lv_coord_t * x, lv_coord_t * y)
+{
+    /*Your code comes here*/
+
+    (*x) = 0;
+    (*y) = 0;
+}
+
+/*------------------
+ * Keypad
+ * -----------------*/
+
+/* Initialize your keypad */
+static void keypad_init(void)
+{
+    /*Your code comes here*/
+}
+
+/* Will be called by the library to read the mouse */
+static bool keypad_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
+{
+    static uint32_t last_key = 0;
+
+    /*Get the current x and y coordinates*/
+    mouse_get_xy(&data->point.x, &data->point.y);
+
+    /*Get whether the a key is pressed and save the pressed key*/
+    uint32_t act_key = keypad_get_key();
+    if(act_key != 0) {
+        data->state = LV_INDEV_STATE_PR;
+
+        /*Translate the keys to LVGL control characters according to your key definitions*/
+        switch(act_key) {
+        case 1:
+            act_key = LV_KEY_NEXT;
+            break;
+        case 2:
+            act_key = LV_KEY_PREV;
+            break;
+        case 3:
+            act_key = LV_KEY_LEFT;
+            break;
+        case 4:
+            act_key = LV_KEY_RIGHT;
+            break;
+        case 5:
+            act_key = LV_KEY_ENTER;
+            break;
+        }
+
+        last_key = act_key;
+    } else {
+        data->state = LV_INDEV_STATE_REL;
+    }
+
+    data->key = last_key;
+
+    /*Return `false` because we are not buffering and no more data to read*/
+    return false;
+}
+
+/*Get the currently being pressed key.  0 if no key is pressed*/
+static uint32_t keypad_get_key(void)
+{
+    /*Your code comes here*/
+
+    return 0;
+}
+
+/*------------------
+ * Encoder
+ * -----------------*/
+
+/* Initialize your keypad */
+static void encoder_init(void)
+{
+    /*Your code comes here*/
+}
+
+/* Will be called by the library to read the encoder */
+static bool encoder_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
+{
+
+    data->enc_diff = encoder_diff;
+    data->state = encoder_state;
+
+    /*Return `false` because we are not buffering and no more data to read*/
+    return false;
+}
+
+/*Call this function in an interrupt to process encoder events (turn, press)*/
+static void encoder_handler(void)
+{
+    /*Your code comes here*/
+
+    encoder_diff += 0;
+    encoder_state = LV_INDEV_STATE_REL;
+}
+
+/*------------------
+ * Button
+ * -----------------*/
+
+/* Initialize your buttons */
+static void button_init(void)
+{
+    /*Your code comes here*/
+}
+
+/* Will be called by the library to read the button */
+static bool button_read(lv_indev_drv_t * indev_drv, lv_indev_data_t * data)
+{
+
+    static uint8_t last_btn = 0;
+
+    /*Get the pressed button's ID*/
+    int8_t btn_act = button_get_pressed_id();
+
+    if(btn_act >= 0) {
+        data->state = LV_INDEV_STATE_PR;
+        last_btn = btn_act;
+    } else {
+        data->state = LV_INDEV_STATE_REL;
+    }
+
+    /*Save the last pressed button's ID*/
+    data->btn_id = last_btn;
+
+    /*Return `false` because we are not buffering and no more data to read*/
+    return false;
+}
+
+/*Get ID  (0, 1, 2 ..) of the pressed button*/
+static int8_t button_get_pressed_id(void)
+{
+    uint8_t i;
+
+    /*Check to buttons see which is being pressed (assume there are 2 buttons)*/
+    for(i = 0; i < 2; i++) {
+        /*Return the pressed button's ID*/
+        if(button_is_pressed(i)) {
+            return i;
+        }
+    }
+
+    /*No button pressed*/
+    return -1;
+}
+
+/*Test if `id` button is pressed or not*/
+static bool button_is_pressed(uint8_t id)
+{
+
+    /*Your code comes here*/
+
+    return false;
+}
+
+#else /* Enable this file at the top */
+
+/* This dummy typedef exists purely to silence -Wpedantic. */
+typedef int keep_pedantic_happy;
+#endif

examples/porting/lv_port_indev_template.h

@@ -0,0 +1,44 @@
+
+/**
+ * @file lv_port_indev_templ.h
+ *
+ */
+
+ /*Copy this file as "lv_port_indev.h" and set this value to "1" to enable content*/
+#if 0
+
+#ifndef LV_PORT_INDEV_TEMPL_H
+#define LV_PORT_INDEV_TEMPL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*********************
+ *      INCLUDES
+ *********************/
+#include "lvgl/lvgl.h"
+
+/*********************
+ *      DEFINES
+ *********************/
+
+/**********************
+ *      TYPEDEFS
+ **********************/
+
+/**********************
+ * GLOBAL PROTOTYPES
+ **********************/
+
+/**********************
+ *      MACROS
+ **********************/
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /*LV_PORT_INDEV_TEMPL_H*/
+
+#endif /*Disable/Enable content*/

img_conf_templ.h

@@ -1,41 +0,0 @@
-/**
- * @file img_conf.h
- *
- */
-
-#if 0 /*Remove this to enable the content (Delete the last #endif too!)*/
-
-#ifndef IMG_CONF_H
-#define IMG_CONF_H
-
-/*********************
- *      INCLUDES
- *********************/
-
-/*********************
- *      DEFINES
- *********************/
-
-/* Enable here the used images
- * For example:
- * #define USE_IMG_EXAMPLE       1
- *
- * This is compatible with the images
- * generated by the image converter utility
- * For more information see: www.littlev.hu */
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif /*Remove this to enable the content*/

library.json

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

library.properties

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

lv_app/lv_app.h

@@ -1,246 +0,0 @@
-/**
- * @file lv_app.h
- *
- */
-
-#ifndef LV_APP_H
-#define LV_APP_H
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include "lvgl/lvgl.h"
-
-#if LV_APP_ENABLE != 0
-
-/*********************
- *      DEFINES
- *********************/
-/*Check dependencies*/
-#if LV_OBJ_FREE_P == 0
-#error "lv_app: Free pointer is required for application. Enable it lv_conf.h: LV_OBJ_FREE_P 1"
-#endif
-
-#if LV_OBJ_FREE_NUM == 0
-#error "lv_app: Free number is required for application. Enable it lv_conf.h: LV_OBJ_FREE_NUM 1"
-#endif
-
-#if DM_CUSTOM == 0 && DM_MEM_SIZE < (2 * 1024)
-#error "lv_app: not enough dynamic memory. Increase it in misc_conf.h: DM_MEM_SIZE"
-#endif
-
-/**********************
- *      TYPEDEFS
- **********************/
-typedef enum
-{
-	LV_APP_MODE_NONE 	 = 0x0000,
-	LV_APP_MODE_NOT_LIST = 0x0001,		/*Do not list the application*/
-	LV_APP_MODE_NO_SC_TITLE = 0x0002,	/*No short cut title*/
-}lv_app_mode_t;
-
-typedef enum
-{
-	LV_APP_COM_TYPE_CHAR,   /*Stream of characters. Not '\0' terminated*/
-	LV_APP_COM_TYPE_INT,    /*Stream of 'int32_t' numbers*/
-	LV_APP_COM_TYPE_LOG,    /*String about an event to log*/
-    LV_APP_COM_TYPE_TRIG,   /*A trigger to do some specific action (data is ignored)*/
-    LV_APP_COM_TYPE_INV,    /*Invalid type*/
-    LV_APP_COM_TYPE_NUM,    /*Indicates the number of com. types*/
-}lv_app_com_type_t;
-
-struct __LV_APP_DSC_T;
-
-typedef struct
-{
-	const struct __LV_APP_DSC_T * dsc;
-	char * name;
-	lv_obj_t * sc;
-	lv_obj_t * sc_title;
-	lv_obj_t * win;
-    lv_obj_t * conf_win;
-	void * app_data;
-	void * sc_data;
-	void * win_data;
-}lv_app_inst_t;
-
-typedef struct __LV_APP_DSC_T
-{
-	const char * name;
-	lv_app_mode_t mode;
-	void (*app_run)(lv_app_inst_t *, void *);
-	void (*app_close) (lv_app_inst_t *);
-	void (*com_rec) (lv_app_inst_t *, lv_app_inst_t *, lv_app_com_type_t, const void *, uint32_t);
-	void (*sc_open) (lv_app_inst_t *, lv_obj_t *);
-	void (*sc_close) (lv_app_inst_t *);
-	void (*win_open) (lv_app_inst_t *, lv_obj_t *);
-	void (*win_close) (lv_app_inst_t *);
-    void (*conf_open) (lv_app_inst_t *, lv_obj_t * );
-	uint16_t app_data_size;
-	uint16_t sc_data_size;
-	uint16_t win_data_size;
-}lv_app_dsc_t;
-
-typedef struct {
-	lv_style_t menu;
-    lv_style_t menu_btn_rel;
-    lv_style_t menu_btn_pr;
-    lv_style_t sc_rel;
-    lv_style_t sc_pr;
-    lv_style_t sc_send_rel;
-    lv_style_t sc_send_pr;
-    lv_style_t sc_rec_rel;
-    lv_style_t sc_rec_pr;
-    lv_style_t sc_title;
-    lv_style_t win_header;
-    lv_style_t win_scrl;
-    lv_style_t win_cbtn_rel;
-    lv_style_t win_cbtn_pr;
-}lv_app_style_t;
-
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Initialize the application system
- */
-void lv_app_init(void);
-
-/**
- * Run an application according to 'app_dsc'
- * @param app_dsc pointer to an application descriptor
- * @param conf pointer to an application specific configuration structure or NULL if unused
- * @return pointer to the opened application or NULL if any error occurred
- */
-lv_app_inst_t * lv_app_run(const lv_app_dsc_t * app_dsc, void * conf);
-
-/**
- * Close a running application. Close the Window and the Shortcut too if opened.
- * @param app pointer to an application
- */
-void lv_app_close(lv_app_inst_t * app);
-
-/**
- * Open a shortcut for an application
- * @param app pointer to an application
- * @return pointer to the shortcut
- */
-lv_obj_t * lv_app_sc_open(lv_app_inst_t * app);
-
-/**
- * Close the shortcut of an application
- * @param app pointer to an application
- */
-void lv_app_sc_close(lv_app_inst_t * app);
-
-/**
- * Open the application in a window
- * @param app pointer to an application
- * @return pointer to the shortcut
- */
-lv_obj_t * lv_app_win_open(lv_app_inst_t * app);
-
-/**
- * Close the window of an application
- * @param app pointer to an application
- */
-void lv_app_win_close(lv_app_inst_t * app);
-
-/**
- * Send data to other applications
- * @param app_send pointer to the application which is sending the message
- * @param type type of data from 'lv_app_com_type_t' enum
- * @param data pointer to the sent data
- * @param size length of 'data' in bytes
- * @return number application which were received the message
- */
-uint16_t lv_app_com_send(lv_app_inst_t * app_send, lv_app_com_type_t type , const void * data, uint32_t size);
-
-/**
- * Test an application communication connection
- * @param sender pointer to an application which sends data
- * @param receiver pointer to an application which receives data
- * @return false: no connection, true: there is connection
- */
-bool lv_app_con_check(lv_app_inst_t * sender, lv_app_inst_t * receiver);
-
-/**
- * Create a new connection between two applications
- * @param sender pointer to a data sender application
- * @param receiver pointer to a data receiver application
- */
-void lv_app_con_set(lv_app_inst_t * sender, lv_app_inst_t * receiver);
-
-/**
- * Delete a communication connection
- * @param sender pointer to a data sender application or NULL to be true for all sender
- * @param receiver pointer to a data receiver application  or NULL to be true for all receiver
- */
-void lv_app_con_del(lv_app_inst_t * sender, lv_app_inst_t * receiver);
-
-/**
- * Get the application descriptor from its name
- * @param name name of the app. dsc.
- * @return pointer to the app. dsc.
- */
-const lv_app_dsc_t * lv_app_dsc_get(const char * name);
-
-/**
- * Rename an application
- * @param app pointer to an application
- * @param name a string with the new name
- */
-void lv_app_rename(lv_app_inst_t * app, const char * name);
-
-/**
- * Get the window object from an object located on the window
- * @param obj pointer to an object on the window
- * @return pointer to the window of 'obj'
- */
-lv_obj_t * lv_app_win_get_from_obj(lv_obj_t * obj);
-
-/**
- * Read the list of the running applications. (Get he next element)
- * @param prev the previous application (at the first call give NULL to get the first application)
- * @param dsc pointer to an application descriptor to filer the applications (NULL to do not filter)
- * @return pointer to the next running application or NULL if no more
- */
-lv_app_inst_t * lv_app_get_next(lv_app_inst_t * prev, lv_app_dsc_t * dsc);
-
-/**
- * Read the list of applications descriptors. (Get he next element)
- * @param prev the previous application descriptors(at the first call give NULL to get the first)
- * @return pointer to the next application descriptors or NULL if no more
- */
-lv_app_dsc_t ** lv_app_dsc_get_next(lv_app_dsc_t ** prev);
-
-
-/**
- * Get a pointer to the application style structure. If modified then 'lv_app_refr_style' should be called
- * @return pointer to the application style structure
- */
-lv_app_style_t * lv_app_style_get(void);
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   POST-INCLUDES
- *********************/
-#include "lvgl/lv_app/lv_app_util/lv_app_kb.h"
-#include "lvgl/lv_app/lv_app_util/lv_app_fsel.h"
-#include "lvgl/lv_app/lv_app_util/lv_app_notice.h"
-
-#include "lvgl/lv_appx/lv_app_example.h"
-#include "lvgl/lv_appx/lv_app_phantom.h"
-#include "lvgl/lv_appx/lv_app_sysmon.h"
-#include "lvgl/lv_appx/lv_app_terminal.h"
-#include "lvgl/lv_appx/lv_app_files.h"
-
-#endif /*LV_APP_ENABLE != 0*/
-
-#endif /*LV_APP_H*/

lv_app/lv_app_util/lv_app_fsel.c

@@ -1,381 +0,0 @@
-/**
- * @file lv_app_fsel.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_app_fsel.h"
-#if USE_LV_APP_FSEL != 0
-
-#include <stdio.h>
-#include "lv_app_notice.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void fsel_refr(void);
-static lv_action_res_t fsel_close_action(lv_obj_t * close, lv_dispi_t * dispi);
-static lv_action_res_t fsel_up_action(lv_obj_t * up, lv_dispi_t * dispi);
-static lv_action_res_t fsel_next_action(lv_obj_t * next, lv_dispi_t * dispi);
-static lv_action_res_t fsel_prev_action(lv_obj_t * prev, lv_dispi_t * dispi);
-static lv_action_res_t fsel_drv_action(lv_obj_t * drv, lv_dispi_t * dispi);
-static lv_action_res_t fsel_drv_lpr_action(lv_obj_t * drv, lv_dispi_t * dispi);
-static lv_action_res_t fsel_folder_action(lv_obj_t * folder, lv_dispi_t * dispi);
-static lv_action_res_t fsel_folder_lpr_action(lv_obj_t * folder, lv_dispi_t * dispi);
-static lv_action_res_t fsel_file_action(lv_obj_t * file, lv_dispi_t * dispi);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static const char * fsel_filter;
-static char fsel_path[LV_APP_FSEL_PATH_MAX_LEN];
-static uint16_t fsel_file_cnt;
-static lv_obj_t * fsel_win;
-static lv_obj_t * fsel_list;
-static void *  fsel_param;
-static void (*fsel_ok_action)(void *, const char *);
-static lv_style_t style_btn_symbol;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the File selector utility
- */
-void lv_app_fsel_init(void)
-{
-    lv_style_get(LV_STYLE_BTN_REL, &style_btn_symbol);
-    style_btn_symbol.font = font_get(LV_IMG_DEF_SYMBOL_FONT);
-}
-
-/**
- * Open the File selector
- * @param path start path
- * @param filter show only files with a specific extension, e.g. "wav".
- *               "/" means filter to folders.
- * @param param a free parameter which will be added to 'ok_action'
- * @param ok_action an action to call when a file or folder is chosen
- */
-void lv_app_fsel_open(const char * path, const char * filter, void * param, void (*ok_action)(void *, const char *))
-{
-    /*Save the parameters*/
-    strcpy(fsel_path, path);
-    fsel_filter = filter;
-    fsel_file_cnt = 0;
-    fsel_param = param;
-    fsel_ok_action = ok_action;
-
-    /*Trim the extra '\' or '/' from the end of path*/
-    uint16_t i;
-    for(i = strlen(fsel_path) -1 ; fsel_path[i] == '/' || fsel_path[i] == '\\'; i--) {
-        fsel_path[i] = '\0';
-    }
-
-    /*Check filter: NULL and "" mean no filtering*/
-    if(fsel_filter == NULL) fsel_filter = "";
-
-    lv_app_style_t * app_style = lv_app_style_get();
-
-    /*Create a window for the File selector*/
-    fsel_win = lv_win_create(lv_scr_act(), NULL);
-    lv_obj_set_size(fsel_win, LV_HOR_RES, LV_VER_RES);
-    lv_win_set_styles_cbtn(fsel_win, &app_style->win_cbtn_rel, &app_style->win_cbtn_pr);
-    lv_obj_set_style(lv_win_get_header(fsel_win), &app_style->menu);
-
-    lv_win_add_cbtn(fsel_win, SYMBOL_CLOSE, fsel_close_action);
-
-    fsel_refr(); /*Refresh the list*/
-
-    /*Show instruction when first open with folder filter*/
-    static bool first_folder_call = false;
-    if(first_folder_call == false && fsel_filter[0] == '/') {
-        lv_app_notice_add("Press a folder long\nto choose it!");
-        first_folder_call = true;
-    }
-}
-
-/**
- * Close the File selector
- */
-void lv_app_fsel_close(void)
-{
-    if(fsel_win != NULL) {
-            lv_obj_del(fsel_win);
-    }
-
-    fsel_win = NULL;
-    fsel_list = NULL;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Refresh the file list according to the current path and filter
- */
-static void fsel_refr(void)
-{
-    /*Delete the previous list*/
-    if(fsel_list != NULL) {
-        lv_obj_del(fsel_list);
-    }
-
-    lv_win_set_title(fsel_win, fsel_path);
-
-    /*Create a new list*/
-    fsel_list = lv_list_create(fsel_win, NULL);
-    lv_obj_set_width(fsel_list, lv_win_get_width(fsel_win));
-    lv_list_set_style_img(fsel_list, &style_btn_symbol);
-    lv_obj_set_style(lv_page_get_scrl(fsel_list), lv_style_get(LV_STYLE_TRANSP_TIGHT, NULL));
-    lv_obj_set_drag_parent(fsel_list, true);
-    lv_obj_set_drag_parent(lv_page_get_scrl(fsel_list), true);
-    lv_cont_set_fit(fsel_list, false, true);
-
-    fs_res_t res = FS_RES_OK;
-    lv_obj_t * liste;
-
-    /*At empty path show the drivers */
-    if(fsel_path[0] == '\0') {
-        char drv[16];
-        char buf[2];
-        fs_get_letters(drv);
-        uint8_t i;
-        for(i = 0; drv[i] != '\0'; i++) {
-            buf[0] = drv[i];
-            buf[1] = '\0';
-            liste = lv_list_add(fsel_list, SYMBOL_DRIVE, buf, fsel_drv_action);
-            /*Add long press action to choose the driver as a folder*/
-            if(fsel_filter[0] == '/') lv_btn_set_lpr_action(liste, fsel_drv_lpr_action);
-        }
-    }
-    /*List the files/folders with fs interface*/
-    else {
-        liste = lv_list_add(fsel_list, SYMBOL_UP, "Up", fsel_up_action);
-
-        fs_readdir_t rd;
-        res = fs_readdir_init(&rd, fsel_path);
-        if(res != FS_RES_OK) {
-            lv_app_notice_add("Can not read the path\nin File selector");
-            return;
-        }
-
-        /*At not first page add prev. page button */
-        if(fsel_file_cnt != 0) {
-            liste = lv_list_add(fsel_list, SYMBOL_LEFT, "Previous page", fsel_prev_action);
-        }
-
-        char fn[LV_APP_FSEL_FN_MAX_LEN];
-
-        /*Read the files from the previous pages*/
-        uint16_t file_cnt = 0;
-        while(file_cnt <= fsel_file_cnt) {
-            res = fs_readdir(&rd, fn);
-            if(res != FS_RES_OK){
-                lv_app_notice_add("Can not read the path\nin File selector");
-                return;
-            }
-            file_cnt ++;
-        }
-
-        /*Add list elements from the files and folders*/
-        while(res == FS_RES_OK && fn[0] != '\0') {
-            if(fn[0] == '/') { /*Add a folder*/
-                lv_obj_t * liste;
-                liste = lv_list_add(fsel_list, SYMBOL_FOLDER, &fn[1], fsel_folder_action);
-                /*Add long press action to choose a folder*/
-                if(fsel_filter[0] == '/') lv_btn_set_lpr_action(liste, fsel_folder_lpr_action);
-
-                fsel_file_cnt ++;
-                file_cnt ++;
-            }
-            /*Add a file if it is not filtered*/
-            else if(fsel_filter[0] == '\0' || /*No filtering or ...*/
-                    (strcmp(fs_get_ext(fn), fsel_filter) == 0 && /*.. the filter matches*/
-                     fsel_filter[0] != '/')) {
-                liste = lv_list_add(fsel_list, SYMBOL_FILE, fn, fsel_file_action);
-                fsel_file_cnt ++;
-                file_cnt ++;
-            }
-
-            /*Get the next element*/
-            res = fs_readdir(&rd, fn);
-
-            /*Show only LV_APP_FSEL_MAX_FILE elements and add a Next page button*/
-            if(fsel_file_cnt != 0 && fsel_file_cnt % LV_APP_FSEL_PAGE_SIZE == 0) {
-                liste = lv_list_add(fsel_list, SYMBOL_RIGHT, "Next page", fsel_next_action);
-                break;
-            }
-        }
-
-        /*Close the read directory*/
-        fs_readdir_close(&rd);
-    }
-
-    if(res != FS_RES_OK) {
-        lv_app_notice_add("Can not read the path\nin File selector");
-    }
-
-    /*Focus to the top of the list*/
-    lv_obj_set_y(lv_page_get_scrl(fsel_list), 0);
-}
-
-/**
- * Called when the File selector window close button is released
- * @param close pointer to the close button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the window is deleted in the function
- */
-static lv_action_res_t fsel_close_action(lv_obj_t * close, lv_dispi_t * dispi)
-{
-    lv_app_fsel_close();
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when the Up list element is released to step one level
- * @param up pointer to the Up button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t fsel_up_action(lv_obj_t * up, lv_dispi_t * dispi)
-{
-    fs_up(fsel_path);
-    fsel_file_cnt = 0;
-    fsel_refr();
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when the Next list element is released to go to the next page
- * @param next pointer to the Next button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t fsel_next_action(lv_obj_t * next, lv_dispi_t * dispi)
-{
-    fsel_refr();
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when the Prev list element is released to previous page
- * @param prev pointer to the Prev button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t fsel_prev_action(lv_obj_t * prev, lv_dispi_t * dispi)
-{
-    if(fsel_file_cnt <= 2 * LV_APP_FSEL_PAGE_SIZE) fsel_file_cnt = 0;
-    else if(fsel_file_cnt % LV_APP_FSEL_PAGE_SIZE == 0) {
-        fsel_file_cnt -= 2 * LV_APP_FSEL_PAGE_SIZE;
-    } else {
-        fsel_file_cnt = ((fsel_file_cnt / LV_APP_FSEL_PAGE_SIZE) - 1) * LV_APP_FSEL_PAGE_SIZE;
-    }
-
-    fsel_refr();
-    return LV_ACTION_RES_INV;
-}
-
-
-/**
- * Called when the Driver list element is released to step into a driver
- * @param drv pointer to the Driver button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t fsel_drv_action(lv_obj_t * drv, lv_dispi_t * dispi)
-{
-    sprintf(fsel_path, "%s:", lv_list_get_element_text(drv));
-    fsel_file_cnt = 0;
-    fsel_refr();
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when the Driver list element is long pressed to choose it
- * @param drv pointer to the Driver button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t fsel_drv_lpr_action(lv_obj_t * drv, lv_dispi_t * dispi)
-{
-    sprintf(fsel_path, "%s:", lv_list_get_element_text(drv));
-
-    if(fsel_ok_action != NULL) {
-        fsel_ok_action(fsel_param, fsel_path);
-    }
-
-    lv_app_fsel_close();
-
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when a folder list element is released to enter into it
- * @param folder pointer to a folder button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t fsel_folder_action(lv_obj_t * folder, lv_dispi_t * dispi)
-{
-    sprintf(fsel_path, "%s/%s", fsel_path, lv_list_get_element_text(folder));
-    fsel_file_cnt = 0;
-    fsel_refr();
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when a folder list element is long pressed to choose it
- * @param folder pointer to a folder button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t fsel_folder_lpr_action(lv_obj_t * folder, lv_dispi_t * dispi)
-{
-    sprintf(fsel_path, "%s/%s", fsel_path, lv_list_get_element_text(folder));
-
-    if(fsel_ok_action != NULL) {
-        fsel_ok_action(fsel_param, fsel_path);
-    }
-
-    lv_app_fsel_close();
-
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when a file list element is released to choose it
- * @param file pointer to a file button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t fsel_file_action(lv_obj_t * file, lv_dispi_t * dispi)
-{
-    sprintf(fsel_path, "%s/%s", fsel_path, lv_list_get_element_text(file));
-
-    if(fsel_ok_action != NULL) {
-        fsel_ok_action(fsel_param, fsel_path);
-    }
-
-    lv_app_fsel_close();
-
-    return LV_ACTION_RES_INV;
-}
-
-#endif /*LV_APP_ENABLE != 0*/

lv_app/lv_app_util/lv_app_fsel.h

@@ -1,67 +0,0 @@
-/**
- * @file lv_app_fsel.h
- *
- */
-
-#ifndef LV_APP_FSEL_H
-#define LV_APP_FSEL_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_app.h"
-#if USE_LV_APP_FSEL != 0
-
-/*********************
- *      DEFINES
- *********************/
-/*Add the required configurations*/
-#ifndef LV_APP_FSEL_FN_MAX_LEN
-#define LV_APP_FSEL_FN_MAX_LEN    128
-#endif
-
-#ifndef LV_APP_FSEL_PATH_MAX_LEN
-#define LV_APP_FSEL_PATH_MAX_LEN  256
-#endif
-
-#ifndef LV_APP_FSEL_PAGE_SIZE
-#define LV_APP_FSEL_PAGE_SIZE     8
-#endif
-
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Initialize the File selector utility
- */
-void lv_app_fsel_init(void);
-
-/**
- * Open the File selector
- * @param path start path
- * @param filter show only files with a specific extension, e.g. "wav".
- *               "/" means filter to folders.
- * @param param a free parameter which will be added to 'ok_action'
- * @param ok_action an action to call when a file or folder is chosen (give 'param' and the path as parameters)
- */
-void lv_app_fsel_open(const char * path, const char * filter, void * param,
-                       void (*ok_action)(void *, const char *));
-
-/**
- * Close the File selector
- */
-void lv_app_fsel_close(void);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_APP_ENABLE != 0*/
-
-#endif /*LV_APP_FSEL_H*/

lv_app/lv_app_util/lv_app_kb.c

@@ -1,264 +0,0 @@
-/**
- * @file lv_app_kb.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_app_kb.h"
-#if USE_LV_APP_KB != 0
-
-#include "lvgl/lv_objx/lv_btnm.h"
-#include "lvgl/lv_objx/lv_ta.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static lv_action_res_t lv_app_kb_action(lv_obj_t * btnm, uint16_t i);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_obj_t * kb_btnm;
-static lv_obj_t * kb_win;
-static lv_obj_t * kb_ta;
-static const char * kb_map_lc[] = {
-"\0051#", "\004q", "\004w", "\004e", "\004r", "\004t", "\004y", "\004u", "\004i", "\004o", "\004p", "\007Del", "\n",
-"\006ABC", "\003a", "\003s", "\003d", "\003f", "\003g", "\003h", "\003j", "\003k", "\003l", "\010Enter", "\n",
-"_", "-", "z", "x", "c", "v", "b", "n", "m", ".", ",", ":", "\n",
-"\003Hide", "\003Left", "\006 ", "\003Right", "\003Ok", ""
-};
-
-static const char * kb_map_uc[] = {
-"\0051#", "\004Q", "\004W", "\004E", "\004R", "\004T", "\004Y", "\004U", "\004I", "\004O", "\004P", "\007Del", "\n",
-"\006abc", "\003A", "\003S", "\003D", "\003F", "\003G", "\003H", "\003J", "\003K", "\003L", "\010Enter", "\n",
-"_", "-", "Z", "X", "C", "V", "B", "N", "M", ".", ",", ":", "\n",
-"\003Hide", "\003Left", "\006 ", "\003Right", "\003Ok", ""
-};
-
-static const char * kb_map_spec[] = {
-"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "\002Del", "\n",
-"\002abc", "+", "-", "/", "*", "=", "%", "!", "?", "#", "<", ">", "\n",
-"\\", "@", "$", "(", ")", "{", "}", "[", "]", ";", "\"", "'", "\n",
-"\003Hide", "\003Left", "\006 ", "\003Right", "\003Ok", ""
-};
-
-static const char * kb_map_num[] = {
-"1", "2", "3", "\002Hide","\n",
-"4", "5", "6", "\002Ok", "\n",
-"7", "8", "9", "\002Del", "\n",
-"+/-", "0", ".", "Left", "Right", ""
-};
-
-static cord_t kb_ta_ori_size;
-static uint8_t kb_mode;
-static void (*kb_close_action)(lv_obj_t *);
-static void (*kb_ok_action)(lv_obj_t *);
-static lv_style_t style_bg;
-static lv_style_t style_btn_rel;
-static lv_style_t style_btn_pr;
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the application keyboard
- */
-void lv_app_kb_init(void)
-{
-    lv_app_style_t * app_style = lv_app_style_get();
-
-    memcpy(&style_bg, &app_style->menu, sizeof(lv_style_t));
-    style_bg.opa = OPA_COVER;
-    style_bg.hpad = 0;
-    style_bg.vpad = 0;
-    style_bg.opad = 0;
-
-    memcpy(&style_btn_rel, &app_style->menu_btn_rel, sizeof(lv_style_t));
-    style_btn_rel.radius = 0;
-    style_btn_rel.bwidth = 1;
-
-    memcpy(&style_btn_pr, &app_style->menu_btn_pr, sizeof(lv_style_t));
-    style_btn_pr.radius = 0;
-    style_btn_pr.bwidth = 1;
-}
-
-/**
- * Open a keyboard for a text area object
- * @param ta pointer to a text area object
- * @param mode 'OR'd values of 'lv_app_kb_mode_t' enum
- * @param close a function to call when the keyboard is closed
- * @param ok a function to called when the "Ok" button is pressed
- * @return the created button matrix objects
- */
-lv_obj_t * lv_app_kb_open(lv_obj_t * ta, lv_app_kb_mode_t mode, void (*close)(lv_obj_t *), void (*ok)(lv_obj_t *))
-{
-	/*Close the previous keyboard*/
-    if(kb_btnm != NULL) {
-        lv_app_kb_close(false);
-    }
-
-    /*Save some parameters*/
-    kb_ta = ta;
-    kb_mode = mode;
-    kb_close_action = close;
-    kb_ok_action = ok;
-
-    /*Create a button matrix for the keyboard  */
-    kb_btnm = lv_btnm_create(lv_scr_act(), NULL);
-    lv_obj_set_style(kb_btnm, &style_bg);
-    lv_obj_set_size(kb_btnm, LV_HOR_RES, LV_VER_RES / 2);
-    lv_obj_align(kb_btnm, NULL, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
-    lv_btnm_set_action(kb_btnm, lv_app_kb_action);
-    if(mode & LV_APP_KB_MODE_TXT) {
-        style_btn_rel.font = font_get(LV_APP_FONT_MEDIUM);
-        style_btn_pr.font = font_get(LV_APP_FONT_MEDIUM);
-    	lv_btnm_set_map(kb_btnm, kb_map_lc);
-    }
-    else if(mode & LV_APP_KB_MODE_NUM) {
-        style_btn_rel.font = font_get(LV_APP_FONT_LARGE);
-        style_btn_pr.font = font_get(LV_APP_FONT_LARGE);
-    	lv_btnm_set_map(kb_btnm, kb_map_num);
-    }
-    lv_btnm_set_styles_btn(kb_btnm, &style_btn_rel, &style_btn_pr);
-
-    kb_win = NULL;
-    kb_ta_ori_size = 0;
-    if(mode & LV_APP_KB_MODE_WIN_RESIZE) {
-        /*Reduce the size of the window and align it to the top*/
-        kb_win = lv_app_win_get_from_obj(kb_ta);
-        lv_obj_set_height(kb_win, LV_VER_RES / 2);
-        lv_obj_set_y(kb_win, 0);
-
-        /*If the text area is higher then the new size of the window reduce its size too*/
-        cord_t cont_h = lv_obj_get_height(kb_win) - lv_obj_get_height(lv_win_get_header(kb_win));
-        kb_ta_ori_size = lv_obj_get_height(kb_ta);
-        if(lv_obj_get_height(kb_ta)  > cont_h - LV_DPI / 10) {
-            lv_obj_set_height(kb_ta, cont_h - LV_DPI / 10);
-        }
-#if LV_APP_ANIM_LEVEL != 0
-        lv_page_focus(lv_win_get_content(kb_win), kb_ta, true);
-#else
-        lv_page_focus(lv_win_get_page(kb_win), kb_ta, 0);
-#endif
-    }
-
-    lv_ta_set_cursor_pos(kb_ta, LV_TA_CUR_LAST);
-
-    return kb_btnm;
-
-}
-
-/**
- * Close the keyboard
- * @param ok true: call the ok function, false: call the close function
- */
-void lv_app_kb_close(bool ok)
-{
-	if(kb_btnm == NULL) return;
-
-	if(ok == false) {
-		if(kb_close_action != NULL) kb_close_action(kb_ta);
-	} else {
-		if(kb_ok_action != NULL) kb_ok_action(kb_ta);
-	}
-
-	/*Reset the modified sizes*/
-	if((kb_mode & LV_APP_KB_MODE_WIN_RESIZE) && kb_win != NULL) {
-        lv_obj_set_height(kb_ta, kb_ta_ori_size);
-        lv_obj_set_size(kb_win, LV_HOR_RES, LV_VER_RES);
-        kb_win = NULL;
-	}
-
-    lv_obj_del(kb_btnm);
-    kb_btnm = NULL;
-
-    kb_ta = NULL;
-}
-
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Called when a button of 'kb_btnm' is released
- * @param btnm pointer to 'kb_btnm'
- * @param i the index of the released button from the current btnm map
- * @return LV_ACTION_RES_INV if the btnm is deleted else LV_ACTION_RES_OK
- */
-static lv_action_res_t lv_app_kb_action(lv_obj_t * btnm, uint16_t i)
-{
-    const char ** map = lv_btnm_get_map(btnm);
-    const char * txt = map[i];
-
-    /*Ignore the unit size number of the text*/
-    if(txt[0] <= '\011') txt++;
-
-    /*Do the corresponding action according to the text of the button*/
-    if(strcmp(txt, "abc") == 0) {
-        lv_btnm_set_map(btnm, kb_map_lc);
-    } else if(strcmp(txt, "ABC") == 0) {
-        lv_btnm_set_map(btnm, kb_map_uc);
-    } else if(strcmp(txt, "1#") == 0) {
-        lv_btnm_set_map(btnm, kb_map_spec);
-    }  else if(strcmp(txt, "Enter") == 0) {
-        lv_ta_add_char(kb_ta, '\n');
-    } else if(strcmp(txt, "Left") == 0) {
-        lv_ta_cursor_left(kb_ta);
-    } else if(strcmp(txt, "Right") == 0) {
-        lv_ta_cursor_right(kb_ta);
-    } else if(strcmp(txt, "Del") == 0) {
-        lv_ta_del(kb_ta);
-    } else if(strcmp(txt, "+/-") == 0) {
-        uint16_t cur = lv_ta_get_cursor_pos(kb_ta);
-        const char * ta_txt = lv_ta_get_txt(kb_ta);
-        if(ta_txt[0] == '-') {
-            lv_ta_set_cursor_pos(kb_ta, 1);
-            lv_ta_del(kb_ta);
-            lv_ta_add_char(kb_ta, '+');
-            lv_ta_set_cursor_pos(kb_ta, cur);
-        } else if(ta_txt[0] == '+') {
-            lv_ta_set_cursor_pos(kb_ta, 1);
-            lv_ta_del(kb_ta);
-            lv_ta_add_char(kb_ta, '-');
-            lv_ta_set_cursor_pos(kb_ta, cur);
-        } else {
-            lv_ta_set_cursor_pos(kb_ta, 0);
-            lv_ta_add_char(kb_ta, '-');
-            lv_ta_set_cursor_pos(kb_ta, cur + 1);
-        }
-    } else if(strcmp(txt, "Hide") == 0) {
-        lv_app_kb_close(false);
-        return LV_ACTION_RES_INV;
-    } else if(strcmp(txt, "Ok") == 0) {
-        lv_app_kb_close(true);
-        return LV_ACTION_RES_INV;
-    } else {
-        lv_ta_add_text(kb_ta, txt);
-    }
-
-    if(kb_mode & LV_APP_KB_MODE_WIN_RESIZE) {
-#if LV_APP_ANIM_LEVEL != 0
-        lv_page_focus(lv_win_get_content(kb_win), kb_ta, true);
-#else
-        lv_page_focus(lv_win_get_page(kb_win), kb_ta, 0);
-#endif
-    }
-    return LV_ACTION_RES_OK;
-}
-
-#endif /*LV_APP_ENABLE != 0*/

lv_app/lv_app_util/lv_app_kb.h

@@ -1,59 +0,0 @@
-/**
- * @file lv_app_kb.h
- *
- */
-
-#ifndef LV_APP_KB_H
-#define LV_APP_KB_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_app.h"
-#if USE_LV_APP_KB != 0
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-typedef enum
-{
-	LV_APP_KB_MODE_TXT = 0x01,
-	LV_APP_KB_MODE_NUM = 0x02,
-    LV_APP_KB_MODE_WIN_RESIZE = 0x04,
-}lv_app_kb_mode_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Initialize the application keyboard
- */
-void lv_app_kb_init(void);
-
-/**
- * Open a keyboard for a text area object
- * @param ta pointer to a text area object
- * @param mode 'OR'd values of 'lv_app_kb_mode_t' enum
- * @param close a function to call when the keyboard is closed
- * @param ok a function to called when the "Ok" button is pressed
- * @return the created button matrix objects
- */
-lv_obj_t * lv_app_kb_open(lv_obj_t * ta, lv_app_kb_mode_t mode, void (*close)(lv_obj_t *), void (*ok)(lv_obj_t *));
-
-/**
- * Close the keyboard
- * @param ok true: call the ok function, false: call the close function
- */
-void lv_app_kb_close(bool ok);
-
-/**********************
- *      MACROS
- **********************/
-#endif /*LV_APP_ENABLE != 0*/
-
-#endif /*LV_APP_KB_H*/

lv_app/lv_app_util/lv_app_notice.c

@@ -1,95 +0,0 @@
-/**
- * @file lv_app_notice.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_app_notice.h"
-#if USE_LV_APP_NOTICE != 0
-
-#include <lvgl/lv_objx/lv_cont.h>
-#include "lvgl/lv_objx/lv_label.h"
-
-#include "misc/gfx/anim.h"
-#include <stdio.h>
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_obj_t * notice_h;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-/**
- * Initialize the Notifications
- */
-void lv_app_notice_init(void)
-{
-    notice_h = lv_cont_create(lv_scr_act(), NULL);
-    lv_obj_set_size(notice_h, LV_HOR_RES, LV_VER_RES - LV_DPI / 8);
-    lv_obj_set_y(notice_h, LV_DPI / 8);
-    lv_obj_set_click(notice_h, false);
-    lv_obj_set_style(notice_h, lv_style_get(LV_STYLE_TRANSP, NULL));
-    lv_cont_set_layout(notice_h, LV_CONT_LAYOUT_COL_R);
-}
-
-/**
- * Add a notification with a given text
- * @param format pritntf-like format string
- * @return pointer the notice which is a message box (lv_mbox) object
- */
-lv_obj_t *  lv_app_notice_add(const char * format, ...)
-{
-    char txt[LV_APP_NOTICE_MAX_LEN];
-
-    va_list va;
-    va_start(va, format);
-    vsprintf(txt,format, va);
-    va_end(va);
-
-    lv_obj_t * mbox;
-    mbox = lv_mbox_create(notice_h, NULL);
-    lv_mbox_set_text(mbox, txt);
-    lv_mbox_set_anim_close_time(mbox, LV_APP_NOTICE_CLOSE_ANIM_TIME);
-
-#if LV_APP_NOTICE_SHOW_TIME != 0
-    lv_mbox_start_auto_close(mbox, LV_APP_NOTICE_SHOW_TIME);
-#endif
-
-    /*Delete the last children if there are too many*/
-    uint32_t child_num = lv_obj_get_child_num(notice_h);
-    if(child_num > LV_APP_NOTICE_MAX_NUM) {
-        lv_obj_t * last_child = ll_get_tail(&notice_h->child_ll);
-        lv_obj_del(last_child);
-    }
-
-    /*make sure the notices are on the top*/
-    lv_obj_set_parent(notice_h, lv_scr_act());
-
-    return mbox;
-
-}
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-#endif

lv_app/lv_app_util/lv_app_notice.h

@@ -1,63 +0,0 @@
-/**
- * @file lv_app_notice.h
- * 
- */
-
-#ifndef LV_APP_NOTICE_H
-#define LV_APP_NOTICE_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "../lv_app.h"
-#include <stdarg.h>
-#if USE_LV_APP_NOTICE != 0
-
-/*********************
- *      DEFINES
- *********************/
-/*Add the required configurations*/
-#ifndef LV_APP_NOTICE_SHOW_TIME
-#define LV_APP_NOTICE_SHOW_TIME   4000
-#endif
-
-#ifndef LV_APP_NOTICE_CLOSE_ANIM_TIME
-#define LV_APP_NOTICE_CLOSE_ANIM_TIME   300
-#endif
-
-#ifndef LV_APP_NOTICE_MAX_NUM
-#define LV_APP_NOTICE_MAX_NUM   6
-#endif
-
-#ifndef LV_APP_NOTICE_MAX_LEN
-#define LV_APP_NOTICE_MAX_LEN   256
-#endif
-
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Initialize the Notifications
- */
-void lv_app_notice_init(void);
-
-/**
- * Add a notification with a given text
- * @param format pritntf-like format string
- * @return pointer the notice which is a message box (lv_mbox) object
- */
-lv_obj_t *  lv_app_notice_add(const char * format, ...);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_APP_NOTICE_H*/
-
-#endif

lv_appx/lv_app_example.c

@@ -1,216 +0,0 @@
-/**
- * @file lv_app_example.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_app_example.h"
-#if LV_APP_ENABLE != 0 && USE_LV_APP_EXAMPLE != 0
-
-#include "../lv_app/lv_app_util/lv_app_kb.h"
-#include <stdio.h>
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Application specific data for an instance of this application*/
-typedef struct
-{
-
-}my_app_data_t;
-
-/*Application specific data a window of this application*/
-typedef struct
-{
-
-}my_win_data_t;
-
-/*Application specific data for a shortcut of this application*/
-typedef struct
-{
-    lv_obj_t * label;
-}my_sc_data_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void my_app_run(lv_app_inst_t * app, void * conf);
-static void my_app_close(lv_app_inst_t * app);
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec, lv_app_com_type_t type , const void * data, uint32_t size);
-static void my_sc_open(lv_app_inst_t * app, lv_obj_t * sc);
-static void my_sc_close(lv_app_inst_t * app);
-static void my_win_open(lv_app_inst_t * app, lv_obj_t * win);
-static void my_win_close(lv_app_inst_t * app);
-
-static lv_action_res_t ta_rel_action(lv_obj_t * ta, lv_dispi_t * dispi);
-static void kb_ok_action(lv_obj_t * ta);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_app_dsc_t my_app_dsc =
-{
-	.name = "Example",
-	.mode = LV_APP_MODE_NONE,
-	.app_run = my_app_run,
-	.app_close = my_app_close,
-	.com_rec = my_com_rec,
-	.win_open = my_win_open,
-	.win_close = my_win_close,
-	.sc_open = my_sc_open,
-	.sc_close = my_sc_close,
-	.app_data_size = sizeof(my_app_data_t),
-	.sc_data_size = sizeof(my_sc_data_t),
-	.win_data_size = sizeof(my_win_data_t),
-};
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the application
- * @return pointer to the application descriptor of this application
- */
-const lv_app_dsc_t * lv_app_example_init(void)
-{
-	return &my_app_dsc;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Run an application according to 'app_dsc'
- * @param app_dsc pointer to an application descriptor
- * @param conf pointer to a lv_app_example_conf_t structure with configuration data or NULL if unused
- * @return pointer to the opened application or NULL if any error occurred
- */
-static void my_app_run(lv_app_inst_t * app, void * conf)
-{
-    /*Initialize the application*/
-}
-
-/**
- * Close a running application.
- * Close the Window and the Shortcut too if opened.
- * Free all the allocated memory by this application.
- * @param app pointer to an application
- */
-static void my_app_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_app_data'*/
-}
-
-/**
- * Read the data have been sent to this application
- * @param app_send pointer to an application which sent the message
- * @param app_rec pointer to an application which is receiving the message
- * @param type type of data from 'lv_app_com_type_t' enum
- * @param data pointer to the sent data
- * @param size length of 'data' in bytes
- */
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec,
-                       lv_app_com_type_t type , const void * data, uint32_t size)
-{
-	if(type == LV_APP_COM_TYPE_CHAR) {      /*data: string*/
-	    my_sc_data_t * sc_data = app_rec->sc_data;
-	    if (sc_data->label != NULL) {
-	        lv_label_set_text_array(sc_data->label, data, size);
-	        lv_obj_align(sc_data->label , NULL,LV_ALIGN_CENTER, 0, 0);
-	    }
-	}
-}
-
-/**
- * Open a shortcut for an application
- * @param app pointer to an application
- * @param sc pointer to an object where the application
- *           can create content of the shortcut
- */
-static void my_sc_open(lv_app_inst_t * app, lv_obj_t * sc)
-{
-    my_sc_data_t * sc_data = app->sc_data;
-
-    sc_data->label = lv_label_create(sc, NULL);
-	lv_label_set_text(sc_data->label, "Empty");
-	lv_obj_align(sc_data->label, NULL, LV_ALIGN_CENTER, 0, 0);
-}
-
-/**
- * Close the shortcut of an application
- * @param app pointer to an application
- */
-static void my_sc_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_sc_data'*/
-}
-
-
-/**
- * Open the application in a window
- * @param app pointer to an application
- * @param win pointer to a window object where
- *            the application can create content
- */
-static void my_win_open(lv_app_inst_t * app, lv_obj_t * win)
-{
-	lv_obj_t * ta;
-	ta = lv_ta_create(win, NULL);
-    lv_obj_set_size_us(ta, 200, 100);
-	lv_obj_set_pos_us(ta, 0, 0);
-    lv_obj_set_free_p(ta, app);
-	lv_page_set_rel_action(ta, ta_rel_action);
-	lv_ta_set_text(ta, "Write a text to send to the other applications");
-}
-
-/**
- * Close the window of an application
- * @param app pointer to an application
- */
-static void my_win_close(lv_app_inst_t * app)
-{
-
-}
-
-/*--------------------
- * OTHER FUNCTIONS
- ---------------------*/
-
-/**
- * Called when the text area on the window is released to open the app. keyboard
- * @param ta pointer to the text area on the window
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the text area is not deleted
- */
-static lv_action_res_t ta_rel_action(lv_obj_t * ta, lv_dispi_t * dispi)
-{
-    lv_ta_set_text(ta, ""); /*Clear the ta*/
-    lv_app_kb_open(ta, LV_APP_KB_MODE_TXT | LV_APP_KB_MODE_WIN_RESIZE, NULL, kb_ok_action);
-    return LV_ACTION_RES_OK;
-}
-
-/**
- * Called when the "Ok" button is  pressed on the app. keyboard
- * @param ta pointer to the text area assigned to the app. kexboard
- */
-static void kb_ok_action(lv_obj_t * ta)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(ta);
-    const char * txt = lv_ta_get_txt(ta);
-    lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, txt, strlen(txt));
-}
-
-#endif /*LV_APP_ENABLE != 0 && USE_LV_APP_EXAMPLE != 0*/

lv_appx/lv_app_files.c

@@ -1,897 +0,0 @@
-/**
- * @file lv_app_example.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_app_files.h"
-#if LV_APP_ENABLE != 0 && USE_LV_APP_FILES != 0
-
-#include <stdio.h>
-#include "misc/os/ptask.h"
-#include "../lv_app/lv_app_util/lv_app_kb.h"
-#include "../lv_app/lv_app_util/lv_app_notice.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_APP_FILES_CHUNK_MIN_SIZE     32
-#define LV_APP_FILES_CHUNK_MIN_TIME     10
-#define LV_APP_FILES_CHUNK_MAX_TIME     10000
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Application specific data for an instance of this application*/
-typedef struct
-{
-    char path[LV_APP_FILES_PATH_MAX_LEN];
-    char fn[LV_APP_FILES_FN_MAX_LEN];
-    fs_file_t file;
-    uint8_t file_cnt;
-    uint16_t chunk_delay;
-    uint16_t chunk_size;
-    uint8_t send_fn     :1;
-    uint8_t send_size   :1;
-    uint8_t send_crc    :1;
-    uint8_t send_in_prog :1;
-    ptask_t * send_task;
-}my_app_data_t;
-
-/*Application specific data a window of this application*/
-typedef struct
-{
-    lv_obj_t * file_list;
-}my_win_data_t;
-
-/*Application specific data for a shortcut of this application*/
-typedef struct
-{
-    lv_obj_t * label;
-}my_sc_data_t;
-
-typedef enum
-{
-    SEND_SETTINGS_FN,
-    SEND_SETTINGS_SIZE,
-    SEND_SETTINGS_CRC,
-    SEND_SETTINGS_CHUNK_SIZE,
-    SEND_SETTINGS_CHUNK_DELAY,
-}send_settings_id_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void my_app_run(lv_app_inst_t * app, void * conf);
-static void my_app_close(lv_app_inst_t * app);
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec, lv_app_com_type_t type , const void * data, uint32_t size);
-static void my_sc_open(lv_app_inst_t * app, lv_obj_t * sc);
-static void my_sc_close(lv_app_inst_t * app);
-static void my_win_open(lv_app_inst_t * app, lv_obj_t * win);
-static void my_win_close(lv_app_inst_t * app);
-static void my_conf_open(lv_app_inst_t * app, lv_obj_t * conf_win);
-
-static void win_load_file_list(lv_app_inst_t * app);
-static void win_create_list(lv_app_inst_t * app);
-static lv_action_res_t win_up_action(lv_obj_t * up, lv_dispi_t * dispi);
-static lv_action_res_t win_next_action(lv_obj_t * next, lv_dispi_t * dispi);
-static lv_action_res_t win_prev_action(lv_obj_t * prev, lv_dispi_t * dispi);
-static lv_action_res_t win_drv_action(lv_obj_t * drv, lv_dispi_t * dispi);
-static lv_action_res_t win_folder_action(lv_obj_t * folder, lv_dispi_t * dispi);
-static lv_action_res_t win_file_action(lv_obj_t * file, lv_dispi_t * dispi);
-static lv_action_res_t win_send_rel_action(lv_obj_t * send, lv_dispi_t * dispi);
-static lv_action_res_t win_send_settings_element_rel_action(lv_obj_t * element, lv_dispi_t * dispi);
-static lv_action_res_t win_back_action(lv_obj_t * back, lv_dispi_t * dispi);
-static lv_action_res_t win_del_rel_action(lv_obj_t * del, lv_dispi_t * dispi);
-static lv_action_res_t win_del_lpr_action(lv_obj_t * del, lv_dispi_t * dispi);
-static void send_settings_kb_close_action(lv_obj_t * ta);
-static void send_settings_kb_ok_action(lv_obj_t * ta);
-static void start_send(lv_app_inst_t * app, const char * path);
-static void send_task(void * param);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_app_dsc_t my_app_dsc =
-{
-	.name = "Files",
-	.mode = LV_APP_MODE_NONE,
-	.app_run = my_app_run,
-	.app_close = my_app_close,
-	.com_rec = my_com_rec,
-	.win_open = my_win_open,
-	.win_close = my_win_close,
-	.sc_open = my_sc_open,
-	.sc_close = my_sc_close,
-    .conf_open = my_conf_open,
-	.app_data_size = sizeof(my_app_data_t),
-	.sc_data_size = sizeof(my_sc_data_t),
-	.win_data_size = sizeof(my_win_data_t),
-};
-
-static lv_style_t style_sc_label;
-static lv_style_t style_btn_symbol;
-
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the application
- * @return pointer to the application descriptor of this application
- */
-const lv_app_dsc_t * lv_app_files_init(void)
-{
-    lv_app_style_t * app_style = lv_app_style_get();
-    memcpy(&style_sc_label, &app_style->sc_rec_rel, sizeof(lv_style_t));
-    style_sc_label.font = font_get(LV_APP_FONT_LARGE);
-
-    lv_style_get(LV_STYLE_BTN_REL, &style_btn_symbol);
-    style_btn_symbol.font = font_get(LV_IMG_DEF_SYMBOL_FONT);
-	return &my_app_dsc;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Run an application according to 'app_dsc'
- * @param app_dsc pointer to an application descriptor
- * @param conf pointer to a lv_app_example_conf_t structure with configuration data or NULL if unused
- * @return pointer to the opened application or NULL if any error occurred
- */
-static void my_app_run(lv_app_inst_t * app, void * conf)
-{
-    /*Initialize the application*/
-    my_app_data_t * app_data = app->app_data;
-    app_data->file_cnt = 0;
-    app_data->path[0] = '\0';
-    app_data->fn[0] = '\0';
-    app_data->send_fn = 0;
-    app_data->send_size = 0;
-    app_data->send_crc = 0;
-    app_data->chunk_size = LV_APP_FILES_CHUNK_DEF_SIZE;
-    app_data->chunk_delay = LV_APP_FILES_CHUNK_DEF_TIME;
-    app_data->send_in_prog = 0;
-
-    app_data->send_task = ptask_create(send_task, LV_APP_FILES_CHUNK_DEF_TIME, PTASK_PRIO_OFF, app);
-}
-
-/**
- * Close a running application.
- * Close the Window and the Shortcut too if opened.
- * Free all the allocated memory by this application.
- * @param app pointer to an application
- */
-static void my_app_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_app_data'*/
-    my_app_data_t * app_data = app->app_data;
-    ptask_del(app_data->send_task);
-    if(app_data->send_in_prog != 0) fs_close(&app_data->file);
-
-}
-
-/**
- * Read the data have been sent to this application
- * @param app_send pointer to an application which sent the message
- * @param app_rec pointer to an application which is receiving the message
- * @param type type of data from 'lv_app_com_type_t' enum
- * @param data pointer to the sent data
- * @param size length of 'data' in bytes
- */
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec,
-                       lv_app_com_type_t type , const void * data, uint32_t size)
-{
-    if(type == LV_APP_COM_TYPE_CHAR) {
-        /*Check for file query. E.g. "U:/file.txt?"*/
-        const char * path = data;
-        if(path[size - 1] == '?') {
-            if(size > LV_APP_FILES_PATH_MAX_LEN + LV_APP_FILES_FN_MAX_LEN) {
-                lv_app_notice_add("Can not send file:\ntoo long path");
-            }
-
-            char path_fn[LV_APP_FILES_PATH_MAX_LEN + LV_APP_FILES_FN_MAX_LEN];
-            memcpy(path_fn, data, size - 1); /*-1 to ignore the '?' at the end*/
-            path_fn[size - 1] = '\0';
-            start_send(app_rec, path_fn);
-        }
-    }
-}
-
-/**
- * Open a shortcut for an application
- * @param app pointer to an application
- * @param sc pointer to an object where the application
- *           can create content of the shortcut
- */
-static void my_sc_open(lv_app_inst_t * app, lv_obj_t * sc)
-{
-    my_sc_data_t * sc_data = app->sc_data;
-    my_app_data_t * app_data = app->app_data;
-
-
-    sc_data->label = lv_label_create(sc, NULL);
-    lv_obj_set_style(sc_data->label, &style_sc_label);
-    lv_label_set_text(sc_data->label, fs_get_last(app_data->path));
-    lv_obj_align(sc_data->label, NULL, LV_ALIGN_CENTER, 0, 0);
-}
-
-/**
- * Close the shortcut of an application
- * @param app pointer to an application
- */
-static void my_sc_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_sc_data'*/
-}
-
-
-/**
- * Open the application in a window
- * @param app pointer to an application
- * @param win pointer to a window object where
- *            the application can create content
- */
-static void my_win_open(lv_app_inst_t * app, lv_obj_t * win)
-{
-    my_win_data_t * win_data = app->win_data;
-    my_app_data_t * app_data = app->app_data;
-
-    app_data->file_cnt = 0;
-    win_data->file_list = NULL;
-
-    lv_win_set_title(win, app_data->path);
-
-    win_load_file_list(app);
-}
-
-/**
- * Close the window of an application
- * @param app pointer to an application
- */
-static void my_win_close(lv_app_inst_t * app)
-{
-
-}
-
-/**
- * Create objects to configure the applications
- * @param app pointer to an application which settings should be created
- * @param conf_win pointer to a window where the objects can be created
- *                (the window has the proper layout)
- */
-static void my_conf_open(lv_app_inst_t * app, lv_obj_t * conf_win)
-{
-    my_app_data_t * app_data = app->app_data;
-
-    /*Create check boxes*/
-    lv_obj_t * cb;
-
-    /*Send file name check box*/
-    cb = lv_cb_create(conf_win, NULL);
-    lv_cb_set_text(cb, "Send file name");
-    lv_obj_set_free_num(cb, SEND_SETTINGS_FN);
-    lv_obj_set_free_p(cb, app);
-    lv_btn_set_rel_action(cb, win_send_settings_element_rel_action);
-    if(app_data->send_fn != 0) lv_btn_set_state(cb, LV_BTN_STATE_TREL);
-    else lv_btn_set_state(cb, LV_BTN_STATE_REL);
-
-    /*Send size check box*/
-    cb = lv_cb_create(conf_win, cb);
-    lv_cb_set_text(cb, "Send size");
-    lv_obj_set_free_num(cb, SEND_SETTINGS_SIZE);
-    if(app_data->send_size != 0) lv_btn_set_state(cb, LV_BTN_STATE_TREL);
-    else lv_btn_set_state(cb, LV_BTN_STATE_REL);
-
-    /*Send CRC check box*/
-    cb = lv_cb_create(conf_win, cb);
-    lv_cb_set_text(cb, "Send CRC");
-    lv_obj_set_free_num(cb, SEND_SETTINGS_CRC);
-    if(app_data->send_crc != 0) lv_btn_set_state(cb, LV_BTN_STATE_TREL);
-    else lv_btn_set_state(cb, LV_BTN_STATE_REL);
-
-    /*Create a text area to type chunk size*/
-    lv_obj_t * val_set_h;
-    val_set_h = lv_cont_create(conf_win, NULL);
-    lv_obj_set_style(val_set_h, lv_style_get(LV_STYLE_PLAIN_COLOR, NULL));
-    lv_obj_set_click(val_set_h, false);
-    lv_cont_set_fit(val_set_h, true, true);
-    lv_cont_set_layout(val_set_h, LV_CONT_LAYOUT_ROW_M);
-
-    lv_obj_t * label;
-    label = lv_label_create(val_set_h, NULL);
-    lv_label_set_text(label, "Chunk size");
-
-    lv_obj_t * ta;
-    char buf[32];
-    ta = lv_ta_create(val_set_h, NULL);
-    lv_cont_set_fit(ta, false, true);
-    lv_obj_set_free_num(ta, SEND_SETTINGS_CHUNK_SIZE);
-    lv_obj_set_free_p(ta, app);
-    lv_page_set_rel_action(ta, win_send_settings_element_rel_action);
-    sprintf(buf, "%d", app_data->chunk_size);
-    lv_ta_set_text(ta, buf);
-
-    /*Create a text area to type the chunk delay*/
-    val_set_h = lv_cont_create(conf_win, val_set_h);
-
-    label = lv_label_create(val_set_h, NULL);
-    lv_label_set_text(label, "Inter-chunk delay");
-
-    ta = lv_ta_create(val_set_h, ta);
-    lv_obj_set_free_num(ta, SEND_SETTINGS_CHUNK_DELAY);
-    sprintf(buf, "%d", app_data->chunk_delay);
-    lv_ta_set_text(ta, buf);
-}
-
-/*--------------------
- * OTHER FUNCTIONS
- ---------------------*/
-/**
- * Create an mpty list on the window. 'win_load_file_list' will fill it.
- * @param app pointer to a Files application
- */
-static void win_create_list(lv_app_inst_t * app)
-{
-    my_win_data_t * win_data = app->win_data;
-
-    /*Delete the previous list*/
-    if(win_data->file_list != NULL) {
-      lv_obj_del(win_data->file_list);
-    }
-
-    /*Create a new list*/
-    win_data->file_list = lv_list_create(app->win, NULL);
-    lv_obj_set_width(win_data->file_list, lv_win_get_width(app->win));
-    lv_list_set_style_img(win_data->file_list, &style_btn_symbol);
-    lv_obj_set_style(lv_page_get_scrl(win_data->file_list), lv_style_get(LV_STYLE_TRANSP_TIGHT, NULL));
-    lv_obj_set_drag_parent(win_data->file_list, true);
-    lv_obj_set_drag_parent(lv_page_get_scrl(win_data->file_list), true);
-    lv_cont_set_fit(win_data->file_list, false, true);
-    lv_cont_set_layout(lv_page_get_scrl(win_data->file_list), LV_CONT_LAYOUT_COL_L);
-}
-
-/**
- * Load the file list from the current path on the window
- * @param app pointer to a Files application
- */
-static void win_load_file_list(lv_app_inst_t * app)
-{
-    my_app_data_t * app_data = app->app_data;
-    my_win_data_t * win_data = app->win_data;
-
-    /*Create a new list*/
-    win_create_list(app);
-
-    fs_res_t res = FS_RES_OK;
-
-      /*At empty path show the drivers */
-    lv_obj_t * liste;
-    if(app_data->path[0] == '\0') {
-        char drv[16];
-        char buf[2];
-        fs_get_letters(drv);
-        uint8_t i;
-        for(i = 0; drv[i] != '\0'; i++) {
-            buf[0] = drv[i];
-            buf[1] = '\0';
-            liste = lv_list_add(win_data->file_list, SYMBOL_DRIVE, buf, win_drv_action);
-            lv_obj_set_free_p(liste, app);
-        }
-    }
-    /*List the files/folders with fs interface*/
-    else {
-        liste = lv_list_add(win_data->file_list, SYMBOL_UP, "Up", win_up_action);
-        lv_obj_set_free_p(liste, app);
-
-        fs_readdir_t rd;
-        res = fs_readdir_init(&rd, app_data->path);
-        if(res != FS_RES_OK) {
-            lv_app_notice_add("Can not read the\npath in Files");
-        return;
-        }
-
-        /*At not first page add prev. page button */
-        if(app_data->file_cnt != 0) {
-            liste = lv_list_add(win_data->file_list, SYMBOL_LEFT, "Previous page", win_prev_action);
-            lv_obj_set_free_p(liste, app);
-        }
-
-        char fn[LV_APP_FILES_FN_MAX_LEN];
-
-        /*Read the files from the previous pages*/
-        uint16_t file_cnt = 0;
-        while(file_cnt <= app_data->file_cnt) {
-            res = fs_readdir(&rd, fn);
-            if(res != FS_RES_OK ){
-                lv_app_notice_add("Can not read\nthe path in Files");
-                return;
-            }
-            file_cnt ++;
-        }
-
-        /*Add list elements from the files and folders*/
-        while(res == FS_RES_OK && fn[0] != '\0') {
-            if(fn[0] == '/') { /*Add a folder*/
-                lv_obj_t * liste;
-                liste = lv_list_add(win_data->file_list, SYMBOL_FOLDER, &fn[1], win_folder_action);
-                lv_obj_set_free_p(liste, app);
-                app_data->file_cnt ++;
-            }
-            /*Add a file*/
-            else {
-                liste = lv_list_add(win_data->file_list, SYMBOL_FILE, fn, win_file_action);
-                lv_obj_set_free_p(liste, app);
-                app_data->file_cnt ++;
-            }
-
-            /*Get the next element*/
-            res = fs_readdir(&rd, fn);
-
-            /*Show only LV_APP_FSEL_MAX_FILE elements and add a Next page button*/
-            if(app_data->file_cnt != 0 && app_data->file_cnt % LV_APP_FILES_PAGE_SIZE == 0) {
-                liste = lv_list_add(win_data->file_list, SYMBOL_RIGHT, "Next page", win_next_action);
-                lv_obj_set_free_p(liste, app);
-                break;
-            }
-        }
-
-      /*Close the read directory*/
-      fs_readdir_close(&rd);
-    }
-
-    if(res != FS_RES_OK) {
-        lv_app_notice_add("Can not read\nthe path in Files");
-    }
-
-    /*Focus to the top of the list*/
-    lv_obj_set_y(lv_page_get_scrl(win_data->file_list), 0);
-    return;
-}
-
-
-/**
- * Called when the Up list element is released to step one level
- * @param up pointer to the Up button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t win_up_action(lv_obj_t * up, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(up);
-    my_app_data_t * app_data = app->app_data;
-    fs_up(app_data->path);
-    app_data->file_cnt = 0;
-    lv_win_set_title(app->win, app_data->path);
-
-    my_sc_data_t * sc_data = app->sc_data;
-    if(sc_data != NULL) {
-        lv_label_set_text(sc_data->label, fs_get_last(app_data->path));
-        lv_obj_align(sc_data->label, NULL, LV_ALIGN_CENTER, 0, 0);
-    }
-
-    win_load_file_list(app);
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when the Next list element is released to go to the next page
- * @param next pointer to the Next button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t win_next_action(lv_obj_t * next, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(next);
-    win_load_file_list(app);
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when the Prev list element is released to previous page
- * @param prev pointer to the Prev button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t win_prev_action(lv_obj_t * prev, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(prev);
-    my_app_data_t * app_data = app->app_data;
-    if(app_data->file_cnt <= 2 * LV_APP_FILES_PAGE_SIZE) app_data->file_cnt = 0;
-    else if(app_data->file_cnt % LV_APP_FILES_PAGE_SIZE == 0) {
-        app_data->file_cnt -= 2 * LV_APP_FILES_PAGE_SIZE;
-    } else {
-        app_data->file_cnt = ((app_data->file_cnt / LV_APP_FILES_PAGE_SIZE) - 1) * LV_APP_FILES_PAGE_SIZE;
-    }
-
-    win_load_file_list(app);
-    return LV_ACTION_RES_INV;
-}
-
-
-/**
- * Called when the Driver list element is released to step into a driver
- * @param drv pointer to the Driver button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t win_drv_action(lv_obj_t * drv, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(drv);
-    my_app_data_t * app_data = app->app_data;
-    sprintf(app_data->path, "%s:", lv_list_get_element_text(drv));
-    app_data->file_cnt = 0;
-    lv_win_set_title(app->win, app_data->path);
-    my_sc_data_t * sc_data = app->sc_data;
-    if(sc_data != NULL) {
-        lv_label_set_text(sc_data->label, fs_get_last(app_data->path));
-        lv_obj_align(sc_data->label, NULL, LV_ALIGN_CENTER, 0, 0);
-    }
-
-    win_load_file_list(app);
-    return LV_ACTION_RES_INV;
-}
-
-
-/**
- * Called when a folder list element is released to enter into it
- * @param folder pointer to a folder button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t win_folder_action(lv_obj_t * folder, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(folder);
-    my_app_data_t * app_data = app->app_data;
-    sprintf(app_data->path, "%s/%s", app_data->path, lv_list_get_element_text(folder));
-    app_data->file_cnt = 0;
-
-    lv_win_set_title(app->win, app_data->path);
-    my_sc_data_t * sc_data = app->sc_data;
-    if(sc_data != NULL) {
-        lv_label_set_text(sc_data->label, fs_get_last(app_data->path));
-        lv_obj_align(sc_data->label, NULL, LV_ALIGN_CENTER, 0, 0);
-    }
-
-
-    win_load_file_list(app);
-    return LV_ACTION_RES_INV;
-}
-
-
-/**
- * Called when a file list element is released to show the list of operation on it
- * @param file pointer to a file button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t win_file_action(lv_obj_t * file, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(file);
-    my_app_data_t * app_data = app->app_data;
-    my_win_data_t * win_data = app->win_data;
-
-    sprintf(app_data->fn, "%s", lv_list_get_element_text(file));
-
-    win_create_list(app);
-
-    /*Create the list of operations*/
-    lv_obj_t * liste;
-    liste = lv_list_add(win_data->file_list, "U:/icon_left", "Back", win_back_action);
-    lv_obj_set_free_p(liste, app);
-
-    /*Send button*/
-    liste = lv_list_add(win_data->file_list, NULL, "Send", win_send_rel_action);
-    lv_obj_set_free_p(liste, app);
-
-    /*Delete button*/
-    liste = lv_list_add(win_data->file_list, NULL, "Delete", win_del_rel_action);
-    lv_btn_set_lpr_action(liste, win_del_lpr_action);
-    lv_obj_set_free_p(liste, app);
-
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when the Back list element is released to when a file chosen to
- * go back to the file list from file operation
- * @param back pointer to the back button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_INV because the list is deleted in the function
- */
-static lv_action_res_t win_back_action(lv_obj_t * up, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(up);
-    my_app_data_t * app_data = app->app_data;
-
-    app_data->file_cnt = 0;
-    win_load_file_list(app);
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Called when the Send list element is released to send the file
- * @param sed pointer to the Up button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the list is NOT deleted in the function
- */
-static lv_action_res_t win_send_rel_action(lv_obj_t * send, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(send);
-    my_app_data_t * app_data = app->app_data;
-
-    if(app_data->send_in_prog != 0) {
-        lv_app_notice_add("File sending\nin progress");
-        return LV_ACTION_RES_OK;
-    }
-
-    char path_fn[LV_APP_FILES_PATH_MAX_LEN + LV_APP_FILES_FN_MAX_LEN];
-    sprintf(path_fn, "%s/%s", app_data->path, app_data->fn);
-    start_send(app, path_fn);
-
-    return LV_ACTION_RES_OK;
-}
-
-/**
- * Called when a send settings element is released
- * @param element pointer to a chekbox or text area
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the list is NOT deleted in the function
- */
-static lv_action_res_t win_send_settings_element_rel_action(lv_obj_t * element, lv_dispi_t * dispi)
-{
-    send_settings_id_t id = lv_obj_get_free_num(element);
-    lv_app_inst_t * app = lv_obj_get_free_p(element);
-    my_app_data_t * app_data = app->app_data;
-
-    if(id == SEND_SETTINGS_FN) {
-        app_data->send_fn = lv_btn_get_state(element) == LV_BTN_STATE_REL ? 0 : 1;
-    } else if(id == SEND_SETTINGS_SIZE) {
-        app_data->send_size = lv_btn_get_state(element) == LV_BTN_STATE_REL ? 0 : 1;
-    } else if(id == SEND_SETTINGS_CRC) {
-        app_data->send_crc = lv_btn_get_state(element) == LV_BTN_STATE_REL ? 0 : 1;
-
-        /*TODO CRC sending is not supported yet*/
-        if(app_data->send_crc != 0) {
-            lv_app_notice_add("CRC sending is\nnot supported yet");
-        }
-    } else if(id == SEND_SETTINGS_CHUNK_SIZE) {
-        lv_app_kb_open(element, LV_APP_KB_MODE_NUM | LV_APP_KB_MODE_WIN_RESIZE, send_settings_kb_close_action, send_settings_kb_ok_action);
-    } else if(id == SEND_SETTINGS_CHUNK_DELAY) {
-        lv_app_kb_open(element, LV_APP_KB_MODE_NUM | LV_APP_KB_MODE_WIN_RESIZE, send_settings_kb_close_action, send_settings_kb_ok_action);
-    }
-
-    return LV_ACTION_RES_OK;
-}
-
-
-/**
- * Called when the Delete list element is released.
- * It will show a notification to long press the Delete button to remove the file
- * @param del pointer to the back button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the list is NOT deleted in the function
- */
-static lv_action_res_t win_del_rel_action(lv_obj_t * del, lv_dispi_t * dispi)
-{
-    lv_app_notice_add("Press long the Delete button\n"
-                      "to remove the file");
-
-    return LV_ACTION_RES_OK;
-}
-/**
- * Called when the Delete list element is long pressed to remove a file
- * @param del pointer to the Delete button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the list is NOT deleted in the function
- */
-static lv_action_res_t win_del_lpr_action(lv_obj_t * del, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(del);
-    my_app_data_t * app_data = app->app_data;
-
-    char path_fn[LV_APP_FILES_PATH_MAX_LEN + LV_APP_FILES_FN_MAX_LEN];
-    sprintf(path_fn, "%s/%s", app_data->path, app_data->fn);
-
-    fs_res_t res = fs_remove(path_fn);
-    if(res == FS_RES_OK) lv_app_notice_add("%s deleted", app_data->fn);
-    else lv_app_notice_add("Can not delete\n%s", app_data->fn);
-
-    return LV_ACTION_RES_OK;
-}
-
-/**
- * Called when a send setting is typed and 'Close' pressed on the App. keyboard.
- * The function reverts the original value in the text area.
- * @param ta pointer to a text area
- */
-static void send_settings_kb_close_action(lv_obj_t * ta)
-{
-    send_settings_id_t id = lv_obj_get_free_num(ta);
-    lv_app_inst_t * app = lv_obj_get_free_p(ta);
-    my_app_data_t * app_data = app->app_data;
-
-    char buf[32];
-    buf[0] = '\0';
-
-    if(id == SEND_SETTINGS_CHUNK_DELAY) {
-        sprintf(buf, "%d", app_data->chunk_size);
-    } else if(id == SEND_SETTINGS_CHUNK_SIZE) {
-        sprintf(buf, "%d", app_data->chunk_size);
-    }
-    lv_ta_set_text(ta, buf);
-}
-
-/**
- * Called when a send setting is typed and 'Ok' pressed on the App. keyboard.
- * The function saves teh new value.
- * @param ta pointer to a text area
- */
-static void send_settings_kb_ok_action(lv_obj_t * ta)
-{
-    send_settings_id_t id = lv_obj_get_free_num(ta);
-    lv_app_inst_t * app = lv_obj_get_free_p(ta);
-    my_app_data_t * app_data = app->app_data;
-
-    int num;
-    sscanf(lv_ta_get_txt(ta), "%d", &num);
-
-    if(id == SEND_SETTINGS_CHUNK_DELAY) {
-        if(num > LV_APP_FILES_CHUNK_MAX_TIME) num = LV_APP_FILES_CHUNK_MAX_TIME;
-        if(num < LV_APP_FILES_CHUNK_MIN_TIME) num = LV_APP_FILES_CHUNK_MIN_TIME;
-        app_data->chunk_delay = (uint16_t) num;
-    } else if(id == SEND_SETTINGS_CHUNK_SIZE) {
-        if(num > LV_APP_FILES_CHUNK_MAX_SIZE) num = LV_APP_FILES_CHUNK_MAX_SIZE;
-        if(num < LV_APP_FILES_CHUNK_MIN_SIZE) num = LV_APP_FILES_CHUNK_MIN_SIZE;
-        app_data->chunk_size= (uint16_t) num;
-    }
-
-}
-
-/**
- * Start the sending of a file
- * @param app pointer to a Files application
- * @param path path of the file to send
- */
-static void start_send(lv_app_inst_t * app, const char * path)
-{
-    my_app_data_t * app_data = app->app_data;
-
-    /*Open the file*/
-    fs_res_t res = fs_open(&app_data->file, path, FS_MODE_RD);
-    if(res == FS_RES_OK) {
-        app_data->send_in_prog = 1;
-
-        /*Send the header*/
-        if(app_data->send_fn != 0) {
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, app_data->path, strlen(app_data->path));
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, "/", 1);
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, app_data->fn, strlen(app_data->fn));
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, "\n", 1);
-        }
-
-        if(app_data->send_size != 0) {
-            char buf[64];
-            uint32_t size;
-            fs_size(&app_data->file, &size);
-            sprintf(buf,"%d", (int) size);
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, buf, strlen(buf));
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, "\n", 1);
-        }
-        if(app_data->send_crc != 0) {
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, "0x0000", 6);
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, "\n", 1);
-        }
-
-        /*Add an extra \n to separate the header from the file data*/
-        if(app_data->send_fn != 0 || app_data->send_size != 0 || app_data->send_crc != 0) {
-            lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, "\n", 1);
-        } 
-    }
-
-    /*If an error occurred  close the file*/
-    if(res != FS_RES_OK) {
-        fs_close(&app_data->file);
-        ptask_set_prio(app_data->send_task, PTASK_PRIO_OFF);
-        app_data->send_in_prog = 0;
-        lv_app_notice_add("Can not send\nthe file in Files");
-    }
-    /*If no error show notification, start the sender task and refresh the shortcut*/
-    else {
-       /*Start the sender task*/
-       ptask_set_period(app_data->send_task, app_data->chunk_delay);
-       ptask_reset(app_data->send_task);
-       ptask_set_prio(app_data->send_task, PTASK_PRIO_HIGH);
-       lv_app_notice_add("Sending\n%s", fs_get_last(path));
-
-       /*Refresh the shortcut with the percentage of the sending*/
-       if(app->sc_data != NULL) {
-           my_sc_data_t * sc_data = app->sc_data;
-
-           uint32_t size;
-           fs_size(&app_data->file, &size);
-           uint32_t pos;
-           fs_tell(&app_data->file, &pos);
-
-           int pct = (uint32_t) (pos * 100) / size;
-
-           char buf[256];
-           sprintf(buf, "Sending\n%d%%", pct);
-           lv_label_set_text(sc_data->label, buf);
-           lv_obj_align(sc_data->label, NULL, LV_ALIGN_CENTER, 0, 0);
-       }
-   }
-}
-
-/**
- * Periodically send the next chunk of the file
- * @param app pointer to a Files application
- */
-static void send_task(void * param)
-{
-    lv_app_inst_t * app = param;
-    my_app_data_t * app_data = app->app_data;
-
-    if(app_data->send_in_prog == 0) return;
-
-    /*Read a chunk*/
-    uint32_t rn;
-    char rd_buf[LV_APP_FILES_CHUNK_MAX_SIZE];
-    fs_res_t res = fs_read(&app_data->file, rd_buf, app_data->chunk_size, &rn);
-    if(res == FS_RES_OK) {
-       app_data->send_in_prog = 1;
-       lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, rd_buf, rn);
-    }
-
-    /*If the read failed close the file and show an error*/
-    if(res != FS_RES_OK) {
-       fs_close(&app_data->file);
-       app_data->send_in_prog = 0;
-       lv_app_notice_add("Can not send\nthe file in Files");
-    }
-    /*If the read was successful*/
-    else {
-        my_sc_data_t * sc_data = app->sc_data;
-
-        /*If the file is read close it a show a notification*/
-        if(rn < app_data->chunk_size) {
-            lv_app_notice_add("File sent");
-            fs_close(&app_data->file);
-            app_data->send_in_prog = 0;
-
-            /*Refresh the shortut*/
-            if(sc_data != NULL) {
-                lv_label_set_text(sc_data->label, fs_get_last(app_data->path));
-                lv_obj_align(sc_data->label, NULL, LV_ALIGN_CENTER, 0, 0);
-            }
-        }
-        /*If the file is not sent yet refresh the shortcut with percentage of sending*/
-        else {
-            if(sc_data != NULL) {
-                uint32_t size;
-                fs_size(&app_data->file, &size);
-                uint32_t pos;
-                fs_tell(&app_data->file, &pos);
-
-                uint8_t pct = (uint32_t) (pos * 100) / size;
-
-                char buf[256];
-                sprintf(buf, "Sending\n%d%%", pct);
-                lv_label_set_text(sc_data->label, buf);
-                lv_obj_align(sc_data->label, NULL, LV_ALIGN_CENTER, 0, 0);
-            }
-        }
-    }
-}
-
-#endif /*LV_APP_ENABLE != 0 && USE_LV_APP_FILES != 0*/

lv_appx/lv_app_phantom.c

@@ -1,143 +0,0 @@
-/**
- * @file lv_app_example.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_app_phantom.h"
-#if LV_APP_ENABLE != 0 && USE_LV_APP_PHANTOM != 0
-
-#include "../lv_app/lv_app_util/lv_app_kb.h"
-#include <stdio.h>
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Application specific data for an instance of this application*/
-typedef struct
-{
-    void (*com_listen)(lv_app_inst_t * app_send, lv_app_inst_t * app_rec,
-                       lv_app_com_type_t type , const void * data, uint32_t size);
-}my_app_data_t;
-
-/*Application specific data a window of this application*/
-typedef struct
-{
-
-}my_win_data_t;
-
-/*Application specific data for a shortcut of this application*/
-typedef struct
-{
-    lv_obj_t * label;
-}my_sc_data_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void my_app_run(lv_app_inst_t * app, void * conf);
-static void my_app_close(lv_app_inst_t * app);
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec,
-                       lv_app_com_type_t type , const void * data, uint32_t size);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_app_dsc_t my_app_dsc =
-{
-	.name = "Phantom",
-	.mode = LV_APP_MODE_NONE,
-	.app_run = my_app_run,
-	.app_close = my_app_close,
-	.com_rec = my_com_rec,
-	.win_open = NULL,
-	.win_close = NULL,
-	.sc_open = NULL,
-	.sc_close = NULL,
-	.app_data_size = sizeof(my_app_data_t),
-	.sc_data_size = sizeof(my_sc_data_t),
-	.win_data_size = sizeof(my_win_data_t),
-};
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the application
- * @return pointer to the application descriptor of this application
- */
-const lv_app_dsc_t * lv_app_phantom_init(void)
-{
-
-	return &my_app_dsc;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Run an application according to 'app_dsc'
- * @param app_dsc pointer to an application descriptor
- * @param conf pointer to a lv_app_phantom_conf_t structure with configuration data or NULL if unused
- * @return pointer to the opened application or NULL if any error occurred
- */
-static void my_app_run(lv_app_inst_t * app, void * conf)
-{
-    /*Initialize the application*/
-    my_app_data_t * app_data = app->app_data;
-    app_data->com_listen = NULL;
-
-    if(conf != NULL) {
-        lv_app_phantom_conf_t * my_conf = conf;
-        app_data->com_listen = my_conf->com_listen;
-    }
-}
-
-/**
- * Close a running application.
- * Close the Window and the Shortcut too if opened.
- * Free all the allocated memory by this application.
- * @param app pointer to an application
- */
-static void my_app_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_app_data'*/
-}
-
-/**
- * Read the data have been sent to this application
- * @param app_send pointer to an application which sent the message
- * @param app_rec pointer to an application which is receiving the message
- * @param type type of data from 'lv_app_com_type_t' enum
- * @param data pointer to the sent data
- * @param size length of 'data' in bytes
- */
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec,
-                       lv_app_com_type_t type , const void * data, uint32_t size)
-{
-
-    my_app_data_t * app_data = app_rec->app_data;
-
-    if(app_data->com_listen != NULL) {
-        app_data->com_listen(app_send, app_rec, type, data, size);
-    }
-}
-
-/*--------------------
- * OTHER FUNCTIONS
- ---------------------*/
-
-#endif /*LV_APP_ENABLE != 0 && USE_LV_APP_EXAMPLE != 0*/

lv_appx/lv_app_phantom.h

@@ -1,42 +0,0 @@
-/**
- * @file lv_app_phantom.h
- *
- */
-
-#ifndef LV_APP_PHANTOM_H
-#define LV_APP_PHANTOM_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lvgl/lv_app/lv_app.h"
-
-#if LV_APP_ENABLE != 0 && USE_LV_APP_PHANTOM != 0
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-typedef struct
-{
-    void (*com_listen)(lv_app_inst_t * app_send,
-                       lv_app_inst_t * app_rec,
-                       lv_app_com_type_t type ,
-                       const void * data, uint32_t size);
-}lv_app_phantom_conf_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-const lv_app_dsc_t * lv_app_phantom_init(void);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_APP_ENABLE != 0 && USE_LV_APP_PHANTOM != 0*/
-
-#endif /* LV_APP_PHANTOM_H */

lv_appx/lv_app_sysmon.c

@@ -1,399 +0,0 @@
-/**
- * @file lv_app_sysmon.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_app_sysmon.h"
-#if LV_APP_ENABLE != 0 && USE_LV_APP_SYSMON != 0
-
-#include <stdio.h>
-#include "misc/os/ptask.h"
-#include "misc/os/idle.h"
-#include "lvgl/lv_objx/lv_chart.h"
-#include "lvgl/lv_app/lv_app_util/lv_app_notice.h"
-#include "hal/systick/systick.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define CPU_LABEL_COLOR "FF0000"
-#define MEM_LABEL_COLOR "0000FF"
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Application specific data for an instance of this application*/
-typedef struct
-{
-
-}my_app_data_t;
-
-/*Application specific data a window of this application*/
-typedef struct
-{
-    lv_obj_t * chart;
-    lv_chart_dl_t * cpu_dl;
-    lv_chart_dl_t * mem_dl;
-    lv_obj_t * label;
-}my_win_data_t;
-
-/*Application specific data for a shortcut of this application*/
-typedef struct
-{
-    lv_obj_t * bar_cpu;
-    lv_obj_t * bar_mem;
-}my_sc_data_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void my_app_run(lv_app_inst_t * app, void * conf);
-static void my_app_close(lv_app_inst_t * app);
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec, lv_app_com_type_t type , const void * data, uint32_t size);
-static void my_sc_open(lv_app_inst_t * app, lv_obj_t * sc);
-static void my_sc_close(lv_app_inst_t * app);
-static void my_win_open(lv_app_inst_t * app, lv_obj_t * win);
-static void my_win_close(lv_app_inst_t * app);
-
-static void sysmon_task(void * param);
-static void lv_app_sysmon_refr(void);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_app_dsc_t my_app_dsc =
-{
-	.name = "Sys. monitor",
-	.mode = LV_APP_MODE_NONE,
-	.app_run = my_app_run,
-	.app_close = my_app_close,
-	.com_rec = my_com_rec,
-	.win_open = my_win_open,
-	.win_close = my_win_close,
-	.sc_open = my_sc_open,
-	.sc_close = my_sc_close,
-	.app_data_size = sizeof(my_app_data_t),
-	.sc_data_size = sizeof(my_sc_data_t),
-	.win_data_size = sizeof(my_win_data_t),
-};
-
-static uint8_t mem_pct[LV_APP_SYSMON_PNUM];
-static uint8_t cpu_pct[LV_APP_SYSMON_PNUM];
-static lv_style_t cpu_bar_bg;
-static lv_style_t mem_bar_bg;
-static lv_style_t cpu_bar_indic;
-static lv_style_t mem_bar_indic;
-#if USE_DYN_MEM != 0  && DM_CUSTOM == 0
-static  dm_mon_t mem_mon;
-#endif
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the application
- * @return pointer to the application descriptor of this application
- */
-const lv_app_dsc_t * lv_app_sysmon_init(void)
-{
-    ptask_create(sysmon_task, LV_APP_SYSMON_REFR_TIME, PTASK_PRIO_LOW, NULL);
-
-    memset(mem_pct, 0, sizeof(mem_pct));
-    memset(cpu_pct, 0, sizeof(cpu_pct));
-
-    /*Create bar styles for the shortcut*/
-    lv_style_get(LV_STYLE_PRETTY, &cpu_bar_bg);
-    cpu_bar_bg.ccolor = COLOR_MAKE(0x40, 0x00, 0x00);
-    cpu_bar_bg.font = font_get(LV_APP_FONT_MEDIUM);
-    cpu_bar_bg.line_space = 0;
-    cpu_bar_bg.txt_align = 1;
-    cpu_bar_bg.hpad = 0;
-    cpu_bar_bg.vpad = 0;
-
-    memcpy(&mem_bar_bg, &cpu_bar_bg, sizeof(lv_style_t));
-    mem_bar_bg.ccolor = COLOR_MAKE(0x00, 0x40, 0x00);
-
-    lv_style_get(LV_STYLE_PRETTY_COLOR, &cpu_bar_indic);
-    cpu_bar_indic.gcolor = COLOR_MARRON;
-    cpu_bar_indic.mcolor = COLOR_RED;
-    cpu_bar_indic.bcolor = COLOR_BLACK;
-    //cpu_bar_indic.bwidth = 1 * LV_DOWNSCALE;
-    cpu_bar_indic.bopa = OPA_50;
-    cpu_bar_indic.hpad = 0 * LV_DOWNSCALE;
-    cpu_bar_indic.vpad = 0 * LV_DOWNSCALE;
-
-
-    memcpy(&mem_bar_indic, &cpu_bar_indic, sizeof(lv_style_t));
-    mem_bar_indic.gcolor = COLOR_GREEN;
-    mem_bar_indic.mcolor = COLOR_LIME;
-
-	return &my_app_dsc;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Run an application according to 'app_dsc'
- * @param app_dsc pointer to an application descriptor
- * @param conf pointer to a lv_app_sysmon_conf_t structure with configuration data or NULL if unused
- * @return pointer to the opened application or NULL if any error occurred
- */
-static void my_app_run(lv_app_inst_t * app,  void * conf)
-{
-
-}
-
-/**
- * Close a running application.
- * Close the Window and the Shortcut too if opened.
- * Free all the allocated memory by this application.
- * @param app pointer to an application
- */
-static void my_app_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_app_data'*/
-}
-
-/**
- * Read the data have been sent to this application
- * @param app_send pointer to an application which sent the message
- * @param app_rec pointer to an application which is receiving the message
- * @param type type of data from 'lv_app_com_type_t' enum
- * @param data pointer to the sent data
- * @param size length of 'data' in bytes
- */
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec,
-                       lv_app_com_type_t type , const void * data, uint32_t size)
-{
-
-}
-
-/**
- * Open a shortcut for an application
- * @param app pointer to an application
- * @param sc pointer to an object where the application
- *           can create content of the shortcut
- */
-static void my_sc_open(lv_app_inst_t * app, lv_obj_t * sc)
-{
-    my_sc_data_t * sc_data = app->sc_data;
-
-    cord_t w = lv_obj_get_width(sc) / 5;
-
-    /*Create 2 bars for the CPU and the Memory*/
-    sc_data->bar_cpu = lv_bar_create(sc, NULL);
-    lv_obj_set_size(sc_data->bar_cpu, w, 5 * lv_obj_get_height(sc) / 8);
-    lv_obj_align(sc_data->bar_cpu, NULL, LV_ALIGN_IN_BOTTOM_LEFT, w, - lv_obj_get_height(sc) / 8);
-    lv_obj_set_style(sc_data->bar_cpu, &cpu_bar_bg);
-    lv_bar_set_style_indic(sc_data->bar_cpu, &cpu_bar_indic);
-    lv_obj_set_click(sc_data->bar_cpu, false);
-    lv_bar_set_range(sc_data->bar_cpu, 0, 100);
-    lv_obj_t * label = lv_label_create(sc_data->bar_cpu, NULL);
-    lv_label_set_text(label, "C\nP\nU");
-    lv_obj_align(label, NULL, LV_ALIGN_CENTER, 0, 0);
-
-    sc_data->bar_mem = lv_bar_create(sc, sc_data->bar_cpu);
-    lv_obj_align(sc_data->bar_mem, sc_data->bar_cpu, LV_ALIGN_OUT_RIGHT_MID, w, 0);
-    lv_obj_set_style(sc_data->bar_mem, &mem_bar_bg);
-    lv_bar_set_style_indic(sc_data->bar_mem, &mem_bar_indic);
-    label = lv_label_create(sc_data->bar_mem, NULL);
-    lv_label_set_text(label, "M\nE\nM");
-    lv_obj_align(label, NULL, LV_ALIGN_CENTER, 0, 0);
-
-    lv_app_sysmon_refr();
-}
-
-/**
- * Close the shortcut of an application
- * @param app pointer to an application
- */
-static void my_sc_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_sc_data'*/
-}
-
-
-/**
- * Open the application in a window
- * @param app pointer to an application
- * @param win pointer to a window object where
- *            the application can create content
- */
-static void my_win_open(lv_app_inst_t * app, lv_obj_t * win)
-{
-    my_win_data_t * win_data = app->win_data;
-
-    /*Make the window content responsive*/
-    lv_cont_set_layout(lv_page_get_scrl(lv_win_get_page(win)), LV_CONT_LAYOUT_PRETTY);
-
-    /*Create a chart with two data lines*/
-    win_data->chart = lv_chart_create(win, NULL);
-    lv_obj_set_size(win_data->chart, LV_HOR_RES / 2, LV_VER_RES / 2);
-    lv_obj_set_pos(win_data->chart, LV_DPI / 10, LV_DPI / 10);
-    lv_chart_set_pnum(win_data->chart, LV_APP_SYSMON_PNUM);
-    lv_chart_set_range(win_data->chart, 0, 100);
-    lv_chart_set_type(win_data->chart, LV_CHART_LINE);
-    lv_chart_set_dl_width(win_data->chart, 2 * LV_DOWNSCALE);
-    win_data->cpu_dl =  lv_chart_add_data_line(win_data->chart, COLOR_RED);
-    win_data->mem_dl =  lv_chart_add_data_line(win_data->chart, COLOR_BLUE);
-
-    uint16_t i;
-    for(i = 0; i < LV_APP_SYSMON_PNUM; i ++) {
-        win_data->cpu_dl->points[i] = cpu_pct[i];
-        win_data->mem_dl->points[i] = mem_pct[i];
-    }
-
-    /*Create a label for the details of Memory and CPU usage*/
-    win_data->label = lv_label_create(win, NULL);
-    lv_label_set_recolor(win_data->label, true);
-    lv_obj_align(win_data->label, win_data->chart, LV_ALIGN_OUT_RIGHT_TOP, LV_DPI / 4, 0);
-
-
-    lv_app_sysmon_refr();
-}
-
-/**
- * Close the window of an application
- * @param app pointer to an application
- */
-static void my_win_close(lv_app_inst_t * app)
-{
-
-}
-
-/*--------------------
- * OTHER FUNCTIONS
- ---------------------*/
-
-/**
- * Called periodically to monitor the CPU and memory usage.
- * It refreshes the shortcuts and windows and also add notifications if there is any problem.
- * @param param unused
- */
-static void sysmon_task(void * param)
-{
-    /*Shift out the oldest data*/
-    uint16_t i;
-    for(i = 1; i < LV_APP_SYSMON_PNUM; i++) {
-        mem_pct[i - 1] = mem_pct[i];
-        cpu_pct[i - 1] = cpu_pct[i];
-    }
-
-    /*Get CPU and memory information */
-    uint8_t cpu_busy = 0;
-#if USE_IDLE != 0   /*Use the more precise idle module if enabled*/
-    cpu_busy = 100 - idle_get();
-#else
-    cpu_busy = 100 - ptask_get_idle();
-#endif
-
-    uint8_t mem_used_pct = 0;
-#if  USE_DYN_MEM != 0  && DM_CUSTOM == 0
-    dm_monitor(&mem_mon);
-    mem_used_pct = mem_mon.pct_used;
-#endif
-
-    /*Add the CPU and memory data*/
-    cpu_pct[LV_APP_SYSMON_PNUM - 1] = cpu_busy;
-    mem_pct[LV_APP_SYSMON_PNUM - 1] = mem_used_pct;
-
-    /*Refresh the shortcuts and windows*/
-    lv_app_sysmon_refr();
-
-#if USE_DYN_MEM != 0 && DM_CUSTOM == 0
-
-    /*Handle periodic defrag. if enabled*/
-#if LV_APP_SYSMON_DEFRAG_PERIOD != 0
-    static uint32_t last_defrag = 0;
-
-    if(systick_elaps(last_defrag) > LV_APP_SYSMON_DEFRAG_PERIOD) {
-        dm_defrag();
-        last_defrag = systick_get();
-    }
-#endif
-    /*Add notifications if something is critical*/
-    static bool mem_warn_report = false;
-    if(mem_mon.size_free < LV_APP_SYSMON_MEM_WARN && mem_warn_report == false) {
-        mem_warn_report = true;
-        lv_app_notice_add("Critically low memory");
-    }
-
-    if(mem_mon.size_free > LV_APP_SYSMON_MEM_WARN)  mem_warn_report = false;
-
-    static bool frag_warn_report = false;
-    if(mem_mon.pct_frag > LV_APP_SYSMON_FRAG_WARN) {
-        if(frag_warn_report == false) {
-            frag_warn_report = true;
-            lv_app_notice_add("Critical memory\nfragmentation");
-
-            dm_defrag(); /*Defrag. if the fragmentation is critical*/
-        }
-    }
-
-    if(mem_mon.pct_frag < LV_APP_SYSMON_FRAG_WARN)  frag_warn_report = false;
-#endif
-}
-
-/**
- * Refresh the shortcuts and windows.
- */
-static void lv_app_sysmon_refr(void)
-{
-
-    char buf_long[256];
-    char buf_short[128];
-    sprintf(buf_long, "%c%s CPU: %d %%%c\n\n",TXT_RECOLOR_CMD, CPU_LABEL_COLOR, cpu_pct[LV_APP_SYSMON_PNUM - 1], TXT_RECOLOR_CMD);
-    sprintf(buf_short, "CPU: %d %%\n", cpu_pct[LV_APP_SYSMON_PNUM - 1]);
-
-#if USE_DYN_MEM != 0  && DM_CUSTOM == 0
-    sprintf(buf_long, "%s%c%s MEMORY: %d %%%c\nTotal: %d bytes\nUsed: %d bytes\nFree: %d bytes\nFrag: %d %%",
-                  buf_long,
-                  TXT_RECOLOR_CMD,
-                  MEM_LABEL_COLOR,
-                  mem_pct[LV_APP_SYSMON_PNUM - 1],
-                  TXT_RECOLOR_CMD,
-                  (int)mem_mon.size_total,
-                  (int)mem_mon.size_total - mem_mon.size_free, mem_mon.size_free, mem_mon.pct_frag);
-
-    sprintf(buf_short, "%sMem: %d %%\nFrag: %d %%\n",
-                  buf_short, mem_pct[LV_APP_SYSMON_PNUM - 1], mem_mon.pct_frag);
-#else
-    sprintf(buf_long, "%s%c%s MEMORY: N/A%c", buf_long, TXT_RECOLOR_CMD, MEM_LABEL_COLOR, TXT_RECOLOR_CMD);
-    sprintf(buf_short, "%sMem: N/A\nFrag: N/A", buf_short);
-#endif
-    lv_app_inst_t * app;
-    app = lv_app_get_next(NULL, &my_app_dsc);
-    while(app != NULL) {
-        /*Refresh the windows*/
-        my_win_data_t * win_data = app->win_data;
-        if(win_data != NULL) {
-            lv_label_set_text(win_data->label, buf_long);
-
-            lv_chart_set_next(win_data->chart, win_data->mem_dl, mem_pct[LV_APP_SYSMON_PNUM - 1]);
-            lv_chart_set_next(win_data->chart, win_data->cpu_dl, cpu_pct[LV_APP_SYSMON_PNUM - 1]);
-
-        }
-        /*Refresh the shortcut*/
-        my_sc_data_t * sc_data = app->sc_data;
-        if(sc_data != NULL) {
-            lv_bar_set_value(sc_data->bar_cpu, cpu_pct[LV_APP_SYSMON_PNUM - 1]);
-            lv_bar_set_value(sc_data->bar_mem, mem_pct[LV_APP_SYSMON_PNUM - 1]);
-        }
-
-        lv_app_com_send(app, LV_APP_COM_TYPE_CHAR, buf_short, strlen(buf_short));
-
-        app = lv_app_get_next(app, &my_app_dsc);
-    }
-}
-#endif /*LV_APP_ENABLE != 0 && USE_LV_APP_SYSMON != 0*/

lv_appx/lv_app_terminal.c

@@ -1,495 +0,0 @@
-/**
- * @file lv_app_terminal.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include <lv_conf.h>
-#include <misc/gfx/area.h>
-#include <lvgl/lv_obj/lv_dispi.h>
-#include <lvgl/lv_obj/lv_obj.h>
-#include <lvgl/lv_objx/lv_btn.h>
-#include <lvgl/lv_objx/lv_cont.h>
-#include <lvgl/lv_objx/lv_ddlist.h>
-#include <lvgl/lv_objx/lv_label.h>
-#include <lvgl/lv_objx/lv_page.h>
-#include <lvgl/lv_objx/lv_ta.h>
-#include <misc/gfx/color.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-#include "lv_app_terminal.h"
-
-#if LV_APP_ENABLE != 0 && USE_LV_APP_TERMINAL != 0
-
-#include "lvgl/lv_app/lv_app_util/lv_app_kb.h"
-#include <stdio.h>
-
-/*********************
- *      DEFINES
- *********************/
-#define OBJ_PAD (LV_DPI / 12)
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-
-/*Application specific data for an instance of this application*/
-typedef struct
-{
-    char txt[LV_APP_TERMINAL_LENGTH + 1];
-    lv_app_com_type_t com_type;
-    lv_app_terminal_format_t format;
-    lv_app_inst_t * last_sender;
-}my_app_data_t;
-
-/*Application specific data a window of this application*/
-typedef struct
-{
-    lv_obj_t * label;
-    lv_obj_t * ta;
-    lv_obj_t * clear_btn;
-}my_win_data_t;
-
-/*Application specific data for a shortcut of this application*/
-typedef struct
-{
-    lv_obj_t * label;
-}my_sc_data_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void my_app_run(lv_app_inst_t * app, void * conf);
-static void my_app_close(lv_app_inst_t * app);
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec, lv_app_com_type_t type , const void * data, uint32_t size);
-static void my_sc_open(lv_app_inst_t * app, lv_obj_t * sc);
-static void my_sc_close(lv_app_inst_t * app);
-static void my_win_open(lv_app_inst_t * app, lv_obj_t * win);
-static void my_win_close(lv_app_inst_t * app);
-static void my_conf_open(lv_app_inst_t * app, lv_obj_t * conf_win);
-
-static void add_data(lv_app_inst_t * app, const void * data, uint16_t data_len);
-static lv_action_res_t win_ta_rel_action(lv_obj_t * ta, lv_dispi_t * dispi);
-static lv_action_res_t win_comtype_action(lv_obj_t * ddlist, lv_dispi_t * dispi);
-static lv_action_res_t win_format_action(lv_obj_t * ddlist, lv_dispi_t * dispi);
-static lv_action_res_t win_clear_rel_action(lv_obj_t * btn, lv_dispi_t * dispi);
-static void win_ta_kb_ok_action(lv_obj_t * ta);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_app_dsc_t my_app_dsc =
-{
-	.name = "Terminal",
-	.mode = LV_APP_MODE_NONE,
-	.app_run = my_app_run,
-	.app_close = my_app_close,
-	.com_rec = my_com_rec,
-	.win_open = my_win_open,
-	.win_close = my_win_close,
-	.sc_open = my_sc_open,
-	.sc_close = my_sc_close,
-    .conf_open = my_conf_open,
-	.app_data_size = sizeof(my_app_data_t),
-	.sc_data_size = sizeof(my_sc_data_t),
-	.win_data_size = sizeof(my_win_data_t),
-};
-
-static const char * com_type_list_txt[] = {"Character", "Integer", "Log", "None", ""};
-static lv_app_com_type_t com_type_list[] = {LV_APP_COM_TYPE_CHAR, LV_APP_COM_TYPE_INT, LV_APP_COM_TYPE_LOG, LV_APP_COM_TYPE_INV};
-static const char * txt_format_list_txt[] = {"ASCII", "Hexadecimal", ""};
-static lv_style_t style_sc_term;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the application
- * @return pointer to the application descriptor of this application
- */
-const lv_app_dsc_t * lv_app_terminal_init(void)
-{
-    lv_style_get(LV_STYLE_PLAIN, &style_sc_term);
-    style_sc_term.line_space = 0;
-    style_sc_term.letter_space = 0;
-    style_sc_term.txt_align = 0;
-    style_sc_term.ccolor = COLOR_WHITE;
-    style_sc_term.mcolor = COLOR_MAKE(0x20, 0x20, 0x20);
-    style_sc_term.gcolor = COLOR_MAKE(0x20, 0x20, 0x20);
-
-	return &my_app_dsc;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Run an application according to 'app_dsc'
- * @param app_dsc pointer to an application descriptor
- * @param conf pointer to a lv_app_example_conf_t structure with configuration data or NULL if unused
- * @return pointer to the opened application or NULL if any error occurred
- */
-static void my_app_run(lv_app_inst_t * app, void * conf)
-{
-    /*Initialize the application*/
-    my_app_data_t * app_data = app->app_data;
-
-    if(conf != NULL) {
-        app_data->com_type = ((lv_app_terminal_conf_t * ) conf)->com_type;
-        app_data->format = ((lv_app_terminal_conf_t * ) conf)->format;
-    } else {
-        app_data->com_type = LV_APP_COM_TYPE_CHAR;
-        app_data->format = LV_APP_TERMINAL_FORMAT_ASCII;
-    }
-
-    app_data->last_sender = NULL;
-
-    memset(app_data->txt, 0, sizeof(app_data->txt));
-}
-
-/**
- * Close a running application.
- * Close the Window and the Shortcut too if opened.
- * Free all the allocated memory by this application.
- * @param app pointer to an application
- */
-static void my_app_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_app_data'*/
-}
-
-/**
- * Read the data have been sent to this applicationstring
- * @param app_send pointer to an application which sent the message
- * @param app_rec pointer to an application which is receiving the message
- * @param type type of data from 'lv_app_com_type_t' enum
- * @param data pointer to the sent data
- * @param size length of 'data' in bytes
- */
-static void my_com_rec(lv_app_inst_t * app_send, lv_app_inst_t * app_rec,
-                       lv_app_com_type_t type , const void * data, uint32_t size)
-{
-    my_app_data_t * app_data = app_rec->app_data;
-
-    /*Add the received data if the type is matches*/
-	if(type == app_data->com_type) {
-
-        /*Insert the name of the sender application if it is not the last*/
-        if(app_data->last_sender != app_send) {
-            add_data(app_rec, "@", 1);
-            add_data(app_rec, app_send->name, strlen(app_send->name));
-            add_data(app_rec, "\n", 1);
-        }
-
-        if(app_data->format == LV_APP_TERMINAL_FORMAT_HEX) {
-            char hex_buf[8];
-            const char * data_buf = data;
-            uint32_t i;
-            for(i = 0; i < size; i++) {
-                sprintf(hex_buf, "%02x", data_buf[i]);
-                add_data(app_rec, hex_buf, 2);
-            }
-        } else {
-            add_data(app_rec, data, size);
-        }
-	}
-
-	app_data->last_sender = app_send;
-}
-
-/**
- * Open a shortcut for an application
- * @param app pointer to an application
- * @param sc pointer to an object where the application
- *           can create content of the shortcut
- */
-static void my_sc_open(lv_app_inst_t * app, lv_obj_t * sc)
-{
-    my_sc_data_t * sc_data = app->sc_data;
-    my_app_data_t * app_data = app->app_data;
-
-    /*Create a dark background*/
-    lv_obj_t * txt_bg = lv_obj_create(sc, NULL);
-    lv_obj_set_size(txt_bg, 7 * LV_APP_SC_WIDTH / 8 , app->sc->cords.y2 - app->sc_title->cords.y2 - 10 * LV_DOWNSCALE);
-    lv_obj_set_style(txt_bg, &style_sc_term);
-    lv_obj_align(txt_bg, app->sc_title, LV_ALIGN_OUT_BOTTOM_MID, 0, 3 * LV_DOWNSCALE);
-    lv_obj_set_click(txt_bg, false);
-
-    /*Add a text with the text of the terminal*/
-    sc_data->label = lv_label_create(txt_bg, NULL);
-    lv_label_set_long_mode(sc_data->label, LV_LABEL_LONG_BREAK);
-    lv_obj_set_width(sc_data->label, lv_obj_get_width(txt_bg) - LV_APP_SC_WIDTH / 8);
-    lv_label_set_text_static(sc_data->label, app_data->txt);
-    lv_obj_align(sc_data->label, txt_bg, LV_ALIGN_IN_BOTTOM_MID, 0, 0);
-}
-
-/**
- * Close the shortcut of an application
- * @param app pointer to an application
- */
-static void my_sc_close(lv_app_inst_t * app)
-{
-    /*No dynamically allocated data in 'my_sc_data'*/
-}
-
-/**
- * Open the application in a window
- * @param app pointer to an application
- * @param win pointer to a window object where
- *            the application can create content
- */
-static void my_win_open(lv_app_inst_t * app, lv_obj_t * win)
-{
-    my_win_data_t * win_data = app->win_data;
-    my_app_data_t * app_data = app->app_data;
-
-    /*Make the window content responsive*/
-    lv_cont_set_layout(lv_page_get_scrl(lv_win_get_page(win)), LV_CONT_LAYOUT_PRETTY);
-
-    /*Create a label for the text of the terminal*/
-    win_data->label = lv_label_create(win, NULL);
-    lv_label_set_long_mode(win_data->label, LV_LABEL_LONG_BREAK);
-    lv_obj_set_width(win_data->label, lv_win_get_width(win));
-    lv_label_set_text_static(win_data->label, app_data->txt); /*Use the app. data text directly*/
-
-    /*Create a text area. Text can be added to the terminal from here by app. keyboard.*/
-    win_data->ta = lv_ta_create(win, NULL);
-    lv_obj_set_size(win_data->ta, 3 * LV_HOR_RES / 5, LV_VER_RES / 4);
-    lv_obj_set_free_p(win_data->ta, app);
-    lv_page_set_rel_action(win_data->ta, win_ta_rel_action);
-    lv_page_glue_obj(win_data->ta, true);
-    lv_ta_set_text(win_data->ta, "");
-
-    /*Create a clear button*/
-    win_data->clear_btn = lv_btn_create(win, NULL);
-    lv_cont_set_fit(win_data->clear_btn, true, true);
-    lv_obj_set_free_p(win_data->clear_btn, app);
-    lv_page_glue_obj(win_data->ta, true);
-    lv_btn_set_rel_action(win_data->clear_btn, win_clear_rel_action);
-    lv_obj_t * btn_label = lv_label_create(win_data->clear_btn, NULL);
-    lv_label_set_text(btn_label, "Clear");
-
-    /*Align the window to see the text area on the bottom*/
-    lv_obj_t * page = lv_win_get_page(app->win);
-    lv_obj_align(lv_page_get_scrl(page), NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, - LV_VER_RES);
-}
-
-/**
- * Close the window of an application
- * @param app pointer to an application
- */
-static void my_win_close(lv_app_inst_t * app)
-{
-
-}
-
-/**
- * Create objects to configure the applications
- * @param app pointer to an application which settings should be created
- * @param conf_win pointer to a window where the objects can be created
- *                (the window has the proper layout)
- */
-static void my_conf_open(lv_app_inst_t * app, lv_obj_t * conf_win)
-{
-    my_app_data_t * app_data = app->app_data;
-
-    lv_obj_t * label;
-    label = lv_label_create(conf_win, NULL);
-    lv_label_set_text(label, "Communication type");
-
-    lv_obj_t * ddl;
-    ddl = lv_ddlist_create(conf_win, NULL);
-    lv_obj_set_free_p(ddl, app);
-    lv_ddlist_set_options(ddl, com_type_list_txt);
-    lv_ddlist_set_action(ddl, win_comtype_action);
-    lv_ddlist_set_selected(ddl, app_data->com_type);
-
-    label = lv_label_create(conf_win, label);
-    lv_label_set_text(label, "\nText format");  /*First '\n' keeps space from the list above*/
-    ddl = lv_ddlist_create(conf_win, ddl);
-    lv_ddlist_set_options(ddl, txt_format_list_txt);
-    lv_ddlist_set_selected(ddl, app_data->format);
-    lv_ddlist_set_action(ddl, win_format_action);
-}
-
-/*--------------------
- * OTHER FUNCTIONS
- ---------------------*/
-
-/**
- * Called when the Text area is released to open the app. keybard
- * @param ta pointer to the text area
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the text area is not deleted
- */
-static lv_action_res_t win_ta_rel_action(lv_obj_t * ta, lv_dispi_t * dispi)
-{
-    lv_app_kb_open(ta, LV_APP_KB_MODE_TXT | LV_APP_KB_MODE_WIN_RESIZE, NULL, win_ta_kb_ok_action);
-
-    return LV_ACTION_RES_OK;
-}
-
-/**
- * Called when an option is chosen in the communication type drop down list on the configuration window
- * @param ddl pointer to the drop down list
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the list is not deleted
- */
-static lv_action_res_t win_comtype_action(lv_obj_t * ddlist, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(ddlist);
-    my_app_data_t * app_data = app->app_data;
-
-    app_data->com_type = com_type_list[lv_ddlist_get_selected(ddlist)];
-
-    return LV_ACTION_RES_OK;
-}
-
-/**
- * Called when an option is chosen in the format drop down list on the configuration window
- * @param ddl pointer to the drop down list
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the list is not deleted
- */
-static lv_action_res_t win_format_action(lv_obj_t * ddlist, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(ddlist);
-    my_app_data_t * app_data = app->app_data;
-    uint16_t opt = lv_ddlist_get_selected(ddlist);
-    if(strcmp(txt_format_list_txt[opt], "Hexadecimal") == 0) {
-        app_data->format = LV_APP_TERMINAL_FORMAT_HEX;
-    } else if (strcmp(txt_format_list_txt[opt], "ASCII") == 0) {
-        app_data->format = LV_APP_TERMINAL_FORMAT_ASCII;
-    }
-
-    return LV_ACTION_RES_OK;
-}
-
-
-/**
- * Called when the Clear button is released to clear the text of the terminal
- * @param btn pointer to the clear button
- * @param dispi pointer to the caller display input
- * @return LV_ACTION_RES_OK because the button is not deleted
- */
-static lv_action_res_t win_clear_rel_action(lv_obj_t * btn, lv_dispi_t * dispi)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(btn);
-    my_app_data_t * app_data = app->app_data;
-    my_win_data_t * win_data = app->win_data;
-    my_sc_data_t * sc_data = app->sc_data;
-
-    app_data->txt[0] = '\0';
-
-    if(sc_data != NULL) {
-        lv_label_set_text_static(sc_data->label, app_data->txt);
-        lv_obj_align(sc_data->label, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
-    }
-
-    if(win_data != NULL) {
-        lv_label_set_text_static(win_data->label, app_data->txt);
-        lv_obj_t * page = lv_win_get_page(app->win);
-        lv_obj_align(lv_page_get_scrl(page), NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, - LV_VER_RES);
-    }
-
-    return LV_ACTION_RES_OK;
-}
-
-/**
- * Called when the 'Ok' button of the keyboard in the window
- * is pressed to write to the Terminal
- * @param ta pointer to the Text area in the window
- */
-static void win_ta_kb_ok_action(lv_obj_t * ta)
-{
-    lv_app_inst_t * app = lv_obj_get_free_p(ta);
-    my_app_data_t * app_data = app->app_data;
-    const char * ta_txt = lv_ta_get_txt(ta);
-    uint32_t ta_txt_len = strlen(ta_txt);
-    if(app_data->txt[0] != '\0') add_data(app, "\n", 1);
-    add_data(app, ">", 1);
-    add_data(app, ta_txt, ta_txt_len);
-
-    lv_app_com_send(app, app_data->com_type, ta_txt, ta_txt_len);
-
-    lv_ta_set_text(ta, "");
-}
-
-/**
- * Add data to the terminal
- * @param app pointer to a Terminal application
- * @param data pointer to the data
- * @param data_len length of 'data' in bytes
- */
-static void add_data(lv_app_inst_t * app, const void * data, uint16_t data_len)
-{
-    my_app_data_t * app_data = app->app_data;
-    uint16_t old_len = strlen(app_data->txt);
-    const char * txt = data;
-
-    /*IF the data is longer then the terminal ax size show the last part of data*/
-    if(data_len > LV_APP_TERMINAL_LENGTH) {
-        txt += (data_len - LV_APP_TERMINAL_LENGTH);
-        data_len = LV_APP_TERMINAL_LENGTH;
-        old_len = 0;
-    }
-    /*If the text become too long 'forget' the oldest lines*/
-    else if(old_len + data_len > LV_APP_TERMINAL_LENGTH) {
-        uint16_t new_start;
-        for(new_start = 0; new_start < old_len; new_start++) {
-            if(app_data->txt[new_start] == '\n') {
-                /*If there is enough space break*/
-                if(new_start >= data_len) {
-                    /*Ignore line breaks*/
-                    while(app_data->txt[new_start] == '\n' || app_data->txt[new_start] == '\r') new_start++;
-                    break;
-                }
-            }
-        }
-
-        /* If it wasn't able to make enough space on line breaks
-         * simply forget the oldest characters*/
-        if(new_start == old_len) {
-            new_start = old_len - (LV_APP_TERMINAL_LENGTH - data_len);
-        }
-        /*Move the remaining text to the beginning*/
-        uint16_t j;
-        for(j = new_start; j < old_len; j++) {
-            app_data->txt[j - new_start] = app_data->txt[j];
-        }
-        old_len = old_len - new_start;
-        app_data->txt[old_len] = '\0';
-
-    }
-
-    memcpy(&app_data->txt[old_len], txt, data_len);
-    app_data->txt[old_len + data_len] = '\0';
-
-    my_win_data_t * win_data = app->win_data;
-    my_sc_data_t * sc_data = app->sc_data;
-
-    if(win_data != NULL) {
-        lv_label_set_text_static(win_data->label, app_data->txt);
-        lv_obj_t * page = lv_win_get_page(app->win);
-        lv_obj_align(lv_page_get_scrl(page), NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, - LV_VER_RES);
-    }
-
-    /*Set the last line on the shortcut*/
-    if(sc_data != NULL) {
-        lv_label_set_text_static(sc_data->label, app_data->txt);
-        lv_obj_align(sc_data->label, NULL, LV_ALIGN_IN_BOTTOM_LEFT, 0, 0);
-    }
-}
-
-#endif /*LV_APP_ENABLE != 0 && USE_LV_APP_TERMINAL != 0*/

lv_appx/lv_app_terminal.h

@@ -1,46 +0,0 @@
-/**
- * @file lv_app_terminal.h
- *
- */
-
-#ifndef LV_APP_TERMINAL_H
-#define LV_APP_TERMINAL_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lvgl/lv_app/lv_app.h"
-
-#if LV_APP_ENABLE != 0 && USE_LV_APP_TERMINAL != 0
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-typedef enum
-{
-    LV_APP_TERMINAL_FORMAT_ASCII,
-    LV_APP_TERMINAL_FORMAT_HEX,
-}lv_app_terminal_format_t;
-
-typedef struct
-{
-    lv_app_terminal_format_t format;    /*Data display format*/
-    lv_app_com_type_t com_type;          /*The listened communication type (channel) */
-}lv_app_terminal_conf_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-const lv_app_dsc_t * lv_app_terminal_init(void);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*LV_APP_ENABLE != 0 && USE_LV_APP_TERMINAL != 0*/
-
-#endif /* LV_APP_TERMINAL_H */

lv_conf_templ.h

@@ -1,250 +0,0 @@
-/**
- * @file lv_conf.h
- * 
- */
-
-#if 0 /*Remove this to enable the content (Delete the last #endif too!)*/
-
-#ifndef LV_CONF_H
-#define LV_CONF_H
-
-/*===================
-   Graphical settings
- *=====================*/
-
-/* Horizontal and vertical resolution of the library.
- * Screen resolution multiplied by LV_DOWN_SCALE*/
-#define LV_HOR_RES          (320 * LV_DOWNSCALE)
-#define LV_VER_RES          (240 * LV_DOWNSCALE)
-#define LV_DPI              (80 * LV_DOWNSCALE)
-
-/* Buffered rendering: >= LV_DOWNSCALE * LV_HOR_RES or 0 to disable buffering*/
-#define LV_VDB_SIZE        (LV_HOR_RES * 30)
-
-/* Enable antialaiassing
- * If enabled everything will half-sized
- * Use LV_DOWNSCALE to compensate
- * the down scaling effect of antialiassing*/
-#define LV_ANTIALIAS        1
-
-/*Set the downscaling value*/
-#define LV_DOWNSCALE        (1 << LV_ANTIALIAS)
-
-#define LV_REFR_PERIOD      40    /*Screen refresh period in milliseconds*/
-#define LV_INV_FIFO_SIZE    32    /*The average number of objects on a screen */
-
-/*=================
-   Misc. setting
- *=================*/
-/*Display Input settings*/
-#define LV_DISPI_READ_PERIOD      50                    /*Input device read period milliseconds*/
-#define LV_DISPI_TP_MARKER        0                     /*Mark the pressed points (Value means marker point size)*/
-#define LV_DISPI_DRAG_LIMIT       (10 * LV_DOWNSCALE)   /*Drag threshold in pixels */
-#define LV_DISPI_DRAG_THROW       20                    /*Drag throw slow-down in [%]. Greater value means faster slow-down */
-#define LV_DISPI_LONG_PRESS_TIME        400             /*Long press time in milliseconds*/
-#define LV_DISPI_LONG_PRESS_REP_TIME    100             /*Repeated trigger period in long press [ms] */
-
-/*lv_obj (base object) settings*/
-#define LV_OBJ_FREE_NUM          1           /*Enable the free number attribute*/
-#define LV_OBJ_FREE_P            1           /*Enable the free pointer attribute*/
-
-/*Others*/
-#define LV_COLOR_TRANSP     COLOR_LIME
-
-/*==================
- *  LV OBJ X USAGE 
- * ================*/
-
-/*****************
- * Simple object
- *****************/
-
-/*Label (dependencies: -*/
-#define USE_LV_LABEL    1
-#if USE_LV_LABEL != 0
-#define LV_LABEL_SCROLL_SPEED       (25 * LV_DOWNSCALE) /*Hor, or ver. scroll speed (px/sec) in 'LV_LABEL_LONG_SCROLL' mode*/
-#define LV_LABEL_SCROLL_SPEED_VER   (10 * LV_DOWNSCALE) /*Ver. scroll speed if hor. scroll is applied too*/
-#define LV_LABEL_SCROLL_PLAYBACK_PAUSE  500 /*Wait before the scroll turns back in ms*/
-#define LV_LABEL_SCROLL_REPEAT_PAUSE    500 /*Wait before the scroll begins again in ms*/
-#endif
-
-/*Image (dependencies: lv_label (if symbols are enabled) from misc: FSINT, UFS)*/
-#define USE_LV_IMG      1
-#if USE_LV_IMG != 0
-//#define LV_IMG_DEF_WALLPAPER    img_square_x1  /*Comment this line to NOT use wallpaper*/
-/* 1: enables to interpret the file names as symbol name
- * from symbol_def.h if they begin with a lower case letter.
- * (driver letters are always upper case)*/
-#define LV_IMG_ENABLE_SYMBOLS   1
-#if LV_IMG_ENABLE_SYMBOLS != 0
-#define LV_IMG_DEF_SYMBOL_FONT       FONT_SYMBOL_30
-#endif /*LV_IMG_ENABLE_SYMBOLS*/
-#endif /*USE_LV_IMG*/
-
-/*Line (dependencies: -*/
-#define USE_LV_LINE     1
-
-/*******************
- * Container object
- *******************/
-
-/*Container (dependencies: -*/
-#define USE_LV_CONT     1
-
-/*Page (dependencies: lv_cont)*/
-#define USE_LV_PAGE     1
-
-/*Window (dependencies: lv_cont, lv_btn, lv_label, lv_img, lv_page)*/
-#define USE_LV_WIN      1
-
-/*************************
- * Data visualizer object
- *************************/
-
-/*Bar (dependencies: -)*/
-#define USE_LV_BAR       1
-
-/*Line meter (dependencies: bar; misc: trigo)*/
-#define USE_LV_LMETER   1
-
-/*Gauge (dependencies:bar, lmeter; misc: trigo)*/
-#define USE_LV_GAUGE    1
-
-/*Chart (dependencies: -)*/
-#define USE_LV_CHART    1
-
-/*LED (dependencies: -)*/
-#define USE_LV_LED      1
-
-/*Message box (dependencies: lv_rect, lv_btn, lv_label)*/
-#define USE_LV_MBOX     1
-
-/*Text area (dependencies: lv_label, lv_page)*/
-#define USE_LV_TA       1
-#if USE_LV_TA != 0
-#define LV_TA_MAX_LENGTH    256
-#define LV_TA_CUR_BLINK_TIME 400    /*ms*/
-#endif
-
-/*************************
- * User input object
- *************************/
-
-/*Button (dependencies: lv_cont*/
-#define USE_LV_BTN      1
-
-/*Button matrix (dependencies: -)*/
-#define USE_LV_BTNM     1
-
-/*Check box (dependencies: lv_btn, lv_label)*/
-#define USE_LV_CB       1
-
-/*List (dependencies: lv_page, lv_btn, lv_label, lv_img)*/
-#define USE_LV_LIST     1
-
-/*Drop down list (dependencies: lv_page, lv_label)*/
-#define USE_LV_DDLIST    1
-
-/*Slider (dependencies: lv_bar)*/
-#define USE_LV_SLIDER    1
-
-
-/*==================
- *  LV APP SETTINGS
- * =================*/
-
-/*Enable the application system*/
-#define LV_APP_ENABLE       0
-#if LV_APP_ENABLE != 0
-
-/****************************
- * Basic application settings
- *****************************/
-#define LV_APP_DESKTOP      1                   /*Create a desktop-like environment*/
-
-#define LV_APP_SC_WIDTH     (LV_HOR_RES / 4)    /*Shortcut width*/
-#define LV_APP_SC_HEIGHT    (LV_VER_RES / 3)    /*Shortcut height*/
-#define LV_APP_FONT_SMALL   FONT_DEJAVU_20      /*A small font*/
-#define LV_APP_FONT_MEDIUM  FONT_DEFAULT        /*A medium font*/
-#define LV_APP_FONT_LARGE   FONT_DEJAVU_40      /*A large font*/
-
-/***********************
- * Animation settings
- ***********************/
-#define LV_APP_ANIM_WIN      200      /*Animation time of windows [ms] (0: turn off animations)*/
-#define LV_APP_ANIM_DESKTOP  200      /*Animation time the desktop [ms] (0: turn off animations)*/
-
-/************************
- * App. utility settings
- ************************/
-
-/*Notice*/
-#define USE_LV_APP_NOTICE           1
-#if USE_LV_APP_NOTICE != 0
-#define LV_APP_NOTICE_SHOW_TIME         4000    /*Notices will be shown for this time [ms]*/
-#define LV_APP_NOTICE_CLOSE_ANIM_TIME   300     /*Notice close animation time. [ms] 0: no animation */
-#define LV_APP_NOTICE_MAX_NUM   6               /*Max. number of notices*/
-#define LV_APP_NOTICE_MAX_LEN   256             /*Max. number of characters on a notice*/
-#endif
-
-/*File selector*/
-#define USE_LV_APP_FSEL         1
-#if USE_LV_APP_FSEL != 0
-#define LV_APP_FSEL_PAGE_SIZE     8         /*Max. number of files/folder on a page*/
-#define LV_APP_FSEL_FN_MAX_LEN    32        /*Max file name length*/
-#define LV_APP_FSEL_PATH_MAX_LEN  256       /*Max path length*/
-#endif
-
-/*Keyboard*/
-#define USE_LV_APP_KB           1
-#if USE_LV_APP_KB != 0
-/*No settings*/
-#endif
-
-/*==================
- *  LV APP X USAGE 
- * ================*/
-
-/*Example application*/
-#define USE_LV_APP_EXAMPLE  1
-
-/*Phantom application*/
-#define USE_LV_APP_PHANTOM  1
-#if USE_LV_APP_PHANTOM != 0
-/*No settings*/
-#endif
-
-/*System monitor*/
-#define USE_LV_APP_SYSMON   1
-#if USE_LV_APP_SYSMON != 0
-#define LV_APP_SYSMON_REFR_TIME     500         /*Mem. and CPU usage read period [ms]*/
-#define LV_APP_SYSMON_PNUM          64          /*Number of point on the window's chart*/
-#define LV_APP_SYSMON_MEM_WARN      (2 * 1024)  /*Make a notice less then this remaining memory [bytes]*/
-#define LV_APP_SYSMON_FRAG_WARN     (70)        /*Make a notice above this fragmentation level [%]*/
-#define LV_APP_SYSMON_DEFRAG_PERIOD (5000)      /*Auto-defrag period [ms]*/
-#endif /*USE_LV_APP_SYSMON != 0*/
-
-/*Terminal*/
-#define USE_LV_APP_TERMINAL 1
-#if USE_LV_APP_TERMINAL != 0
-#define LV_APP_TERMINAL_LENGTH      512     /*Memory of the terminal [character number]*/
-#endif /*USE_LV_APP_TERMINAL != 0*/
-
-/*Files*/
-#define USE_LV_APP_FILES    1
-#if USE_LV_APP_FILES != 0
-#define LV_APP_FILES_PAGE_SIZE      8       /*Max. number of files/folder on a page*/
-#define LV_APP_FILES_FN_MAX_LEN     32      /*Max file name length*/
-#define LV_APP_FILES_PATH_MAX_LEN   256     /*Max path length*/
-#define LV_APP_FILES_CHUNK_DEF_SIZE 256     /*Chunk size when sending a file*/
-#define LV_APP_FILES_CHUNK_DEF_TIME 100     /*Delay between sent chunks*/
-#define LV_APP_FILES_CHUNK_MAX_SIZE 1024    /*Max chunk size when the user sets it*/
-#endif /*USE_LV_APP_FILES != 0*/
-
-#endif /*LV_APP_ENABLE != 0*/
-
-#endif /*LV_CONF_H*/
-
-
-#endif /*Remove this to enable the content*/
-

lv_conf_template.h

@@ -0,0 +1,762 @@
+/**
+ * @file lv_conf.h
+ * Configuration file for v7.10.1
+ */
+
+/*
+ * COPY THIS FILE AS `lv_conf.h` NEXT TO the `lvgl` FOLDER
+ */
+
+#if 0 /*Set it to "1" to enable content*/
+
+#ifndef LV_CONF_H
+#define LV_CONF_H
+/* clang-format off */
+
+#include <stdint.h>
+
+/*====================
+   Graphical settings
+ *====================*/
+
+/* Maximal horizontal and vertical resolution to support by the library.*/
+#define LV_HOR_RES_MAX          (480)
+#define LV_VER_RES_MAX          (320)
+
+/* Color depth:
+ * - 1:  1 byte per pixel
+ * - 8:  RGB332
+ * - 16: RGB565
+ * - 32: ARGB8888
+ */
+#define LV_COLOR_DEPTH     16
+
+/* Swap the 2 bytes of RGB565 color.
+ * Useful if the display has a 8 bit interface (e.g. SPI)*/
+#define LV_COLOR_16_SWAP   0
+
+/* 1: Enable screen transparency.
+ * Useful for OSD or other overlapping GUIs.
+ * Requires `LV_COLOR_DEPTH = 32` colors and the screen's style should be modified: `style.body.opa = ...`*/
+#define LV_COLOR_SCREEN_TRANSP    0
+
+/*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 anti-aliasing (lines, and radiuses will be smoothed) */
+#define LV_ANTIALIAS        1
+
+/* Default display refresh period.
+ * Can be changed in the display driver (`lv_disp_drv_t`).*/
+#define LV_DISP_DEF_REFR_PERIOD      30      /*[ms]*/
+
+/* 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              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;
+
+/*=========================
+   Memory manager settings
+ *=========================*/
+
+/* LittelvGL's internal memory manager's settings.
+ * The graphical objects and other related data are stored here. */
+
+/* 1: use custom malloc/free, 0: use the built-in `lv_mem_alloc` and `lv_mem_free` */
+#define LV_MEM_CUSTOM      0
+#if LV_MEM_CUSTOM == 0
+/* Size of the memory used by `lv_mem_alloc` in bytes (>= 2kB)*/
+#  define LV_MEM_SIZE    (32U * 1024U)
+
+/* Compiler prefix for a big array declaration */
+#  define LV_MEM_ATTR
+
+/* Set an address for the memory pool instead of allocating it as an array.
+ * Can be in external SRAM too. */
+#  define LV_MEM_ADR          0
+
+/* Automatically defrag. on free. Defrag. means joining the adjacent free cells. */
+#  define LV_MEM_AUTO_DEFRAG  1
+#else       /*LV_MEM_CUSTOM*/
+#  define LV_MEM_CUSTOM_INCLUDE <stdlib.h>   /*Header for the dynamic memory function*/
+#  define LV_MEM_CUSTOM_ALLOC   malloc       /*Wrapper to malloc*/
+#  define LV_MEM_CUSTOM_FREE    free         /*Wrapper to free*/
+#endif     /*LV_MEM_CUSTOM*/
+
+/* Use the standard memcpy and memset instead of LVGL's own functions.
+ * The standard functions might or might not be faster depending on their implementation. */
+#define LV_MEMCPY_MEMSET_STD    0
+
+/* Garbage Collector settings
+ * Used if lvgl is binded to higher level language and the memory is managed by that language */
+#define LV_ENABLE_GC 0
+#if LV_ENABLE_GC != 0
+#  define LV_GC_INCLUDE "gc.h"                           /*Include Garbage Collector related things*/
+#  define LV_MEM_CUSTOM_REALLOC   your_realloc           /*Wrapper to realloc*/
+#  define LV_MEM_CUSTOM_GET_SIZE  your_mem_get_size      /*Wrapper to lv_mem_get_size*/
+#endif /* LV_ENABLE_GC */
+
+/*=======================
+   Input device settings
+ *=======================*/
+
+/* Input device default settings.
+ * Can be changed in the Input device driver (`lv_indev_drv_t`)*/
+
+/* Input device read period in milliseconds */
+#define LV_INDEV_DEF_READ_PERIOD          30
+
+/* Drag threshold in pixels */
+#define LV_INDEV_DEF_DRAG_LIMIT           10
+
+/* Drag throw slow-down in [%]. Greater value -> faster slow-down */
+#define LV_INDEV_DEF_DRAG_THROW           10
+
+/* Long press time in milliseconds.
+ * Time to send `LV_EVENT_LONG_PRESSED`) */
+#define LV_INDEV_DEF_LONG_PRESS_TIME      400
+
+/* Repeated trigger period in long press [ms]
+ * 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
+ *==================*/
+
+/*1: Enable the Animations */
+#define LV_USE_ANIMATION        1
+#if LV_USE_ANIMATION
+
+/*Declare the type of the user data of animations (can be e.g. `void *`, `int`, `struct`)*/
+typedef void * lv_anim_user_data_t;
+
+#endif
+
+/* 1: Enable shadow drawing on rectangles*/
+#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: enable outline drawing on rectangles*/
+#define LV_USE_OUTLINE  1
+
+/*1: enable pattern drawing on rectangles*/
+#define LV_USE_PATTERN  1
+
+/*1: enable value string drawing on rectangles*/
+#define LV_USE_VALUE_STR    1
+
+/* 1: Use other blend modes than normal (`LV_BLEND_MODE_...`)*/
+#define LV_USE_BLEND_MODES      1
+
+/* 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
+#if LV_USE_GROUP
+typedef void * lv_group_user_data_t;
+#endif  /*LV_USE_GROUP*/
+
+/* 1: Enable GPU interface*/
+#define LV_USE_GPU              1   /*Only enables `gpu_fill_cb` and `gpu_blend_cb` in the disp. drv- */
+#define LV_USE_GPU_STM32_DMA2D  0
+/*If enabling LV_USE_GPU_STM32_DMA2D, LV_GPU_DMA2D_CMSIS_INCLUDE must be defined to include path of CMSIS header of target processor
+e.g. "stm32f769xx.h" or "stm32f429xx.h" */
+#define LV_GPU_DMA2D_CMSIS_INCLUDE
+
+/*1: Use PXP for CPU off-load on NXP RTxxx platforms */
+#define LV_USE_GPU_NXP_PXP      0
+
+/*1: Add default bare metal and FreeRTOS interrupt handling routines for PXP (lv_gpu_nxp_pxp_osa.c)
+ *   and call lv_gpu_nxp_pxp_init() automatically during lv_init(). Note that symbol FSL_RTOS_FREE_RTOS
+ *   has to be defined in order to use FreeRTOS OSA, otherwise bare-metal implementation is selected.
+ *0: lv_gpu_nxp_pxp_init() has to be called manually before lv_init()
+ * */
+#define LV_USE_GPU_NXP_PXP_AUTO_INIT 0
+
+/*1: Use VG-Lite for CPU offload on NXP RTxxx platforms */
+#define LV_USE_GPU_NXP_VG_LITE   0
+
+/* 1: Enable file system (might be required for images */
+#define LV_USE_FILESYSTEM       1
+#if LV_USE_FILESYSTEM
+/*Declare the type of the user data of file system drivers (can be e.g. `void *`, `int`, `struct`)*/
+typedef void * lv_fs_drv_user_data_t;
+#endif
+
+/*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
+#define LV_USE_API_EXTENSION_V7  1
+
+/*========================
+ * Image decoder and cache
+ *========================*/
+
+/* 1: Enable indexed (palette) images */
+#define LV_IMG_CF_INDEXED       1
+
+/* 1: Enable alpha indexed images */
+#define LV_IMG_CF_ALPHA         1
+
+/* Default image cache size. Image caching keeps the images opened.
+ * If only the built-in image formats are used there is no real advantage of caching.
+ * (I.e. no new image decoder is added)
+ * With complex image decoders (e.g. PNG or JPG) caching can save the continuous open/decode of images.
+ * However the opened images might consume additional RAM.
+ * Set it to 0 to disable caching */
+#define LV_IMG_CACHE_DEF_SIZE       1
+
+/*Declare the type of the user data of image decoder (can be e.g. `void *`, `int`, `struct`)*/
+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
+
+/* Required alignment size for buffers */
+#define LV_ATTRIBUTE_MEM_ALIGN_SIZE
+
+/* With size optimization (-Os) the compiler might not align data to
+ * 4 or 8 byte boundary. Some HW may need even 32 or 64 bytes.
+ * This alignment will be explicitly applied where needed.
+ * LV_ATTRIBUTE_MEM_ALIGN_SIZE should be used to specify required align size.
+ * E.g. __attribute__((aligned(LV_ATTRIBUTE_MEM_ALIGN_SIZE))) */
+#define LV_ATTRIBUTE_MEM_ALIGN
+
+/* Attribute to mark large constant arrays for example
+ * 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
+ *
+ * The default value just prevents a GCC warning.
+ */
+#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
+ *==================*/
+
+/* 1: use a custom tick source.
+ * 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  "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*/
+typedef void * lv_indev_drv_user_data_t;            /*Type of user data in the input device driver*/
+
+/*================
+ * Log settings
+ *===============*/
+
+/*1: Enable the log module*/
+#define LV_USE_LOG      0
+#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
+
+/* 1: Print the log with 'printf';
+ * 0: user need to register a callback with `lv_log_register_print_cb`*/
+#  define LV_LOG_PRINTF   0
+#endif  /*LV_USE_LOG*/
+
+/*=================
+ * Debug settings
+ *================*/
+
+/* If Debug is enabled LittelvGL validates the parameters of the functions.
+ * If an invalid parameter is found an error log message is printed and
+ * the MCU halts at the error. (`LV_USE_LOG` should be enabled)
+ * If you are debugging the MCU you can pause
+ * the debugger to see exactly where the issue is.
+ *
+ * The behavior of asserts can be overwritten by redefining them here.
+ * E.g. #define LV_ASSERT_MEM(p)  <my_assert_code>
+ */
+#define LV_USE_DEBUG        1
+#if LV_USE_DEBUG
+
+/*Check if the parameter is NULL. (Quite fast) */
+#define LV_USE_ASSERT_NULL      1
+
+/*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) */
+#define LV_USE_ASSERT_STR       0
+
+/* Check NULL, the object's type and existence (e.g. not deleted). (Quite slow)
+ * If disabled `LV_USE_ASSERT_NULL` will be performed instead (if it's enabled) */
+#define LV_USE_ASSERT_OBJ       0
+
+/*Check if the styles are properly initialized. (Fast)*/
+#define LV_USE_ASSERT_STYLE     0
+
+#endif /*LV_USE_DEBUG*/
+
+/*==================
+ *    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.lvgl.io/v7/en/html/overview/font.html
+ * To create a new font go to: https://lvgl.com/ttf-font-to-c-array
+ */
+
+/* Montserrat fonts with bpp = 4
+ * https://fonts.google.com/specimen/Montserrat  */
+#define LV_FONT_MONTSERRAT_8     0
+#define LV_FONT_MONTSERRAT_10    0
+#define LV_FONT_MONTSERRAT_12    0
+#define LV_FONT_MONTSERRAT_14    1
+#define LV_FONT_MONTSERRAT_16    0
+#define LV_FONT_MONTSERRAT_18    0
+#define LV_FONT_MONTSERRAT_20    0
+#define LV_FONT_MONTSERRAT_22    0
+#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_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/ */
+#define LV_FONT_UNSCII_8     0
+#define LV_FONT_UNSCII_16     0
+
+/* Optionally declare your custom fonts here.
+ * You can use these fonts as default font too
+ * and they will be available globally. E.g.
+ * #define LV_FONT_CUSTOM_DECLARE LV_FONT_DECLARE(my_font_1) \
+ *                                LV_FONT_DECLARE(my_font_2)
+ */
+#define LV_FONT_CUSTOM_DECLARE
+
+/* 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.*/
+#define LV_FONT_FMT_TXT_LARGE   0
+
+/* Enables/disables support for compressed fonts. If it's disabled, compressed
+ * glyphs cannot be processed by the library and won't be rendered.
+ */
+#define LV_USE_FONT_COMPRESSED 1
+
+/* Enable subpixel rendering */
+#define LV_USE_FONT_SUBPX 1
+#if LV_USE_FONT_SUBPX
+/* Set the pixel order of the display.
+ * Important only if "subpx fonts" are used.
+ * With "normal" font it doesn't matter.
+ */
+#define LV_FONT_SUBPX_BGR    0
+#endif
+
+/*Declare the type of the user data of fonts (can be e.g. `void *`, `int`, `struct`)*/
+typedef void * lv_font_user_data_t;
+
+/*================
+ *  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
+ * LV_THEME_MATERIAL_FLAG_NO_TRANSITION: disable transitions (state change animations)
+ * LV_THEME_MATERIAL_FLAG_NO_FOCUS: disable indication of focused state)
+ * */
+#define LV_USE_THEME_MATERIAL    1
+
+/* Mono-color theme for monochrome displays.
+ * 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_14
+#define LV_THEME_DEFAULT_FONT_NORMAL        &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_SUBTITLE      &lv_font_montserrat_14
+#define LV_THEME_DEFAULT_FONT_TITLE         &lv_font_montserrat_14
+
+/*=================
+ *  Text settings
+ *=================*/
+
+/* Select a character encoding for strings.
+ * Your IDE or editor should have the same character encoding
+ * - LV_TXT_ENC_UTF8
+ * - LV_TXT_ENC_ASCII
+ * */
+#define LV_TXT_ENC LV_TXT_ENC_UTF8
+
+ /*Can break (wrap) texts on these chars*/
+#define LV_TXT_BREAK_CHARS                  " ,.;:-_"
+
+/* If a word is at least this long, will break wherever "prettiest"
+ * To disable, set to a value <= 0 */
+#define LV_TXT_LINE_BREAK_LONG_LEN          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. */
+#define LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN  3
+
+/* Minimum number of characters in a long word to put on a line after a break.
+ * Depends on LV_TXT_LINE_BREAK_LONG_LEN. */
+#define LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN 3
+
+/* The control character to use for signalling text recoloring. */
+#define LV_TXT_COLOR_CMD "#"
+
+/* Support bidirectional texts.
+ * Allows mixing Left-to-Right and Right-to-Left texts.
+ * The direction will be processed according to the Unicode Bidirectional Algorithm:
+ * https://www.w3.org/International/articles/inline-bidi-markup/uba-basics*/
+#define LV_USE_BIDI     0
+#if LV_USE_BIDI
+/* Set the default direction. Supported values:
+ * `LV_BIDI_DIR_LTR` Left-to-Right
+ * `LV_BIDI_DIR_RTL` Right-to-Left
+ * `LV_BIDI_DIR_AUTO` detect texts base direction */
+#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_realign()` based on `lv_obj_align()` parameters*/
+#define LV_USE_OBJ_REALIGN          1
+
+/* Enable to make the object clickable on a larger area.
+ * LV_EXT_CLICK_AREA_OFF or 0: Disable this feature
+ * 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_TINY
+
+/*==================
+ *  LV OBJ X USAGE
+ *================*/
+/*
+ * Documentation of the object types: https://docs.lvgl.com/#Object-types
+ */
+
+/*Arc (dependencies: -)*/
+#define LV_USE_ARC      1
+
+/*Bar (dependencies: -)*/
+#define LV_USE_BAR      1
+
+/*Button (dependencies: lv_cont*/
+#define LV_USE_BTN      1
+
+/*Button matrix (dependencies: -)*/
+#define LV_USE_BTNMATRIX     1
+
+/*Calendar (dependencies: -)*/
+#define LV_USE_CALENDAR 1
+#if LV_USE_CALENDAR
+#  define LV_CALENDAR_WEEK_STARTS_MONDAY    0
+#endif
+
+/*Canvas (dependencies: lv_img)*/
+#define LV_USE_CANVAS   1
+
+/*Check box (dependencies: lv_btn, lv_label)*/
+#define LV_USE_CHECKBOX       1
+
+/*Chart (dependencies: -)*/
+#define LV_USE_CHART    1
+#if LV_USE_CHART
+#  define LV_CHART_AXIS_TICK_LABEL_MAX_LEN    256
+#endif
+
+/*Container (dependencies: -*/
+#define LV_USE_CONT     1
+
+/*Color picker (dependencies: -*/
+#define LV_USE_CPICKER   1
+
+/*Drop down list (dependencies: lv_page, lv_label, lv_symbol_def.h)*/
+#define LV_USE_DROPDOWN    1
+#if LV_USE_DROPDOWN != 0
+/*Open and close default animation time [ms] (0: no animation)*/
+#  define LV_DROPDOWN_DEF_ANIM_TIME     200
+#endif
+
+/*Gauge (dependencies:lv_bar, lv_linemeter)*/
+#define LV_USE_GAUGE    1
+
+/*Image (dependencies: lv_label*/
+#define LV_USE_IMG      1
+
+/*Image Button (dependencies: lv_btn*/
+#define LV_USE_IMGBTN   1
+#if LV_USE_IMGBTN
+/*1: The imgbtn requires left, mid and right parts and the width can be set freely*/
+#  define LV_IMGBTN_TILED 0
+#endif
+
+/*Keyboard (dependencies: lv_btnm)*/
+#define LV_USE_KEYBOARD       1
+
+/*Label (dependencies: -*/
+#define LV_USE_LABEL    1
+#if LV_USE_LABEL != 0
+/*Hor, or ver. scroll speed [px/sec] in 'LV_LABEL_LONG_ROLL/ROLL_CIRC' mode*/
+#  define LV_LABEL_DEF_SCROLL_SPEED       25
+
+/* Waiting period at beginning/end of animation cycle */
+#  define LV_LABEL_WAIT_CHAR_COUNT        3
+
+/*Enable selecting text of the label */
+#  define LV_LABEL_TEXT_SEL               0
+
+/*Store extra some info in labels (12 bytes) to speed up drawing of very long texts*/
+#  define LV_LABEL_LONG_TXT_HINT          0
+#endif
+
+/*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
+
+/*List (dependencies: lv_page, lv_btn, lv_label, (lv_img optionally for icons ))*/
+#define LV_USE_LIST     1
+#if LV_USE_LIST != 0
+/*Default animation time of focusing to a list element [ms] (0: no animation)  */
+#  define LV_LIST_DEF_ANIM_TIME  100
+#endif
+
+/*Line meter (dependencies: *;)*/
+#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    1
+#endif
+
+/*Mask (dependencies: -)*/
+#define LV_USE_OBJMASK  1
+
+/*Message box (dependencies: lv_rect, lv_btnm, lv_label)*/
+#define LV_USE_MSGBOX     1
+
+/*Page (dependencies: lv_cont)*/
+#define LV_USE_PAGE     1
+#if LV_USE_PAGE != 0
+/*Focus default animation time [ms] (0: no animation)*/
+#  define LV_PAGE_DEF_ANIM_TIME     400
+#endif
+
+/*Preload (dependencies: lv_arc, lv_anim)*/
+#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)*/
+#define LV_USE_ROLLER    1
+#if LV_USE_ROLLER != 0
+/*Focus animation time [ms] (0: no animation)*/
+#  define LV_ROLLER_DEF_ANIM_TIME     200
+
+/*Number of extra "pages" when the roller is infinite*/
+#  define LV_ROLLER_INF_PAGES         7
+#endif
+
+/*Slider (dependencies: lv_bar)*/
+#define LV_USE_SLIDER    1
+
+/*Spinbox (dependencies: lv_ta)*/
+#define LV_USE_SPINBOX       1
+
+/*Switch (dependencies: lv_slider)*/
+#define LV_USE_SWITCH       1
+
+/*Text area (dependencies: lv_label, lv_page)*/
+#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)*/
+#define LV_USE_TABLE    1
+#if LV_USE_TABLE
+#  define LV_TABLE_COL_MAX    12
+#  define LV_TABLE_CELL_STYLE_CNT 4
+#endif
+
+/*Tab (dependencies: lv_page, lv_btnm)*/
+#define LV_USE_TABVIEW      1
+#  if LV_USE_TABVIEW != 0
+/*Time of slide animation [ms] (0: no animation)*/
+#  define LV_TABVIEW_DEF_ANIM_TIME    300
+#endif
+
+/*Tileview (dependencies: lv_page) */
+#define LV_USE_TILEVIEW     1
+#if LV_USE_TILEVIEW
+/*Time of slide animation [ms] (0: no animation)*/
+#  define LV_TILEVIEW_DEF_ANIM_TIME   300
+#endif
+
+/*Window (dependencies: lv_cont, lv_btn, lv_label, lv_img, lv_page)*/
+#define LV_USE_WIN      1
+
+/*==================
+ * Non-user section
+ *==================*/
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)    /* Disable warnings for Visual Studio*/
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+
+/*--END OF LV_CONF_H--*/
+
+#endif /*LV_CONF_H*/
+
+#endif /*End of "Content enable"*/

lv_draw/lv_draw.h

@@ -1,83 +0,0 @@
-/**
- * @file lv_draw.h
- * 
- */
-
-#ifndef LV_DRAW_H
-#define LV_DRAW_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "misc_conf.h"
-#include "misc/gfx/text.h"
-#include "../lv_obj/lv_style.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/ 
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Draw a rectangle
- * @param cords_p the coordinates of the rectangle
- * @param mask_p the rectangle will be drawn only in this mask
- * @param style_p pointer to a style
- */
-void lv_draw_rect(const area_t * cords_p, const area_t * mask_p, const lv_style_t * style_p);
-
-
-/*Experimental use for 3D modeling*/
-#define USE_LV_TRIANGLE 0
-#if USE_LV_TRIANGLE != 0
-/**
- *
- * @param points pointer to an array with 3 points
- * @param mask_p the triangle will be drawn only in this mask
- * @param color color of the triangle
- */
-void lv_draw_triangle(const point_t * points, const area_t * mask_p, color_t color);
-#endif
-
-/**
- * Write a text
- * @param cords_p coordinates of the label
- * @param mask_p the label will be drawn only in this area
- * @param style_p pointer to a style
- * @param txt 0 terminated text to write
- * @param flags settings for the text from 'txt_flag_t' enum
- */
-void lv_draw_label(const area_t * cords_p,const area_t * mask_p, const lv_style_t * style_p,
-                    const char * txt, txt_flag_t flag);
-
-/**
- * Draw an image
- * @param cords_p the coordinates of the image
- * @param mask_p the image will be drawn only in this area
- * @param map_p pointer to a color_t array which contains the pixels of the image
- */
-void lv_draw_img(const area_t * cords_p, const area_t * mask_p,
-                 const lv_style_t * style_p, const char * fn);
-
-/**
- * Draw a line
- * @param p1 first point of the line
- * @param p2 second point of the line
- * @param mask_pthe line will be drawn only on this area
- * @param style_p pointer to a style
- */
-void lv_draw_line(const point_t * p1, const point_t * p2, const area_t * mask_p,
-                  const lv_style_t * style_p);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif

lv_draw/lv_draw_rbasic.c

@@ -1,216 +0,0 @@
-/**
- * @file lv_draw_rbasic.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_draw_rbasic.h"
-#include "lv_conf.h"
-#include "hal/disp/disp.h"
-#include "misc/gfx/font.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Put a pixel to the display
- * @param x x coordinate of the pixel
- * @param y y coordinate of the pixel
- * @param mask_p the pixel will be drawn on this area
- * @param color color of the pixel
- * @param opa opacity (ignored, only for compatibility with lv_vpx)
- */
-void lv_rpx(cord_t x, cord_t y, const area_t * mask_p, color_t color, opa_t opa)
-{
-    area_t area;
-    area.x1 = x;
-    area.y1 = y;
-    area.x2 = x;
-    area.y2 = y;
-
-    lv_rfill(&area, mask_p, color, OPA_COVER);
-}
-
-/**
- * Fill an area on the display
- * @param cords_p coordinates of the area to fill
- * @param mask_p fill only o this mask
- * @param color fill color
- * @param opa opacity (ignored, only for compatibility with lv_vfill)
- */
-void lv_rfill(const area_t * cords_p, const area_t * mask_p, 
-              color_t color, opa_t opa)
-{   
-    area_t masked_area;
-    bool union_ok = true;
-    
-    if(mask_p != NULL) {
-        union_ok = area_union(&masked_area, cords_p, mask_p);
-    } else {
-        area_t scr_area;
-        area_set(&scr_area, 0, 0, LV_HOR_RES - 1, LV_VER_RES - 1);
-        union_ok = area_union(&masked_area, cords_p, &scr_area);
-    }
-        
-    
-    if(union_ok != false){
-    	disp_fill(masked_area.x1, masked_area.y1, masked_area.x2, masked_area.y2, color);
-    }
-}
-
-/**
- * Draw a letter to the display
- * @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 (ignored, only for compatibility with lv_vletter)
- */
-void lv_rletter(const point_t * pos_p, const area_t * mask_p,
-                     const font_t * font_p, uint8_t letter,
-                     color_t color, opa_t opa)
-{
-    uint8_t w = font_get_width(font_p, letter);
-    const uint8_t * bitmap_p = font_get_bitmap(font_p, letter);
-
-    uint8_t col, col_sub, row;
-#if FONT_ANTIALIAS == 0
-    for(row = 0; row < font_p->height_row; row ++) {
-        for(col = 0, col_sub = 7; col < w; col ++, col_sub--) {
-            if(*bitmap_p & (1 << col_sub)) {
-                lv_rpx(pos_p->x + col, pos_p->y + row, mask_p, color, opa);
-            }
-
-            if(col_sub == 0) {
-                bitmap_p++;
-                col_sub = 8;
-            }
-        }
-        
-        /*Correction if the letter is short*/
-        bitmap_p += font_p->width_byte - ((w >> 3) + 1);  
-        /*Go to the next row*/
-        bitmap_p ++;
-    }
-#else
-       const uint8_t * map1_p = bitmap_p;
-       const uint8_t * map2_p = bitmap_p + font_p->width_byte;
-       uint8_t px_cnt;
-       uint8_t col_byte_cnt;
-       for(row = 0; row < (font_p->height_row >> 1); row ++) {
-           col_byte_cnt = 0;
-           col_sub = 7;
-           for(col = 0; col < (w >> 1); col ++) {
-
-               px_cnt = 0;
-               if((*map1_p & (1 << col_sub)) != 0) px_cnt++;
-               if((*map2_p & (1 << col_sub)) != 0) px_cnt++;
-               if(col_sub != 0) col_sub --;
-               else {
-                   col_sub = 7;
-                   col_byte_cnt ++;
-                   map1_p ++;
-                   map2_p ++;
-               }
-               if((*map1_p & (1 << col_sub)) != 0) px_cnt++;
-               if((*map2_p & (1 << col_sub)) != 0) px_cnt++;
-               if(col_sub != 0) col_sub --;
-               else {
-                   col_sub = 7;
-                   col_byte_cnt ++;
-                   map1_p ++;
-                   map2_p ++;
-               }
-
-
-               if(px_cnt != 0) {
-                   lv_rpx(pos_p->x + col, pos_p->y + row, mask_p, color_mix(color, COLOR_SILVER, 63 * px_cnt), OPA_COVER);
-               }
-           }
-
-           map1_p += font_p->width_byte;
-           map2_p += font_p->width_byte;
-           map1_p += font_p->width_byte - col_byte_cnt;
-           map2_p += font_p->width_byte - col_byte_cnt;
-       }
-#endif
-}
-
-/**
- * Draw a color map to the display
- * @param cords_p coordinates the color map
- * @param mask_p the map will drawn only on this area
- * @param map_p pointer to a color_t array
- * @param opa opacity of the map (ignored, only for compatibility with lv_vmap)
- * @param transp true: enable transparency of LV_IMG_COLOR_TRANSP color pixels
- * @param upscale true: upscale to double size (not supported)
- * @param recolor mix the pixels with this color (not supported)
- * @param recolor_opa the intense of recoloring (not supported)
- */
-void lv_rmap(const area_t * cords_p, const area_t * mask_p,
-             const color_t * map_p, opa_t opa, bool transp, bool upscale,
-			 color_t recolor, opa_t recolor_opa)
-{
-    area_t masked_a;
-    bool union_ok;
-
-    union_ok = area_union(&masked_a, cords_p, mask_p);
-
-    /*If there are common part of the mask and map then draw the map*/
-    if(union_ok == false) return;
-
-    /*Go to the first pixel*/
-    cord_t map_width = area_get_width(cords_p);
-    map_p+= (masked_a.y1 - cords_p->y1) * map_width;
-    map_p += masked_a.x1 - cords_p->x1;
-
-    if(transp == false) {
-        cord_t row;
-        cord_t mask_w = area_get_width(&masked_a) - 1;
-        for(row = 0; row < area_get_height(&masked_a); row++) {
-            disp_map(masked_a.x1, masked_a.y1 + row, masked_a.x1 + mask_w, masked_a.y1 + row, map_p);
-
-            map_p += map_width;
-        }
-    }else {
-        color_t transp_color = LV_COLOR_TRANSP;
-        cord_t row;
-        for(row = 0; row < area_get_height(&masked_a); row++) {
-            cord_t col;
-            for(col = 0; col < area_get_width(&masked_a); col ++) {
-                if(map_p[col].full != transp_color.full) {
-                    lv_rpx(masked_a.x1 + col, masked_a.y1 + row, mask_p, map_p[col], opa);
-                }
-            }
-            map_p += map_width;
-        }
-    }
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/

lv_draw/lv_draw_rbasic.h

@@ -1,71 +0,0 @@
-/**
- * @file lv_draw_rbasic..h
- * 
- */
-
-#ifndef LV_DRAW_RBASIC_H
-#define LV_DRAW_RBASIC_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "misc/gfx/color.h"
-#include "misc/gfx/area.h"
-#include "misc/gfx/font.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-void lv_rpx(cord_t x, cord_t y, const area_t * mask_p, color_t color, opa_t opa);
-
-/**
- * Fill an area on the display
- * @param cords_p coordinates of the area to fill
- * @param mask_p fill only o this mask
- * @param color fill color
- * @param opa opacity (ignored, only for compatibility with lv_vfill)
- */
-void lv_rfill(const area_t * cords_p, const area_t * mask_p,
-                color_t color, opa_t opa);
-
-/**
- * Draw a letter to the display
- * @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 (ignored, only for compatibility with lv_vletter)
- */
-void lv_rletter(const point_t * pos_p, const area_t * mask_p,
-                const font_t * font_p, uint8_t letter,
-                color_t color, opa_t opa);
-
-/**
- * Draw a color map to the display
- * @param cords_p coordinates the color map
- * @param mask_p the map will drawn only on this area
- * @param map_p pointer to a color_t array
- * @param opa opacity of the map (ignored, only for compatibility with lv_vmap)
- * @param transp true: enable transparency of LV_IMG_COLOR_TRANSP color pixels
- * @param upscale true: upscale to double size (not supported)
- * @param recolor mix the pixels with this color (not supported)
- * @param recolor_opa the intense of recoloring (not supported)
- */
-void lv_rmap(const area_t * cords_p, const area_t * mask_p,
-             const color_t * map_p, opa_t opa, bool transp, bool upscale,
-			 color_t recolor, opa_t recolor_opa);
-/**********************
- *      MACROS
- **********************/
-
-#endif

lv_draw/lv_draw_vbasic.c

@@ -1,482 +0,0 @@
-/**
- * @file lv_vdraw.c
- * 
- */
-
-#include <lv_conf.h>
-#include <misc/gfx/area.h>
-#include <misc/gfx/font.h>
-#include <misc/gfx/color.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-#if LV_VDB_SIZE != 0
-
-#include <stddef.h>
-#include "lvgl/lv_obj/lv_vdb.h"
-
-/*********************
- *      INCLUDES
- *********************/
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-
-/**********************
- *  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_vpx(cord_t x, cord_t y, const area_t * mask_p, color_t color, opa_t opa)
-{
-    lv_vdb_t * vdb_p = lv_vdb_get();
-
-    /*Pixel out of the mask*/
-    if(x < mask_p->x1 || x > mask_p->x2 ||
-       y < mask_p->y1 || y > mask_p->y2) {
-        return;
-    }
-
-    uint32_t vdb_width = area_get_width(&vdb_p->area);
-
-    /*Make the coordinates relative to VDB*/
-    x-=vdb_p->area.x1;
-    y-=vdb_p->area.y1;
-    color_t * vdb_px_p = vdb_p->buf + y * vdb_width + x;
-    if(opa == OPA_COVER) {
-        *vdb_px_p = color;
-    }
-    else {
-        *vdb_px_p = color_mix(color,*vdb_px_p, 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  (truncated to VDB area)
- * @param color fill color
- * @param opa opacity of the area (0..255)
- */
-void lv_vfill(const area_t * cords_p, const area_t * mask_p, 
-                          color_t color, opa_t opa)
-{
-    area_t res_a;
-    bool union_ok;
-    lv_vdb_t * vdb_p = lv_vdb_get();
-    
-    /*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 = area_union(&res_a, cords_p, mask_p);
-    
-    /*If there are common part of the three area then draw to the vdb*/
-    if(union_ok == true) {
-        area_t vdb_rel_a;   /*Stores relative coordinates on vdb*/
-        vdb_rel_a.x1 = res_a.x1 - vdb_p->area.x1;
-        vdb_rel_a.y1 = res_a.y1 - vdb_p->area.y1;
-        vdb_rel_a.x2 = res_a.x2 - vdb_p->area.x1;
-        vdb_rel_a.y2 = res_a.y2 - vdb_p->area.y1;
-        
-        color_t * vdb_buf_tmp = vdb_p->buf;
-        uint32_t vdb_width = area_get_width(&vdb_p->area);
-        /*Move the vdb_tmp to the first row*/
-        vdb_buf_tmp += vdb_width * vdb_rel_a.y1;
-        
-        /*Set all row in vdb to the given color*/
-        cord_t row;
-        uint32_t col;
-        
-        /*Run simpler function without opacity*/
-        if(opa == OPA_COVER) {
-            /*Fill the first row with 'color'*/
-            for(col = vdb_rel_a.x1; col <= vdb_rel_a.x2; col++) {
-                 vdb_buf_tmp[col] = color;
-            }
-            /*Copy the first row to all other rows*/
-            color_t * vdb_buf_first = &vdb_buf_tmp[vdb_rel_a.x1];
-            cord_t copy_size =  (vdb_rel_a.x2 - vdb_rel_a.x1 + 1) * sizeof(color_t);
-            vdb_buf_tmp += vdb_width;
-            
-            for(row = vdb_rel_a.y1 + 1; row <= vdb_rel_a.y2; row++) {
-                memcpy(&vdb_buf_tmp[vdb_rel_a.x1], vdb_buf_first, copy_size);
-                vdb_buf_tmp += vdb_width;
-            }            
-        }
-        /*Calculate with alpha too*/
-        else {
-            color_t bg_tmp = COLOR_BLACK;
-            color_t opa_tmp = color_mix(color, bg_tmp, opa);
-            for(row = vdb_rel_a.y1; row <= vdb_rel_a.y2; row++) {
-                for(col = vdb_rel_a.x1; col <= vdb_rel_a.x2; col++) {
-                    /*If the bg color changed recalculate the result color*/
-                    if(vdb_buf_tmp[col].full != bg_tmp.full) {
-                        bg_tmp = vdb_buf_tmp[col];
-                        opa_tmp = color_mix(color, bg_tmp, opa);
-                    }
-                    vdb_buf_tmp[col] = opa_tmp;
-                }
-                vdb_buf_tmp += vdb_width;
-            }
-        }
-    }    
-}
-
-/**
- * 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_vletter(const point_t * pos_p, const area_t * mask_p, 
-                     const font_t * font_p, uint8_t letter,
-                     color_t color, opa_t opa)
-{      
-    if(font_p == NULL) return;
-
-    uint8_t letter_w = font_get_width(font_p, letter);
-    uint8_t letter_h = font_get_height(font_p);
-
-    const uint8_t * map_p = font_get_bitmap(font_p, letter);
-
-    if(map_p == NULL) return;
-
-    /*If the letter is completely out of mask don't draw it */
-    if(pos_p->x + letter_w < mask_p->x1 || pos_p->x > mask_p->x2 ||
-       pos_p->y + letter_h < mask_p->y1 || pos_p->y > mask_p->y2) return;
-
-    lv_vdb_t * vdb_p = lv_vdb_get();
-    cord_t vdb_width = area_get_width(&vdb_p->area);
-    color_t * vdb_buf_tmp = vdb_p->buf;
-    cord_t col, row;
-    uint8_t col_bit;
-    uint8_t col_byte_cnt;
-
-    /* Calculate the col/row start/end on the map
-     * If font anti alaiassing is enabled use the reduced letter sizes*/
-    cord_t col_start = pos_p->x > mask_p->x1 ? 0 : mask_p->x1 - pos_p->x;
-    cord_t col_end = pos_p->x + (letter_w >> FONT_ANTIALIAS) < mask_p->x2 ? (letter_w >> FONT_ANTIALIAS) : mask_p->x2 - pos_p->x + 1;
-    cord_t row_start = pos_p->y > mask_p->y1 ? 0 : mask_p->y1 - pos_p->y;
-    cord_t row_end  = pos_p->y + (letter_h >> FONT_ANTIALIAS) < mask_p->y2 ? (letter_h >> FONT_ANTIALIAS) : mask_p->y2 - pos_p->y + 1;
-
-    /*Set a pointer on VDB to the first pixel of the letter*/
-    vdb_buf_tmp += ((pos_p->y - vdb_p->area.y1) * vdb_width)
-                    + pos_p->x - vdb_p->area.x1;
-
-    /*If the letter is partially out of mask the move there on VDB*/
-    vdb_buf_tmp += (row_start * vdb_width) + col_start;
-
-    /*Move on the map too*/
-    map_p += ((row_start << FONT_ANTIALIAS) * font_p->width_byte) + ((col_start << FONT_ANTIALIAS) >> 3);
-
-#if FONT_ANTIALIAS != 0
-    opa_t opa_tmp = opa;
-    if(opa_tmp != OPA_COVER) opa_tmp = opa_tmp >> 2;   /*Opacity per pixel (used when sum the pixels)*/
-    const uint8_t * map1_p = map_p;
-    const uint8_t * map2_p = map_p + font_p->width_byte;
-    uint8_t px_cnt;
-    for(row = row_start; row < row_end; row ++) {
-        col_byte_cnt = 0;
-        col_bit = 7 - ((col_start << FONT_ANTIALIAS) % 8);
-        for(col = col_start; col < col_end; col ++) {
-
-            px_cnt = 0;
-            if((*map1_p & (1 << col_bit)) != 0) px_cnt++;
-            if((*map2_p & (1 << col_bit)) != 0) px_cnt++;
-            if(col_bit != 0) col_bit --;
-            else {
-                col_bit = 7;
-                col_byte_cnt ++;
-                map1_p ++;
-                map2_p ++;
-            }
-            if((*map1_p & (1 << col_bit)) != 0) px_cnt++;
-            if((*map2_p & (1 << col_bit)) != 0) px_cnt++;
-            if(col_bit != 0) col_bit --;
-            else {
-                col_bit = 7;
-                col_byte_cnt ++;
-                map1_p ++;
-                map2_p ++;
-            }
-
-
-            if(px_cnt != 0) {
-                if(opa == OPA_COVER) *vdb_buf_tmp = color_mix(color, *vdb_buf_tmp, 63*px_cnt);
-                else *vdb_buf_tmp = color_mix(color, *vdb_buf_tmp, opa_tmp * px_cnt);
-            }
-
-           vdb_buf_tmp++;
-        }
-
-        map1_p += font_p->width_byte;
-        map2_p += font_p->width_byte;
-        map1_p += font_p->width_byte - col_byte_cnt;
-        map2_p += font_p->width_byte - col_byte_cnt;
-        vdb_buf_tmp += vdb_width  - ((col_end) - (col_start)); /*Next row in VDB*/
-    }
-#else
-    for(row = row_start; row < row_end; row ++) {
-        col_byte_cnt = 0;
-        col_bit = 7 - (col_start % 8);
-        for(col = col_start; col < col_end; col ++) {
-
-            if((*map_p & (1 << col_bit)) != 0) {
-                if(opa == OPA_COVER) *vdb_buf_tmp = color;
-                else *vdb_buf_tmp = color_mix(color, *vdb_buf_tmp, opa);
-            }
-
-           vdb_buf_tmp++;
-
-           if(col_bit != 0) col_bit --;
-           else {
-               col_bit = 7;
-               col_byte_cnt ++;
-               map_p ++;
-            }
-        }
-
-        map_p += font_p->width_byte - col_byte_cnt;
-        vdb_buf_tmp += vdb_width  - (col_end - col_start); /*Next row in VDB*/
-    }
-#endif
-}
-
-/**
- * Draw a color map to the display
- * @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 color_t array
- * @param opa opacity of the map (ignored, only for compatibility with lv_vmap)
- * @param transp true: enable transparency of LV_IMG_COLOR_TRANSP color pixels
- * @param upscale true: upscale to double size
- * @param recolor mix the pixels with this color
- * @param recolor_opa the intense of recoloring
- */
-void lv_vmap(const area_t * cords_p, const area_t * mask_p, 
-             const color_t * map_p, opa_t opa, bool transp, bool upscale,
-			 color_t recolor, opa_t recolor_opa)
-{
-    area_t masked_a;
-    bool union_ok;
-    lv_vdb_t * vdb_p = lv_vdb_get();
-
-    /*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 = area_union(&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;
-
-    uint8_t ds_shift = 0;
-    if(upscale != false) ds_shift = 1;
-
-    /*If the map starts OUT of the masked area then calc. the first pixel*/
-    cord_t map_width = area_get_width(cords_p) >> ds_shift;
-    if(cords_p->y1 < masked_a.y1) {
-        map_p += (uint32_t) map_width * ((masked_a.y1 - cords_p->y1) >> ds_shift);
-    }
-    if(cords_p->x1 < masked_a.x1) {
-        map_p += (masked_a.x1 - cords_p->x1) >> ds_shift;
-    }
-
-    /*Stores coordinates relative to the act vdb*/
-    masked_a.x1 = masked_a.x1 - vdb_p->area.x1;
-    masked_a.y1 = masked_a.y1 - vdb_p->area.y1;
-    masked_a.x2 = masked_a.x2 - vdb_p->area.x1;
-    masked_a.y2 = masked_a.y2 - vdb_p->area.y1;
-
-    cord_t vdb_width = area_get_width(&vdb_p->area);
-    color_t * vdb_buf_tmp = vdb_p->buf;
-    vdb_buf_tmp += (uint32_t) vdb_width * masked_a.y1; /*Move to the first row*/
-
-    map_p -= (masked_a.x1 >> ds_shift);
-
-    /*No upscalse*/
-    if(upscale == false) {
-        if(transp == false) { /*Simply copy the pixels to the VDB*/
-            cord_t row;
-
-            if(opa == OPA_COVER)  { /*no opa */
-                for(row = masked_a.y1; row <= masked_a.y2; row++) {
-                    memcpy(&vdb_buf_tmp[masked_a.x1],
-                           &map_p[masked_a.x1],
-                           area_get_width(&masked_a) * sizeof(color_t));
-                    map_p += map_width;               /*Next row on the map*/
-                    vdb_buf_tmp += vdb_width;         /*Next row on the VDB*/
-                }
-            } else {    /*with opacity*/
-                cord_t col;
-                for(row = masked_a.y1; row <= masked_a.y2; row++) {
-                    for(col = masked_a.x1; col <= masked_a.x2; col ++) {
-                        vdb_buf_tmp[col] = color_mix( map_p[col], vdb_buf_tmp[col], opa);
-                    }
-                    map_p += map_width;              /*Next row on the map*/
-                    vdb_buf_tmp += vdb_width;        /*Next row on the VDB*/
-                }
-            }
-
-#if LV_VDB_SIZE != 0
-            /*To recolor draw simply a rectangle above the image*/
-            if(recolor_opa != OPA_TRANSP) {
-                lv_vfill(cords_p, mask_p, recolor, recolor_opa);
-            }
-#endif
-        } else { /*transp == true: Check all pixels */
-            cord_t row;
-            cord_t col;
-            color_t transp_color = LV_COLOR_TRANSP;
-
-            if(recolor_opa == OPA_TRANSP) {/*No recolor*/
-                if(opa == OPA_COVER)  { /*no opa */
-                    for(row = masked_a.y1; row <= masked_a.y2; row++) {
-                        for(col = masked_a.x1; col <= masked_a.x2; col ++) {
-                            if(map_p[col].full != transp_color.full) {
-                                vdb_buf_tmp[col] = map_p[col];
-                            }
-                        }
-
-                        map_p += map_width;         /*Next row on the map*/
-                        vdb_buf_tmp += vdb_width;   /*Next row on the VDB*/
-                    }
-                } else {
-                    for(row = masked_a.y1; row <= masked_a.y2; row++) {
-                        for(col = masked_a.x1; col <= masked_a.x2; col ++) {
-                            if(map_p[col].full != transp_color.full) {
-                                vdb_buf_tmp[col] = color_mix( map_p[col], vdb_buf_tmp[col], opa);
-                            }
-                        }
-
-                        map_p += map_width;          /*Next row on the map*/
-                        vdb_buf_tmp += vdb_width;   /*Next row on the VDB*/
-                    }
-                }
-            } else { /*Recolor needed*/
-                color_t color_tmp;
-                if(opa == OPA_COVER)  { /*no opa */
-                    for(row = masked_a.y1; row <= masked_a.y2; row++) {
-                        for(col = masked_a.x1; col <= masked_a.x2; col ++) {
-                            if(map_p[col].full != transp_color.full) {
-                                color_tmp = color_mix(recolor, map_p[col], recolor_opa);
-                                vdb_buf_tmp[col] = color_tmp;
-                            }
-                        }
-
-                        map_p += map_width; /*Next row on the map*/
-                        vdb_buf_tmp += vdb_width;         /*Next row on the VDB*/
-                    }
-                } else {
-                    for(row = masked_a.y1; row <= masked_a.y2; row++) {
-                        for(col = masked_a.x1; col <= masked_a.x2; col ++) {
-                            if(map_p[col].full != transp_color.full) {
-                                color_tmp = color_mix(recolor, map_p[col], recolor_opa);
-                                vdb_buf_tmp[col] = color_mix(color_tmp, vdb_buf_tmp[col], opa);
-                            }
-                        }
-
-                        map_p += map_width; /*Next row on the map*/
-                        vdb_buf_tmp += vdb_width;         /*Next row on the VDB*/
-                    }
-                }
-            }
-        }
-    }
-    /*Upscalse*/
-    else {
-        cord_t row;
-        cord_t col;
-        color_t transp_color = LV_COLOR_TRANSP;
-        color_t color_tmp;
-        color_t prev_color = COLOR_BLACK;
-        cord_t map_col;
-
-        /*The most simple case (but upscale): 0 opacity, no recolor, no transp. pixels*/
-        if(transp == false && opa == OPA_COVER && recolor_opa == OPA_TRANSP) { 
-                cord_t map_col_start = masked_a.x1 >> 1;
-                cord_t map_col_end = masked_a.x2 >> 1;
-                cord_t map_col;
-                cord_t vdb_col = masked_a.x1;
-            for(row = masked_a.y1; row <= masked_a.y2; row++) {
-                map_col_start = masked_a.x1 >> 1;
-                map_col_end = masked_a.x2 >> 1;
-                vdb_col = masked_a.x1;
-               for(map_col = map_col_start; map_col <= map_col_end; map_col ++, vdb_col += 2) {
-                   vdb_buf_tmp[vdb_col].full = map_p[map_col].full;
-                   vdb_buf_tmp[vdb_col + 1].full = map_p[map_col].full;
-               }
-               if((row & 0x1) != 0) map_p += map_width; /*Next row on the map*/
-               vdb_buf_tmp += vdb_width ;        /*Next row on the VDB*/
-            }
-        }
-        /*Handle other cases*/
-        else {
-           color_tmp = color_mix(recolor, prev_color, recolor_opa);
-           for(row = masked_a.y1; row <= masked_a.y2; row++) {
-               for(col = masked_a.x1; col <= masked_a.x2; col ++) {
-                   map_col = col >> 1;
-
-                   /*Handle recoloring*/
-                   if(recolor_opa == OPA_TRANSP) {
-                       color_tmp.full = map_p[map_col].full;
-                   } else {
-                       if(map_p[map_col].full != prev_color.full) {
-                           prev_color.full = map_p[map_col].full;
-                           color_tmp = color_mix(recolor, prev_color, recolor_opa);
-                       }
-                   }
-                   /*Put the NOT transparent pixels*/
-                   if(transp == false || map_p[map_col].full != transp_color.full) {
-                       /*Handle opacity*/
-                       if(opa == OPA_COVER) {
-                           vdb_buf_tmp[col] = color_tmp;
-                       } else {
-                           vdb_buf_tmp[col] = color_mix( color_tmp, vdb_buf_tmp[col], opa);
-                       }
-                   }
-               }
-               if((row & 0x1) != 0) map_p += map_width; /*Next row on the map*/
-               vdb_buf_tmp += vdb_width ;        /*Next row on the VDB*/
-           }
-        }
-    }
-}
-
-
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-#endif

lv_draw/lv_draw_vbasic.h

@@ -1,79 +0,0 @@
-/**
- * @file lv_draw_vbasic.h
- * 
- */
-
-#ifndef LV_DRAW_VBASIC_H
-#define LV_DRAW_VBASIC_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-
-#if LV_VDB_SIZE != 0
-
-#include "misc/gfx/color.h"
-#include "misc/gfx/area.h"
-#include "misc/gfx/font.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-void lv_vpx(cord_t x, cord_t y, const area_t * mask_p, color_t color, 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_vfill(const area_t * cords_p, const area_t * mask_p,
-                color_t color, 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_vletter(const point_t * pos_p, const area_t * mask_p,
-                const font_t * font_p, uint8_t letter,
-                color_t color, opa_t opa);
-
-/**
- * Draw a color map to the display
- * @param cords_p coordinates the color map
- * @param mask_p the map will drawn only on this area
- * @param map_p pointer to a color_t array
- * @param opa opacity of the map (ignored, only for compatibility with lv_vmap)
- * @param transp true: enable transparency of LV_IMG_COLOR_TRANSP color pixels
- * @param upscale true: upscale to double size
- * @param recolor mix the pixels with this color
- * @param recolor_opa the intense of recoloring
- */
-void lv_vmap(const area_t * cords_p, const area_t * mask_p,
-            const color_t * map_p, opa_t opa, bool transp, bool upscale,
-            color_t recolor, opa_t recolor_opa);
-
-
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_obj/lv_dispi.c

@@ -1,486 +0,0 @@
-/**
- * @file lv_dispi.c
- * 
- */
-
-/*********************
- *      INCLUDES
- ********************/
-#include "lv_conf.h"
-
-#include "misc/os/ptask.h"
-#include "misc/math/math_base.h"
-#include "lv_dispi.h"
-#include "../lv_draw/lv_draw_rbasic.h"
-#include "hal/indev/indev.h"
-#include "hal/systick/systick.h"
-#include "lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void dispi_task(void * param);
-static void dispi_proc_point(lv_dispi_t * dispi_p, cord_t x, cord_t y);
-static void dispi_proc_press(lv_dispi_t * dispi_p);
-static void disi_proc_release(lv_dispi_t * dispi_p);
-static lv_obj_t * dispi_search_obj(const lv_dispi_t * dispi_p, lv_obj_t * obj);
-static void dispi_drag(lv_dispi_t * dispi_p);
-static void dispi_drag_throw(lv_dispi_t * dispi_p);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static ptask_t* dispi_task_p;
-static bool lv_dispi_reset_qry;
-static bool lv_dispi_reset_now;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the display input subsystem
- */
-void lv_dispi_init(void)
-{
-    lv_dispi_reset_qry = false;
-    lv_dispi_reset_now = false;
-
-#if LV_DISPI_READ_PERIOD != 0
-    dispi_task_p = ptask_create(dispi_task, LV_DISPI_READ_PERIOD, PTASK_PRIO_MID, NULL);
-#else
-    dispi_task_p = ptask_create(dispi_task, 1, PTASK_PRIO_OFF); /*Not use lv_dispi*/
-#endif
-}
-
-/**
- * Reset all display inputs
- */
-void lv_dispi_reset(void)
-{
-    lv_dispi_reset_qry = true;
-}
-
-/**
- * Reset the long press state of a display input
- * @param dispi pointer to a display input
- */
-void lv_dispi_reset_lpr(lv_dispi_t * dispi)
-{
-    dispi->long_press_sent = 0;
-    dispi->lpr_rep_time_stamp = systick_get();
-    dispi->press_time_stamp = systick_get();
-}
-
-/**
- * Get the last point on display input
- * @param dispi pointer to a display input
- * @param point pointer to a point to store the result
- */
-void lv_dispi_get_point(lv_dispi_t * dispi, point_t * point)
-{
-    point->x = dispi->act_point.x;
-    point->y = dispi->act_point.y;
-}
-
-/**
- * Check if there is dragging on display input or not 
- * @param dispi pointer to a display input
- * @return true: drag is in progress
- */
-bool lv_dispi_is_dragging(lv_dispi_t * dispi)
-{
-    return dispi->drag_in_prog == 0 ? false : true;
-}
-
-/**
- * Get the vector of dragging on a display input
- * @param dispi pointer to a display input
- * @param point pointer to a point to store the vector
- */
-void lv_dispi_get_vect(lv_dispi_t * dispi, point_t * point)
-{
-    point->x = dispi->vect.x;
-    point->y = dispi->vect.y;
-}
-
-/**
- * Do nothing until the next release
- * @param dispi pointer to a display input
- */
-void lv_dispi_wait_release(lv_dispi_t * dispi)
-{
-    dispi->wait_release = 1;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Called periodically to handle the display inputs
- * @param param unused
- */
-static void dispi_task(void * param)
-{
-
-	static lv_dispi_t dispi[INDEV_NUM];
-	cord_t x;
-	cord_t y;
-	uint8_t i;
-
-	for (i = 0; i < INDEV_NUM; i++) {
-		dispi[i].pressed = indev_get(i, &x, &y);
-		dispi_proc_point(&dispi[i], x, y);
-	}
-
-    /*If reset query occurred in this round then set a flag to 
-     * ask the dispis to reset themself in the next round  */
-    if(lv_dispi_reset_qry != false) {
-        lv_dispi_reset_qry = false;
-        lv_dispi_reset_now = true;
-    } 
-    /*If now a reset occurred then clear the flag*/
-    else if (lv_dispi_reset_now != false){
-        lv_dispi_reset_now = false;
-    }
-}
-
-/**
- * Process new points by a display input. dispi_p->pressed has to be set
- * @param dispi_p pointer to a display input
- * @param x x coordinate of the next point
- * @param y y coordinate of the next point
- */
-static void dispi_proc_point(lv_dispi_t * dispi_p, cord_t x, cord_t y)
-{
-#if LV_ANTIALIAS != 0 && LV_VDB_SIZE != 0
-    dispi_p->act_point.x = x * LV_DOWNSCALE;
-    dispi_p->act_point.y = y * LV_DOWNSCALE;
-#else
-    dispi_p->act_point.x = x;
-    dispi_p->act_point.y = y;
-#endif
-    /*Handle the reset query*/
-    if(lv_dispi_reset_now != false) {
-        dispi_p->act_obj = NULL;
-        dispi_p->last_obj = NULL;
-        dispi_p->drag_range_out = 0;
-        dispi_p->drag_in_prog = 0;
-        dispi_p->long_press_sent = 0;
-        dispi_p->press_time_stamp = 0;
-        dispi_p->lpr_rep_time_stamp = 0;
-        dispi_p->vect_sum.x = 0;
-        dispi_p->vect_sum.y = 0;
-    }
-    
-    if(dispi_p->pressed != false){
-#if LV_DISPI_TP_MARKER != 0
-        area_t area;
-        area.x1 = x - (LV_DISPI_TP_MARKER >> 1);
-        area.y1 = y - (LV_DISPI_TP_MARKER >> 1);
-        area.x2 = x + ((LV_DISPI_TP_MARKER >> 1) | 0x1);
-        area.y2 = y + ((LV_DISPI_TP_MARKER >> 1) | 0x1);
-        lv_rfill(&area, NULL, COLOR_MAKE(0xFF, 0, 0), OPA_COVER);
-#endif
-        dispi_proc_press(dispi_p);
-    } else {
-        disi_proc_release(dispi_p);
-    }
-    
-    
-    dispi_p->last_point.x = dispi_p->act_point.x;
-    dispi_p->last_point.y = dispi_p->act_point.y;
-}   
-
-/**
- * Process the pressed state
- * @param dispi_p pointer to a display input
- */
-static void dispi_proc_press(lv_dispi_t * dispi_p)
-{
-    lv_obj_t * pr_obj = dispi_p->act_obj;
-    
-    if(dispi_p->wait_release != 0) return;
-
-    /*If there is no last object then search*/
-    if(dispi_p->act_obj == NULL) {
-        pr_obj = dispi_search_obj(dispi_p, lv_scr_act());
-    }
-    /*If there is last object but it is not dragged also search*/
-    else if(dispi_p->drag_in_prog == 0) {/*Now act_obj != NULL*/
-        pr_obj = dispi_search_obj(dispi_p, lv_scr_act());
-    }
-    /*If a dragable object was the last then keep it*/
-    else {
-        
-    }
-    
-    /*If a new object was found reset some variables and send a pressed signal*/
-    if(pr_obj != dispi_p->act_obj) {
-
-        dispi_p->last_point.x = dispi_p->act_point.x;
-        dispi_p->last_point.y = dispi_p->act_point.y;
-        
-        /*If a new object found the previous was lost, so send a signal*/
-        if(dispi_p->act_obj != NULL) {
-            dispi_p->act_obj->signal_f(dispi_p->act_obj,
-                                          LV_SIGNAL_PRESS_LOST, dispi_p);
-        }
-        
-        if(pr_obj != NULL) {
-            /* Save the time when the obj pressed. 
-             * It is necessary to count the long press time.*/
-            dispi_p->press_time_stamp = systick_get();
-            dispi_p->long_press_sent = 0;
-            dispi_p->drag_range_out = 0;
-            dispi_p->drag_in_prog = 0;
-            dispi_p->vect_sum.x = 0;
-            dispi_p->vect_sum.y = 0;
-
-            /*Search for 'top' attribute*/
-            lv_obj_t * i = pr_obj;
-            lv_obj_t * last_top = NULL;
-            while(i != NULL){
-				if(i->top_en != 0) last_top = i;
-				i = lv_obj_get_parent(i);
-            }
-
-            if(last_top != NULL) {
-            	/*Move the last_top object to the foreground*/
-            	lv_obj_t * par =lv_obj_get_parent(last_top);
-            	/*After list change it will be the new head*/
-                ll_chg_list(&par->child_ll, &par->child_ll, last_top);
-                lv_obj_inv(last_top);
-            }
-
-            /*Send a signal about the press*/
-            pr_obj->signal_f(pr_obj, LV_SIGNAL_PRESSED, dispi_p);
-        }
-    }
-    
-    /* The reset can be set in the signal function.
-     * In case of reset query ignore the remaining parts.*/
-    if(lv_dispi_reset_qry == false) {
-        dispi_p->act_obj = pr_obj;      /*Save the pressed object*/
-        dispi_p->last_obj = dispi_p->act_obj; /*Refresh the last_obj*/
-
-        /*Calculate the vector*/
-        dispi_p->vect.x = dispi_p->act_point.x - dispi_p->last_point.x;
-        dispi_p->vect.y = dispi_p->act_point.y - dispi_p->last_point.y;
-
-        /*If there is active object and it can be dragged run the drag*/
-        if(dispi_p->act_obj != NULL) {
-            dispi_p->act_obj->signal_f(dispi_p->act_obj, LV_SIGNAL_PRESSING, dispi_p);
-
-            dispi_drag(dispi_p);
-        
-            /*If there is no drag then check for long press time*/
-            if(dispi_p->drag_in_prog == 0 && dispi_p->long_press_sent == 0) {
-                /*Send a signal about the long press if enough time elapsed*/
-                if(systick_elaps(dispi_p->press_time_stamp) > LV_DISPI_LONG_PRESS_TIME) {
-                    pr_obj->signal_f(pr_obj, LV_SIGNAL_LONG_PRESS, dispi_p);
-
-                    /*Mark the signal sending to do not send it again*/
-                    dispi_p->long_press_sent = 1;
-
-                    /*Save the long press time stamp for the long press repeat handler*/
-                    dispi_p->lpr_rep_time_stamp = systick_get();
-                }
-            }
-            /*Send long press repeated signal*/
-            if(dispi_p->drag_in_prog == 0 && dispi_p->long_press_sent == 1) {
-            	/*Send a signal about the long press repeate if enough time elapsed*/
-				if(systick_elaps(dispi_p->lpr_rep_time_stamp) > LV_DISPI_LONG_PRESS_REP_TIME) {
-					pr_obj->signal_f(pr_obj, LV_SIGNAL_LONG_PRESS_REP, dispi_p);
-                    dispi_p->lpr_rep_time_stamp = systick_get();
-
-				}
-            }
-        }
-    }
-}
-
-/**
- * Process the released state
- * @param dispi_p pointer to a display input
- */
-static void disi_proc_release(lv_dispi_t * dispi_p)
-{
-    if(dispi_p->wait_release != 0) {
-        dispi_p->act_obj = NULL;
-        dispi_p->last_obj = NULL;
-        dispi_p->press_time_stamp = 0;
-        dispi_p->lpr_rep_time_stamp = 0;
-        dispi_p->wait_release = 0;
-    }
-
-    /*Forgot the act obj and send a released signal */
-    if(dispi_p->act_obj != NULL) {
-        dispi_p->act_obj->signal_f(dispi_p->act_obj,
-                                      LV_SIGNAL_RELEASED, dispi_p);
-        dispi_p->act_obj = NULL;   
-        dispi_p->press_time_stamp = 0;
-        dispi_p->lpr_rep_time_stamp = 0;
-    }
-    
-    /*The reset can be set in the signal function. 
-     * In case of reset query ignore the remaining parts.*/
-    if(dispi_p->last_obj != NULL && lv_dispi_reset_qry == false) {
-        dispi_drag_throw(dispi_p);
-    }
-
-}
-
-/**
- * Search the most top, clickable object on the last point of a display input
- * @param dispi_p pointer to a display input
- * @param obj pointer to a start object, typically the screen
- * @return pointer to the found object or NULL if there was no suitable object 
- */
-static lv_obj_t * dispi_search_obj(const lv_dispi_t * dispi_p, lv_obj_t * obj)
-{
-    lv_obj_t * found_p = NULL;
-    
-    /*If the point is on this object*/
-    /*Check its children too*/
-    if(area_is_point_on(&obj->cords, &dispi_p->act_point)) {
-        lv_obj_t * i;
-    
-        LL_READ(obj->child_ll, i) {
-            found_p = dispi_search_obj(dispi_p, i);
-            
-            /*If a child was found then break*/
-            if(found_p != NULL) {
-                break;
-            }
-        }
-        
-        /*If then the children was not ok, but this obj is clickable
-         * and it or its parent is not hidden then save this object*/
-        if(found_p == NULL && lv_obj_get_click(obj) != false) {
-        	lv_obj_t * i = obj;
-        	while(i != NULL) {
-        		if(lv_obj_get_hidden(i) == true) break;
-        		i = lv_obj_get_parent(i);
-        	}
-        	/*No parent found with hidden == true*/
-        	if(i == NULL) found_p = obj;
-        }
-        
-    }
-    
-    return found_p;    
-}
-
-/**
- * Handle the dragging of dispi_p->act_obj
- * @param dispi_p pointer to a display input
- */
-static void dispi_drag(lv_dispi_t * dispi_p)
-{
-    lv_obj_t * drag_obj = dispi_p->act_obj;
-    
-    /*If drag parent is active check recursively the drag_parent attribute*/
-	while(lv_obj_get_drag_parent(drag_obj) != false &&
-		  drag_obj != NULL) {
-		drag_obj = lv_obj_get_parent(drag_obj);
-	}
-
-	if(drag_obj == NULL) return;
-    
-    if(lv_obj_get_drag(drag_obj) == false) return;
-
-    /*If still there is no drag then count the movement*/
-    if(dispi_p->drag_range_out == 0) {
-        dispi_p->vect_sum.x += dispi_p->vect.x;
-        dispi_p->vect_sum.y += dispi_p->vect.y;
-        
-        /*If a move is greater then LV_DRAG_LIMIT then begin the drag*/
-        if(MATH_ABS(dispi_p->vect_sum.x) >= LV_DISPI_DRAG_LIMIT ||
-           MATH_ABS(dispi_p->vect_sum.y) >= LV_DISPI_DRAG_LIMIT)
-           {
-                dispi_p->drag_range_out = 1;
-           }
-    }
-    
-    /*If the drag limit is stepped over then handle the dragging*/
-    if(dispi_p->drag_range_out != 0) {
-        /*Set new position if the vector is not zero*/
-        if(dispi_p->vect.x != 0 ||
-           dispi_p->vect.y != 0) {   
-            /*Get the coordinates of the object end modify them*/
-            cord_t act_x = lv_obj_get_x(drag_obj);
-            cord_t act_y = lv_obj_get_y(drag_obj);
-
-            lv_obj_set_pos(drag_obj, act_x + dispi_p->vect.x, act_y + dispi_p->vect.y);
-
-            /*Set the drag in progress flag if the object is really moved*/
-            if(lv_obj_get_x(drag_obj) != act_x || lv_obj_get_y(drag_obj) != act_y) {
-                if(dispi_p->drag_range_out != 0) { /*Send the drag begin signal on first move*/
-                    drag_obj->signal_f(drag_obj,  LV_SIGNAL_DRAG_BEGIN, dispi_p);
-                }
-                dispi_p->drag_in_prog = 1;
-            }
-
-        }
-    }
-}
-
-/**
- * Handle throwing by drag if the drag is ended
- * @param dispi_p pointer to a display input
- */
-static void dispi_drag_throw(lv_dispi_t * dispi_p)
-{
-	if(dispi_p->drag_in_prog == 0) return;
-
-    /*Set new position if the vector is not zero*/
-    lv_obj_t * drag_obj = dispi_p->last_obj;
-    
-    /*If drag parent is active check recursively the drag_parent attribute*/
-
-	while(lv_obj_get_drag_parent(drag_obj) != false &&
-		  drag_obj != NULL) {
-		drag_obj = lv_obj_get_parent(drag_obj);
-	}
-
-	if(drag_obj == NULL) return;
-    
-    /*Return if the drag throw is not enabled*/
-    if(lv_obj_get_drag_throw(drag_obj) == false ){
-    	dispi_p->drag_in_prog = 0;
-        drag_obj->signal_f(drag_obj, LV_SIGNAL_DRAG_END, dispi_p);
-        return;
-    }
-    
-    /*Reduce the vectors*/
-    dispi_p->vect.x = dispi_p->vect.x * (100 -LV_DISPI_DRAG_THROW) / 100;
-    dispi_p->vect.y = dispi_p->vect.y * (100 -LV_DISPI_DRAG_THROW) / 100;
-    
-    if(dispi_p->vect.x != 0 ||
-       dispi_p->vect.y != 0)
-    {
-        /*Get the coordinates  and modify them*/
-        cord_t act_x = lv_obj_get_x(drag_obj) + dispi_p->vect.x;
-        cord_t act_y = lv_obj_get_y(drag_obj) + dispi_p->vect.y;
-        lv_obj_set_pos(drag_obj, act_x, act_y);
-    }
-    /*If the vectors become 0 -> drag_in_prog = 0 and send a drag end signal*/
-    else {
-        dispi_p->drag_in_prog = 0;
-        drag_obj->signal_f(drag_obj, LV_SIGNAL_DRAG_END, dispi_p);
-    }
-}

lv_obj/lv_dispi.h

@@ -1,100 +0,0 @@
-/**
- * @file lv_dispi.h
- * 
- */
-
-#ifndef LV_DISPI_H
-#define LV_DISPI_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-typedef struct
-{
-    bool pressed;
-    point_t act_point;
-    point_t last_point;
-    point_t vect;     
-    point_t vect_sum;
-    lv_obj_t * act_obj;
-    lv_obj_t * last_obj;
-    uint32_t press_time_stamp;
-    uint32_t lpr_rep_time_stamp;
-    
-    /*Flags*/
-    uint8_t drag_range_out :1;
-    uint8_t drag_in_prog :1;
-    uint8_t long_press_sent :1;
-    uint8_t wait_release :1;
-}lv_dispi_t;
-
-
-typedef enum
-{
-    LV_ACTION_RES_INV = 0,      /*Typically indicates that the object is deleted (become invalid) in the action function*/
-	LV_ACTION_RES_OK,           /*The object is valid (no deleted) after the action*/
-}lv_action_res_t;
-
-typedef lv_action_res_t ( * lv_action_t) (struct __LV_OBJ_T * obj, lv_dispi_t * dispi);
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Initialize the display input subsystem
- */
-void lv_dispi_init(void);
-
-/**
- * Reset all display inputs
- */
-void lv_dispi_reset(void);
-
-/**
- * Reset the long press state of a display input
- * @param dispi pointer to a display input
- */
-void lv_dispi_reset_lpr(lv_dispi_t * dispi);
-
-/**
- * Get the last point on display input
- * @param dispi pointer to a display input
- * @param point pointer to a point to store the result
- */
-void lv_dispi_get_point(lv_dispi_t * dispi, point_t * point);
-
-/**
- * Check if there is dragging on display input or not
- * @param dispi pointer to a display input
- * @return true: drag is in progress
- */
-bool lv_dispi_is_dragging(lv_dispi_t * dispi);
-
-/**
- * Get the vector of dragging on a display input
- * @param dispi pointer to a display input
- * @param point pointer to a point to store the vector
- */
-void lv_dispi_get_vect(lv_dispi_t * dispi, point_t * point);
-
-/**
- * Do nothing until the next release
- * @param dispi pointer to a display input
- */
-void lv_dispi_wait_release(lv_dispi_t * dispi);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif

lv_obj/lv_obj.h

@@ -1,659 +0,0 @@
-/**
- * @file lv_obj.h
- * 
- */
-
-#ifndef LV_OBJ_H
-#define LV_OBJ_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#include <misc/gfx/area.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include "misc/mem/dyn_mem.h"
-#include "misc/mem/linked_list.h"
-#include "misc/gfx/color.h"
-#include "lv_style.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/*Error check of lv_conf.h*/
-#if LV_HOR_RES == 0 || LV_VER_RES == 0
-#error "LV: LV_HOR_RES and LV_VER_RES must be greater then 0"
-#endif
-
-#if LV_DOWNSCALE != 1 && LV_DOWNSCALE != 2
-#error "LV: LV_DOWNSCALE can be only 1 or 2"
-#endif
-
-#if LV_VDB_SIZE == 0 && LV_ANTIALIAS != 0
-#error "LV: If LV_VDB_SIZE == 0 the antialaissing must be disabled"
-#endif
-
-/*New defines*/
-#define LV_OBJ_DEF_WIDTH  (80 * LV_DOWNSCALE)
-#define LV_OBJ_DEF_HEIGHT  (60 * LV_DOWNSCALE)
-
-#define ANIM_IN					0x00	/*Animation to show an object. 'OR' it with lv_anim_builtin_t*/
-#define ANIM_OUT				0x80    /*Animation to hide an object. 'OR' it with lv_anim_builtin_t*/
-#define ANIM_DIR_MASK			0x80	/*ANIM_IN/ANIM_OUT mask*/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-struct __LV_OBJ_T;
-
-typedef enum
-{
-    LV_DESIGN_DRAW_MAIN,
-    LV_DESIGN_DRAW_POST,
-    LV_DESIGN_COVER_CHK,
-}lv_design_mode_t;
-
-typedef bool (* lv_design_f_t) (struct __LV_OBJ_T * obj, const area_t * mask_p, lv_design_mode_t mode);
-
-typedef enum
-{
-	LV_SIGNAL_CLEANUP,
-    LV_SIGNAL_PRESSED,
-	LV_SIGNAL_PRESSING,
-    LV_SIGNAL_PRESS_LOST,
-    LV_SIGNAL_RELEASED,
-    LV_SIGNAL_LONG_PRESS,
-    LV_SIGNAL_LONG_PRESS_REP,
-    LV_SIGNAL_DRAG_BEGIN,
-    LV_SIGNAL_DRAG_END,        
-    LV_SIGNAL_CHILD_CHG,
-    LV_SIGNAL_CORD_CHG,
-    LV_SIGNAL_STYLE_CHG,
-	LV_SIGNAL_REFR_EXT_SIZE,
-}lv_signal_t;
-
-typedef bool (* lv_signal_f_t) (struct __LV_OBJ_T * obj, lv_signal_t sign, void * param);
-
-typedef struct __LV_OBJ_T
-{
-    struct __LV_OBJ_T * par;    /*Pointer to the parent object*/
-    ll_dsc_t child_ll;          /*Linked list to store the children objects*/
-    
-    area_t cords;               /*Coordinates of the object (x1, y1, x2, y2)*/
-
-    lv_signal_f_t signal_f;     /*Object type specific signal function*/
-    lv_design_f_t design_f;     /*Object type specific design function*/
-    
-    void * ext;                 /*Object type specific extended data*/
-    lv_style_t * style_p;       /*Pointer to the object's style*/
-
-#if LV_OBJ_FREE_P != 0
-    void * free_p;              /*Application specific pointer (set it freely)*/
-#endif
-
-    /*Attributes and states*/
-    uint8_t click_en     :1;    /*1: Can be pressed by a display input device*/
-    uint8_t drag_en      :1;    /*1: Enable the dragging*/
-    uint8_t drag_throw_en:1;    /*1: Enable throwing with drag*/
-    uint8_t drag_parent  :1;    /*1: Parent will be dragged instead*/
-    uint8_t hidden       :1;    /*1: Object is hidden*/
-    uint8_t top_en       :1;    /*1: If the object or its children is clicked it goes to the foreground*/
-    uint8_t reserved     :1;
-
-    uint8_t protect;            /*Automatically happening actions can be prevented. 'OR'ed values from lv_obj_prot_t*/
-
-    cord_t ext_size;			/*EXTtend the size of the object in every direction. E.g. for shadow drawing*/
-
-#if LV_OBJ_FREE_NUM != 0
-    uint8_t free_num; 		    /*Application specific identifier (set it freely)*/
-#endif
-}lv_obj_t;
-
-/*Protect some attributes (max. 8 bit)*/
-typedef enum
-{
-    LV_PROTECT_NONE      = 0x00,
-    LV_PROTECT_CHILD_CHG = 0x01, /*Disable the child change signal. Used by the library*/
-    LV_PROTECT_PARENT    = 0x02, /*Prevent automatic parent change (e.g. in lv_page)*/
-    LV_PROTECT_POS       = 0x04, /*Prevent automatic positioning (e.g. in lv_rect layout)*/
-}lv_protect_t;
-
-typedef enum
-{
-    LV_ALIGN_CENTER = 0,
-    LV_ALIGN_IN_TOP_LEFT,
-    LV_ALIGN_IN_TOP_MID,
-    LV_ALIGN_IN_TOP_RIGHT,
-    LV_ALIGN_IN_BOTTOM_LEFT,
-    LV_ALIGN_IN_BOTTOM_MID,
-    LV_ALIGN_IN_BOTTOM_RIGHT,
-    LV_ALIGN_IN_LEFT_MID,
-    LV_ALIGN_IN_RIGHT_MID,
-    LV_ALIGN_OUT_TOP_LEFT,
-    LV_ALIGN_OUT_TOP_MID,
-    LV_ALIGN_OUT_TOP_RIGHT,
-    LV_ALIGN_OUT_BOTTOM_LEFT,
-    LV_ALIGN_OUT_BOTTOM_MID,
-    LV_ALIGN_OUT_BOTTOM_RIGHT,
-    LV_ALIGN_OUT_LEFT_TOP,
-    LV_ALIGN_OUT_LEFT_MID,
-    LV_ALIGN_OUT_LEFT_BOTTOM,
-    LV_ALIGN_OUT_RIGHT_TOP,
-    LV_ALIGN_OUT_RIGHT_MID,
-    LV_ALIGN_OUT_RIGHT_BOTTOM,
-}lv_align_t;
-
-
-typedef struct
-{
-	color_t color;
-    opa_t opa;
-}lv_objs_t;
-
-typedef enum
-{
-	LV_ANIM_NONE = 0,
-	LV_ANIM_FLOAT_TOP, 		/*Float from/to the top*/
-	LV_ANIM_FLOAT_LEFT,		/*Float from/to the left*/
-	LV_ANIM_FLOAT_BOTTOM,	/*Float from/to the bottom*/
-	LV_ANIM_FLOAT_RIGHT,	/*Float from/to the right*/
-	LV_ANIM_GROW_H,			/*Grow/shrink  horizontally*/
-	LV_ANIM_GROW_V,			/*Grow/shrink  vertically*/
-}lv_anim_builtin_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Init. the 'lv' library.
- */
-void lv_init(void);
-
-/**
- * Create a basic object
- * @param parent pointer to a parent object.
- *                  If NULL then a screen will be created
- * @param copy pointer to a base object, if not NULL then the new object will be copied from it
- * @return pointer to the new object
- */
-lv_obj_t * lv_obj_create(lv_obj_t * parent, lv_obj_t * copy);
-
-/**
- * Delete 'obj' and all of its children
- * @param obj pointer to an object to delete
- */
-void lv_obj_del(lv_obj_t * obj);
-
-/**
- * Signal function of the basic object
- * @param obj pointer to an object
- * @param sign signal type
- * @param param parameter for the signal (depends on signal type)
- * @return false: the object become invalid (e.g. deleted)
- */
-bool lv_obj_signal(lv_obj_t * obj, lv_signal_t sign, void * param);
-
-/**
- * Mark the object as invalid therefore its current position will be redrawn by 'lv_refr_task'
- * @param obj pointer to an object
- */
-void lv_obj_inv(lv_obj_t * obj);
-
-/**
- * Load a new screen
- * @param scr pointer to a screen
- */
-void lv_scr_load(lv_obj_t * scr);
-
-/**
- * Set a new parent for an object. Its relative position will be the same.
- * @param obj pointer to an object
- * @param parent pointer to the new parent object
- */
-void lv_obj_set_parent(lv_obj_t * obj, lv_obj_t * parent);
-
-/**
- * Set relative the position of an object (relative to the parent)
- * @param obj pointer to an object
- * @param x new distance from the left side of the parent
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_pos(lv_obj_t * obj, cord_t x, cord_t y);
-
-/**
- * Set relative the position of an object (relative to the parent).
- * The coordinates will be upscaled with LV_DOWNSCALE.
- * @param obj pointer to an object
- * @param x new distance from the left side of the parent. (will be multiplied with LV_DOWNSCALE)
- * @param y new distance from the top of the parent. (will be multiplied with LV_DOWNSCALE)
- */
-void lv_obj_set_pos_us(lv_obj_t * obj, cord_t x, cord_t y);
-
-/**
- * Set the x coordinate of a object
- * @param obj pointer to an object
- * @param x new distance from the left side from the parent
- */
-void lv_obj_set_x(lv_obj_t * obj, cord_t x);
-
-/**
- * Set the x coordinate of a object.
- * The coordinate will be upscaled with  LV_DOWNSCALE.
- * @param obj pointer to an object
- * @param x new distance from the left side from the parent. (will be multiplied with LV_DOWNSCALE)
- */
-void lv_obj_set_x_us(lv_obj_t * obj, cord_t x);
-
-/**
- * Set the y coordinate of a object
- * @param obj pointer to an object
- * @param y new distance from the top of the parent
- */
-void lv_obj_set_y(lv_obj_t * obj, cord_t y);
-
-/**
- * Set the y coordinate of a object.
- * The coordinate will be upscaled with LV_DOWNSCALE.
- * @param obj pointer to an object
- * @param y new distance from the top of the parent. (will be multiplied with LV_DOWNSCALE)
- */
-void lv_obj_set_y_us(lv_obj_t * obj, cord_t y);
-
-/**
- * Set the size of an object
- * @param obj pointer to an object
- * @param w new width
- * @param h new height
- */
-void lv_obj_set_size(lv_obj_t * obj, cord_t w, cord_t h);
-
-/**
- * Set the size of an object. The coordinates will be upscaled with  LV_DOWNSCALE.
- * @param obj pointer to an object
- * @param w new width (will be multiplied with LV_DOWNSCALE)
- * @param h new height (will be multiplied with LV_DOWNSCALE)
- */
-void lv_obj_set_size_us(lv_obj_t * obj, cord_t w, cord_t h);
-
-/**
- * Set the width of an object
- * @param obj pointer to an object
- * @param w new width
- */
-void lv_obj_set_width(lv_obj_t * obj, cord_t w);
-
-/**
- * Set the width of an object.  The width will be upscaled with  LV_DOWNSCALE
- * @param obj pointer to an object
- * @param w new width (will be multiplied with LV_DOWNSCALE)
- */
-void lv_obj_set_width_us(lv_obj_t * obj, cord_t w);
-
-/**
- * Set the height of an object
- * @param obj pointer to an object
- * @param h new height
- */
-void lv_obj_set_height(lv_obj_t * obj, cord_t h);
-
-/**
- * Set the height of an object.  The height will be upscaled with  LV_DOWNSCALE
- * @param obj pointer to an object
- * @param h new height (will be multiplied with LV_DOWNSCALE)
- */
-void lv_obj_set_height_us(lv_obj_t * obj, cord_t h);
-
-/**
- * Align an object to an other object.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_mod x coordinate shift after alignment
- * @param y_mod y coordinate shift after alignment
- */
-void lv_obj_align(lv_obj_t * obj,lv_obj_t * base, lv_align_t align, cord_t x_mod, cord_t y_mod);
-
-/**
- * Align an object to an other object. The coordinates will be upscaled with  LV_DOWNSCALE.
- * @param obj pointer to an object to align
- * @param base pointer to an object (if NULL the parent is used). 'obj' will be aligned to it.
- * @param align type of alignment (see 'lv_align_t' enum)
- * @param x_mod x coordinate shift after alignment (will be multiplied with LV_DOWNSCALE)
- * @param y_mod y coordinate shift after alignment (will be multiplied with LV_DOWNSCALE)
- */
-void lv_obj_align_us(lv_obj_t * obj,lv_obj_t * base, lv_align_t align, cord_t x_mod, cord_t y_mod);
-
-/**
- * Set the extended size of an object
- * @param obj pointer to an object
- * @param ext_size the extended size
- */
-void lv_obj_set_ext_size(lv_obj_t * obj, cord_t ext_size);
-
-/**
- * Set a new style for an object
- * @param obj pointer to an object
- * @param style_p pointer to the new style
- */
-void lv_obj_set_style(lv_obj_t * obj, lv_style_t * style);
-
-/**
- * Notify an object about its style is modified
- * @param obj pointer to an object
- */
-void lv_obj_refr_style(lv_obj_t * obj);
-
-/**
- * Notify all object if a style is modified
- * @param style pointer to a style. Only the objects with this style will be notified
- *               (NULL to notify all objects)
- */
-void lv_style_refr_objs(void * style);
-
-/**
- * Hide an object. It won't be visible and clickable.
- * @param obj pointer to an object
- * @param en true: hide the object
- */
-void lv_obj_set_hidden(lv_obj_t * obj, bool en);
-
-/**
- * Enable or disable the clicking of an object
- * @param obj pointer to an object
- * @param en true: make the object clickable
- */
-void lv_obj_set_click(lv_obj_t * obj, bool en);
-
-/**
- * Enable to bring this object to the foreground if it
- * or any of its children is clicked
- * @param obj pointer to an object
- * @param en true: enable the auto top feature
- */
-void lv_obj_set_top(lv_obj_t * obj, bool en);
-
-/**
- * Enable the dragging of an object
- * @param obj pointer to an object
- * @param en true: make the object dragable
- */
-void lv_obj_set_drag(lv_obj_t * obj, bool en);
-
-/**
- * Enable the throwing of an object after is is dragged
- * @param obj pointer to an object
- * @param en true: enable the drag throw
- */
-void lv_obj_set_drag_throw(lv_obj_t * obj, bool en);
-
-/**
- * Enable to use parent for drag related operations.
- * If trying to drag the object the parent will be moved instead
- * @param obj pointer to an object
- * @param en true: enable the 'drag parent' for the object
- */
-void lv_obj_set_drag_parent(lv_obj_t * obj, bool en);
-
-/**
- * Set a bit or bits in the protect filed
- * @param obj pointer to an object
- * @param prot 'OR'-ed values from lv_obj_prot_t
- */
-void lv_obj_set_protect(lv_obj_t * obj, uint8_t prot);
-
-/**
- * Clear a bit or bits in the protect filed
- * @param obj pointer to an object
- * @param prot 'OR'-ed values from lv_obj_prot_t
- */
-void lv_obj_clr_protect(lv_obj_t * obj, uint8_t prot);
-
-/**
- * Set the signal function of an object.
- * Always call the previous signal function in the new.
- * @param obj pointer to an object
- * @param fp the new signal function
- */
-void lv_obj_set_signal_f(lv_obj_t * obj, lv_signal_f_t fp);
-
-/**
- * Set a new design function for an object
- * @param obj pointer to an object
- * @param fp the new design function
- */
-void lv_obj_set_design_f(lv_obj_t * obj, lv_design_f_t fp);
-
-/**
- * Allocate a new ext. data for an object
- * @param obj pointer to an object
- * @param ext_size the size of the new ext. data
- * @return Normal pointer to the allocated ext
- */
-void * lv_obj_alloc_ext(lv_obj_t * obj, uint16_t ext_size);
-
-/**
- * Send a 'LV_SIGNAL_REFR_EXT_SIZE' signal to the object
- * @param obj pointer to an object
- */
-void lv_obj_refr_ext_size(lv_obj_t * obj);
-
-#if LV_OBJ_FREE_NUM != 0
-/**
- * Set an application specific number for an object.
- * It can help to identify objects in the application.
- * @param obj pointer to an object
- * @param free_num the new free number
- */
-void lv_obj_set_free_num(lv_obj_t * obj, uint8_t free_num);
-#endif
-
-#if LV_OBJ_FREE_P != 0
-/**
- * Set an application specific  pointer for an object.
- * It can help to identify objects in the application.
- * @param obj pointer to an object
- * @param free_p the new free pinter
- */
-void lv_obj_set_free_p(lv_obj_t * obj, void * free_p);
-#endif
-/**
- * Animate an object
- * @param obj pointer to an object to animate
- * @param type type of animation from 'lv_anim_builtin_t'. 'OR' it with ANIM_IN or ANIM_OUT
- * @param time time of animation in milliseconds
- * @param delay delay before the animation in milliseconds
- * @param cb a function to call when the animation is ready
- */
-void lv_obj_anim(lv_obj_t * obj, lv_anim_builtin_t type, uint16_t time, uint16_t delay, void (*cb) (lv_obj_t *));
-
-/**
- * Return with the actual screen
- * @return pointer to to the actual screen object
- */
-lv_obj_t * lv_scr_act(void);
-
-/**
- * Return with the screen of an object
- * @param obj pointer to an object
- * @return pointer to a screen
- */
-lv_obj_t * lv_obj_get_scr(lv_obj_t * obj);
-
-/**
- * Returns with the parent of an object
- * @param obj pointer to an object
- * @return pointer to the parent of  'obj'
- */
-lv_obj_t * lv_obj_get_parent(lv_obj_t * obj);
-
-/**
- * Iterate through the children of an object
- * @param obj pointer to an object
- * @param child NULL at first call to get the next children
- *                  and the previous return value later
- * @return the child after 'act_child' or NULL if no more child
- */
-lv_obj_t * lv_obj_get_child(lv_obj_t * obj, lv_obj_t * child);
-
-/**
- * Count the children of an object (only children directly on 'obj')
- * @param obj pointer to an object
- * @return children number of 'obj'
- */
-uint16_t lv_obj_get_child_num(lv_obj_t * obj);
-
-/**
- * Copy the coordinates of an object to an area
- * @param obj pointer to an object
- * @param cords_p pointer to an area to store the coordinates
- */
-void lv_obj_get_cords(lv_obj_t * obj, area_t * cords_p);
-
-/**
- * Get the x coordinate of object
- * @param obj pointer to an object
- * @return distance of 'obj' from the left side of its parent
- */
-cord_t lv_obj_get_x(lv_obj_t * obj);
-
-/**
- * Get the y coordinate of object
- * @param obj pointer to an object
- * @return distance of 'obj' from the top of its parent
- */
-cord_t lv_obj_get_y(lv_obj_t * obj);
-
-/**
- * Get the width of an object
- * @param obj pointer to an object
- * @return the width
- */
-cord_t lv_obj_get_width(lv_obj_t * obj);
-
-/**
- * Get the height of an object
- * @param obj pointer to an object
- * @return the height
- */
-cord_t lv_obj_get_height(lv_obj_t * obj);
-
-/**
- * Get the extended size attribute of an object
- * @param obj pointer to an object
- * @return the extended size attribute
- */
-cord_t lv_obj_get_ext_size(lv_obj_t * obj);
-
-/**
- * Get the style pointer of an object (if NULL get style of the parent)
- * @param obj pointer to an object
- * @return pointer to a style
- */
-lv_style_t * lv_obj_get_style(lv_obj_t * obj);
-
-/**
- * Get the hidden attribute of an object
- * @param obj pointer to an object
- * @return true: the object is hidden
- */
-bool lv_obj_get_hidden(lv_obj_t * obj);
-
-/**
- * Get the click enable attribute of an object
- * @param obj pointer to an object
- * @return true: the object is clickable
- */
-bool lv_obj_get_click(lv_obj_t * obj);
-
-/**
- * Get the top enable attribute of an object
- * @param obj pointer to an object
- * @return true: the auto top feture is enabled
- */
-bool lv_obj_get_top(lv_obj_t * obj);
-
-/**
- * Get the drag enable attribute of an object
- * @param obj pointer to an object
- * @return true: the object is dragable
- */
-bool lv_obj_get_drag(lv_obj_t * obj);
-
-/**
- * Get the drag thow enable attribute of an object
- * @param obj pointer to an object
- * @return true: drag throw is enabled
- */
-bool lv_obj_get_drag_throw(lv_obj_t * obj);
-
-/**
- * Get the drag parent attribute of an object
- * @param obj pointer to an object
- * @return true: drag parent is enabled
- */
-bool lv_obj_get_drag_parent(lv_obj_t * obj);
-
-/**
- * Get the protect field of an object
- * @param obj pointer to an object
- * @return protect field ('OR'ed values of lv_obj_prot_t)
- */
-uint8_t lv_obj_get_protect(lv_obj_t * obj);
-
-/**
- * Check at least one bit of a given protect bitfield is set
- * @param obj pointer to an object
- * @param prot protect bits to test ('OR'ed values of lv_obj_prot_t)
- * @return false: none of the given bits are set, true: at least one bit is set
- */
-bool lv_obj_is_protected(lv_obj_t * obj, uint8_t prot);
-
-/**
- * Get the signal function of an object
- * @param obj pointer to an object
- * @return the signal function
- */
-lv_signal_f_t   lv_obj_get_signal_f(lv_obj_t * obj);
-
-/**
- * Get the design function of an object
- * @param obj pointer to an object
- * @return the design function
- */
-lv_design_f_t lv_obj_get_design_f(lv_obj_t * obj);
-
-/**
- * Get the ext pointer
- * @param obj pointer to an object
- * @return the ext pointer but not the dynamic version
- *         Use it as ext->data1, and NOT da(ext)->data1
- */
-void * lv_obj_get_ext(lv_obj_t * obj);
-
-#if LV_OBJ_FREE_NUM != 0
-/**
- * Get the free number
- * @param obj pointer to an object
- * @return the free number
- */
-uint8_t lv_obj_get_free_num(lv_obj_t * obj);
-#endif
-
-#if LV_OBJ_FREE_P != 0
-/**
- * Get the free pointer
- * @param obj pointer to an object
- * @return the free pointer
- */
-void * lv_obj_get_free_p(lv_obj_t * obj);
-#endif
-
-/**********************
- *      MACROS
- **********************/
-
-#endif

lv_obj/lv_refr.c

@@ -1,444 +0,0 @@
-/**
- * @file lv_refr.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include <stddef.h>
-#include "lv_conf.h"
-#include "misc/os/ptask.h"
-#include "misc/mem/fifo.h"
-#include "lv_refr.h"
-#include "lv_vdb.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-typedef struct
-{
-    area_t area;
-    uint8_t joined;
-}lv_join_t;
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void lv_refr_task(void * param);
-static void lv_refr_join_area(void);
-static void lv_refr_areas(void);
-#if LV_VDB_SIZE == 0
-static void lv_refr_area_no_vdb(const area_t * area_p);
-#else
-static void lv_refr_area_with_vdb(const area_t * area_p);
-static void lv_refr_area_part_vdb(const area_t * area_p);
-#endif
-static lv_obj_t * lv_refr_get_top_obj(const area_t * area_p, lv_obj_t * obj);
-static void lv_refr_make(lv_obj_t * top_p, const area_t * mask_p);
-static void lv_refr_obj(lv_obj_t * obj, const area_t * mask_ori_p);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_join_t inv_buf[LV_INV_FIFO_SIZE];
-static uint16_t inv_buf_p;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Initialize the screen refresh subsystem
- */
-void lv_refr_init(void)
-{    
-    inv_buf_p = 0;
-    memset(inv_buf, 0, sizeof(inv_buf));
-
-    ptask_t* task;
-    task = ptask_create(lv_refr_task, LV_REFR_PERIOD, PTASK_PRIO_MID, NULL);
-    dm_assert(task);
-    
-}
-
-/**
- * Invalidate an area
- * @param area_p pointer to area which should be invalidated
- */
-void lv_inv_area(const area_t * area_p)
-{
-    /*Clear the invalidate buffer if the parameter is NULL*/
-    if(area_p == NULL) {
-        inv_buf_p = 0;
-        return;
-    }
-    
-    area_t scr_area;
-    scr_area.x1 = 0;
-    scr_area.y1 = 0;
-    scr_area.x2 = LV_HOR_RES - 1;
-    scr_area.y2 = LV_VER_RES - 1;
-    
-    area_t com_area;    
-    bool suc;
-
-    suc = area_union(&com_area, area_p, &scr_area);
-
-    /*The area is truncated to the screen*/
-    if(suc != false)
-    {
-#if LV_DOWNSCALE == 2
-    	/*Rounding*/
-    	com_area.x1 = com_area.x1 & (~0x1);
-    	com_area.y1 = com_area.y1 & (~0x1);
-    	com_area.x2 = com_area.x2 | 0x1;
-    	com_area.y2 = com_area.y2 | 0x1;
-#endif
-
-    	/*Save only if this area is not in one of the saved areas*/
-    	uint16_t i;
-    	for(i = 0; i < inv_buf_p; i++) {
-    	    if(area_is_in(&com_area, &inv_buf[i].area) != false) return;
-    	}
-
-
-        /*Save the area*/
-    	if(inv_buf_p < LV_INV_FIFO_SIZE) {
-            area_cpy(&inv_buf[inv_buf_p].area,&com_area);
-    	} else {/*If no place for the area add the screen*/
-    	    inv_buf_p = 0;
-            area_cpy(&inv_buf[inv_buf_p].area,&scr_area);
-        }
-    	inv_buf_p ++;
-    }
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Called periodically to handle the refreshing
- * @param param unused
- */
-static void lv_refr_task(void * param)
-{
-    lv_refr_join_area();
-    
-    lv_refr_areas();
-
-    memset(inv_buf, 0, sizeof(inv_buf));
-    inv_buf_p = 0;
-}
-
-
-/**
- * Join the areas which has got common parts
- */
-static void lv_refr_join_area(void)
-{
-    uint32_t join_from;
-    uint32_t join_in;
-    area_t joined_area;
-    for(join_in = 0; join_in < inv_buf_p; join_in++) {
-        if(inv_buf[join_in].joined != 0) continue;
-        
-        /*Check all areas to join them in 'join_in'*/
-        for(join_from = 0; join_from < inv_buf_p; join_from++) {
-            /*Handle only unjoined areas and ignore itself*/
-            if(inv_buf[join_from].joined != 0 || join_in == join_from) {
-                continue;
-            }
-
-            /*Check if the areas are on each other*/
-            if(area_is_on(&inv_buf[join_in].area,
-                          &inv_buf[join_from].area) == false)
-            {
-                continue;
-            }
-            
-            area_join(&joined_area, &inv_buf[join_in].area,
-                                    &inv_buf[join_from].area);
-
-            /*Join two area only if the joined area size is smaller*/
-            if(area_get_size(&joined_area) < 
-             (area_get_size(&inv_buf[join_in].area) + area_get_size(&inv_buf[join_from].area))) {
-                area_cpy(&inv_buf[join_in].area, &joined_area);
-
-                /*Mark 'join_form' is joined into 'join_in'*/
-                inv_buf[join_from].joined = 1;
-            }
-        }   
-    }
-}
-
-/**
- * Refresh the joined areas
- */
-static void lv_refr_areas(void)
-{
-    uint32_t i;
-    
-    for(i = 0; i < inv_buf_p; i++) {
-        /*Refresh the unjoined areas*/
-        if(inv_buf[i].joined == 0) {
-            /*If there is no VDB do simple drawing*/
-#if LV_VDB_SIZE == 0
-            lv_refr_area_no_vdb(&inv_buf[i].area);
-#else
-            /*If VDB is used...*/
-            lv_refr_area_with_vdb(&inv_buf[i].area);
-#endif
-            
-        }
-    }
-}
-
-#if LV_VDB_SIZE == 0
-/**
- * Refresh an area if there is no Virtual Display Buffer
- * @param area_p pointer to an area to refresh
- */
-static void lv_refr_area_no_vdb(const area_t * area_p)
-{
-    lv_obj_t * top_p;
-    
-    /*Get top object which is not covered by others*/    
-    top_p = lv_refr_get_top_obj(area_p, lv_scr_act());
-    
-    /*Do the refreshing*/
-    lv_refr_make(top_p, area_p);
-}
-
-#else
-
-/**
- * Refresh an area if there is Virtual Display Buffer
- * @param area_p  pointer to an area to refresh
- */
-static void lv_refr_area_with_vdb(const area_t * area_p)
-{
-    lv_vdb_t * vdb_p = lv_vdb_get();
-    
-    /*Always use the full row*/
-    vdb_p->area.x1 = area_p->x1;
-    vdb_p->area.y1 = area_p->y1;
-    vdb_p->area.x2 = area_p->x2;
-
-    /*Calculate the max row num*/
-    uint32_t max_row = (uint32_t) LV_VDB_SIZE / (vdb_p->area.x2 - vdb_p->area.x1 + 1);
-    if(max_row > area_get_height(area_p)) max_row = area_get_height(area_p);
-    
-    /*Round the row number with downscale*/
-#if LV_DOWNSCALE == 2
-    max_row &= (~0x1);
-#endif
-
-    /*Refresh all rows*/
-    cord_t row = area_p->y1;
-
-    for(row = area_p->y1; row  + max_row - 1 <= area_p->y2; row += max_row)  {
-        /*Calc. the next y coordinates of VDB*/
-        vdb_p->area.y1 = row;
-        vdb_p->area.y2 = row + max_row - 1;
-
-        lv_refr_area_part_vdb(area_p);
-    }
-    
-    /*If the last y coordinates are not handled yet ...*/
-    if(area_p->y2 != vdb_p->area.y2) {
-        /*Calc. the next y coordinates of VDB*/
-        vdb_p->area.y1 = row;
-        vdb_p->area.y2 = area_p->y2;
-
-        /*Refresh this part too*/
-        lv_refr_area_part_vdb(area_p);
-    }
-}
-
-/**
- * Refresh a part of an area which is on the actual Virtual Display Buffer
- * @param area_p pointer to an area to refresh
- */
-static void lv_refr_area_part_vdb(const area_t * area_p)
-{
-    lv_vdb_t * vdb_p = lv_vdb_get();
-    lv_obj_t * top_p;
-
-    /*Get the new mask from the original area and the act. VDB
-     It will be a part of 'area_p'*/
-    area_t start_mask;
-    area_union(&start_mask, area_p, &vdb_p->area);
-
-    /*Get the most top object which is not covered by others*/
-    top_p = lv_refr_get_top_obj(&start_mask, lv_scr_act());
-
-    /*Do the refreshing from the top object*/
-    lv_refr_make(top_p, &start_mask);
-            
-    /*Flush the content of the VDB*/ 
-    lv_vdb_flush();
-}
-
-#endif /*LV_VDB_SIZE == 0*/
-
-/**
- * Search the most top object which fully covers an area
- * @param area_p pointer to an area
- * @param obj the first object to start the searching (typically a screen)
- * @return 
- */
-static lv_obj_t * lv_refr_get_top_obj(const area_t * area_p, lv_obj_t * obj)
-{
-    lv_obj_t * i;
-    lv_obj_t * found_p = NULL;
-    
-    /*If this object is fully cover the draw area check the children too */
-    if(area_is_in(area_p, &obj->cords) && obj->hidden == 0)
-    {
-        LL_READ(obj->child_ll, i)        {
-            found_p = lv_refr_get_top_obj(area_p, i);
-            
-            /*If a children is ok then break*/
-            if(found_p != NULL) {
-                break;
-            }
-        }
-        
-        /*If no better children check this object*/
-        if(found_p == NULL) {
-            lv_style_t * style = lv_obj_get_style(obj);
-            if(style->opa == OPA_COVER &&
-               obj->design_f(obj, area_p, LV_DESIGN_COVER_CHK) != false) {
-                found_p = obj;
-            }
-        }
-    }
-    
-    return found_p;
-}
-
-/**
- * Make the refreshing from an object. Draw all its children and the yungers too. 
- * @param top_p pointer to an objects. Start the drawing from it.
- * @param mask_p pointer to an area, the objects will be drawn only here
- */
-static void lv_refr_make(lv_obj_t * top_p, const area_t * mask_p)
-{
-    /* Normally always will be a top_obj (at least the screen)
-     * 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_scr_act();
-    
-    /*Refresh the top object and its children*/
-    lv_refr_obj(top_p, mask_p);
-    
-    /*Draw the 'younger' sibling objects because they can be on top_obj */
-    lv_obj_t * par;
-    lv_obj_t * i;
-    lv_obj_t * border_p = top_p;
-
-    par = lv_obj_get_parent(top_p);
-
-    /*Do until not reach the screen*/
-    while(par != NULL) {
-        /*object before border_p has to be redrawn*/
-        i = ll_get_prev(&(par->child_ll), border_p);
-
-        while(i != NULL) { 
-            /*Refresh the objects*/
-            lv_refr_obj(i, mask_p);
-            i = ll_get_prev(&(par->child_ll), i);
-        }  
-        
-        /*The new border will be there last parents,
-         *so the 'younger' brothers of parent will be refreshed*/
-        border_p = par;
-        /*Go a level deeper*/
-        par = lv_obj_get_parent(par);
-    }
-
-    /*Call the post draw design function of the parents of the to object*/
-    par = lv_obj_get_parent(top_p);
-    while(par != NULL) {
-        par->design_f(par, mask_p, LV_DESIGN_DRAW_POST);
-        par = lv_obj_get_parent(par);
-    }
-}
-
-/**
- * Refresh an object an all of its children. (Called recursively)
- * @param obj pointer to an object to refresh
- * @param mask_ori_p pointer to an area, the objects will be drawn only here
- */
-static void lv_refr_obj(lv_obj_t * obj, const area_t * mask_ori_p)
-{
-    /*Do not refresh hidden objects*/
-    if(obj->hidden != 0) return;
-    
-    bool union_ok;  /* Store the return value of area_union */
-    /* Truncate the original mask to the coordinates of the parent
-     * because the parent and its children are visible only here */
-    area_t obj_mask;
-    area_t obj_ext_mask;
-    area_t obj_area;
-    cord_t ext_size = obj->ext_size;
-    lv_obj_get_cords(obj, &obj_area);
-    obj_area.x1 -= ext_size;
-    obj_area.y1 -= ext_size;
-    obj_area.x2 += ext_size;
-    obj_area.y2 += ext_size;
-    union_ok = area_union(&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 */
-        lv_style_t * style = lv_obj_get_style(obj);
-        if(style->opa != OPA_TRANSP) {
-            obj->design_f(obj, &obj_ext_mask, LV_DESIGN_DRAW_MAIN);
-            //tick_wait_ms(100);  /*DEBUG: Wait after every object draw to see the order of drawing*/
-        }
-
-        /*Create a new 'obj_mask' without 'ext_size' because the children can't be visible there*/
-        lv_obj_get_cords(obj, &obj_area);
-        union_ok = area_union(&obj_mask, mask_ori_p, &obj_area);
-        if(union_ok != false) {
-			area_t mask_child; /*Mask from obj and its child*/
-			lv_obj_t * child_p;
-			area_t child_area;
-			LL_READ_BACK(obj->child_ll, child_p)
-			{
-				lv_obj_get_cords(child_p, &child_area);
-				ext_size = child_p->ext_size;
-				child_area.x1 -= ext_size;
-				child_area.y1 -= ext_size;
-				child_area.x2 += ext_size;
-				child_area.y2 += ext_size;
-				/* Get the union (common parts) of original mask (from obj)
-				 * and its child */
-				union_ok = area_union(&mask_child, &obj_mask, &child_area);
-
-				/*If the parent and the child has common area then refresh the child */
-				if(union_ok) {
-					/*Refresh the next children*/
-					lv_refr_obj(child_p, &mask_child);
-				}
-			}
-        }
-
-        /* If all the children are redrawn make 'post draw' design */
-        if(style->opa != OPA_TRANSP) {
-		  obj->design_f(obj, &obj_ext_mask, LV_DESIGN_DRAW_POST);
-		}
-    }
-}

lv_obj/lv_style.c

@@ -1,233 +0,0 @@
-/**
- * @file lv_style.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#include "lv_style.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-static lv_style_t lv_style_scr;
-static lv_style_t lv_style_transp;
-static lv_style_t lv_style_transp_tight;
-static lv_style_t lv_style_plain;
-static lv_style_t lv_style_plain_color;
-static lv_style_t lv_style_pretty;
-static lv_style_t lv_style_pretty_color;
-static lv_style_t lv_style_btn_rel;
-static lv_style_t lv_style_btn_pr;
-static lv_style_t lv_style_btn_trel;
-static lv_style_t lv_style_btn_tpr;
-static lv_style_t lv_style_btn_ina;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- *  Init the basic styles
- */
-void lv_style_init (void)
-{
-    /* Not White/Black/Gray colors are created by HSV model with
-     * HUE = 210*/
-
-    /*Screen style*/
-    lv_style_scr.ccolor = COLOR_MAKE(0x20, 0x20, 0x20);
-    lv_style_scr.opa = OPA_COVER;
-
-    lv_style_scr.mcolor = COLOR_MAKE(0xc9, 0xdb, 0xee);
-    lv_style_scr.gcolor = COLOR_MAKE(0x4d, 0x91, 0xd5);
-    lv_style_scr.bcolor = COLOR_BLACK;
-    lv_style_scr.scolor = COLOR_GRAY;
-    lv_style_scr.radius = 0;
-    lv_style_scr.bwidth = 0;
-    lv_style_scr.swidth = 0;
-    lv_style_scr.stype = LV_STYPE_FULL;
-    lv_style_scr.vpad = LV_DPI / 12;
-    lv_style_scr.hpad = LV_DPI / 12;
-    lv_style_scr.opad = LV_DPI / 12;
-    lv_style_scr.bopa = OPA_COVER;
-    lv_style_scr.empty = 0;
-    lv_style_scr.glass = 0;
-
-    lv_style_scr.font = font_get(FONT_DEFAULT);
-    lv_style_scr.letter_space = 1 * LV_DOWNSCALE;
-    lv_style_scr.line_space = 3 * LV_DOWNSCALE;
-    lv_style_scr.txt_align = LV_TXT_ALIGN_LEFT;
-    lv_style_scr.img_recolor = OPA_TRANSP;
-    lv_style_scr.line_width = 1 * LV_DOWNSCALE;
-
-    /*Plain style (by default near the same as the screen style)*/
-    memcpy(&lv_style_plain, &lv_style_scr, sizeof(lv_style_t));
-    lv_style_plain.mcolor = COLOR_WHITE;
-    lv_style_plain.gcolor = COLOR_WHITE;
-    lv_style_plain.bcolor = COLOR_WHITE;
-
-    /*Plain color style*/
-    memcpy(&lv_style_plain_color, &lv_style_plain, sizeof(lv_style_t));
-    lv_style_plain_color.ccolor = COLOR_MAKE(0xf0, 0xf0, 0xf0);
-    lv_style_plain_color.mcolor = COLOR_MAKE(0x55, 0x96, 0xd8);
-    lv_style_plain_color.gcolor = lv_style_plain_color.mcolor;
-
-    /*Pretty style */
-    memcpy(&lv_style_pretty, &lv_style_plain, sizeof(lv_style_t));
-    lv_style_pretty.ccolor = COLOR_MAKE(0x20, 0x20, 0x20);
-    lv_style_pretty.mcolor = COLOR_WHITE;
-    lv_style_pretty.gcolor = COLOR_SILVER;
-    lv_style_pretty.bcolor = COLOR_MAKE(0x40, 0x40, 0x40);
-    lv_style_pretty.radius = LV_DPI / 15;
-    lv_style_pretty.bwidth = LV_DPI / 50 >= 1 ? LV_DPI / 50  : 1;
-    lv_style_pretty.bopa = OPA_50;
-
-    /*Pretty color style*/
-    memcpy(&lv_style_pretty_color, &lv_style_pretty, sizeof(lv_style_t));
-    lv_style_pretty_color.ccolor = COLOR_MAKE(0xe0, 0xe0, 0xe0);
-    lv_style_pretty_color.mcolor = COLOR_MAKE(0x6b, 0x9a, 0xc7);
-    lv_style_pretty_color.gcolor = COLOR_MAKE(0x2b, 0x59, 0x8b);
-    lv_style_pretty_color.bcolor = COLOR_MAKE(0x15, 0x2c, 0x42);
-
-    /*Transparent style*/
-    memcpy(&lv_style_transp, &lv_style_plain, sizeof(lv_style_t));
-    lv_style_transp.empty = 1;
-    lv_style_transp.bwidth = 0;
-    lv_style_transp.glass = 1;
-
-    /*Transparent tight style*/
-    memcpy(&lv_style_transp_tight, &lv_style_transp, sizeof(lv_style_t));
-    lv_style_transp_tight.hpad = 0;
-    lv_style_transp_tight.vpad = 0;
-
-    /*Button released style*/
-    memcpy(&lv_style_btn_rel, &lv_style_plain, sizeof(lv_style_t));
-    lv_style_btn_rel.mcolor = COLOR_MAKE(0x76, 0xa2, 0xd0);
-    lv_style_btn_rel.gcolor = COLOR_MAKE(0x19, 0x3a, 0x5d);
-    lv_style_btn_rel.bcolor = COLOR_MAKE(0x0b, 0x19, 0x28);
-    lv_style_btn_rel.ccolor = COLOR_MAKE(0xff, 0xff, 0xff);
-    lv_style_btn_rel.bwidth = LV_DPI / 50 >= 1 ? LV_DPI / 50  : 1;
-    lv_style_btn_rel.radius = LV_DPI / 15;
-    lv_style_btn_rel.bopa = OPA_70;
-    lv_style_btn_rel.scolor = COLOR_GRAY;
-    lv_style_btn_rel.swidth = 0;
-    lv_style_btn_rel.hpad = LV_DPI / 4;
-    lv_style_btn_rel.vpad = LV_DPI / 6;
-    lv_style_btn_rel.opad = LV_DPI / 10;
-
-    /*Button pressed style*/
-    memcpy(&lv_style_btn_pr, &lv_style_btn_rel, sizeof(lv_style_t));
-    lv_style_btn_pr.mcolor = COLOR_MAKE(0x33, 0x62, 0x94);
-    lv_style_btn_pr.gcolor = COLOR_MAKE(0x10, 0x26, 0x3c);
-    lv_style_btn_pr.ccolor = COLOR_MAKE(0xa4, 0xb5, 0xc6);
-
-    /*Button toggle released style*/
-    memcpy(&lv_style_btn_trel, &lv_style_btn_rel, sizeof(lv_style_t));
-    lv_style_btn_trel.mcolor = COLOR_MAKE(0x0a, 0x11, 0x22);
-    lv_style_btn_trel.gcolor = COLOR_MAKE(0x37, 0x62, 0x90);
-    lv_style_btn_trel.bcolor = COLOR_MAKE(0x01, 0x07, 0x0d);
-    lv_style_btn_trel.ccolor = COLOR_MAKE(0xc8, 0xdd, 0xf4);
-
-    /*Button toggle pressed style*/
-    memcpy(&lv_style_btn_tpr, &lv_style_btn_rel, sizeof(lv_style_t));
-    lv_style_btn_tpr.mcolor = COLOR_MAKE(0x02, 0x14, 0x27);
-    lv_style_btn_tpr.gcolor = COLOR_MAKE(0x2b, 0x4c, 0x70);
-    lv_style_btn_tpr.ccolor = COLOR_MAKE(0xa4, 0xb5, 0xc6);
-
-    /*Button inactive style*/
-    memcpy(&lv_style_btn_ina, &lv_style_btn_rel, sizeof(lv_style_t));
-    lv_style_btn_ina.mcolor = COLOR_MAKE(0xd8, 0xd8, 0xd8);
-    lv_style_btn_ina.gcolor = COLOR_MAKE(0xd8, 0xd8, 0xd8);
-    lv_style_btn_ina.bcolor = COLOR_MAKE(0x90, 0x90, 0x90);
-    lv_style_btn_ina.ccolor = COLOR_MAKE(0x70, 0x70, 0x70);
-}
-
-
-/**
- * Get style from its name
- * @param style_name an element of the 'lv_style_name_t' enum
- * @return pointer to the requested style (lv_style_def by default)
- */
-lv_style_t * lv_style_get(lv_style_name_t style_name, lv_style_t * copy)
-{
-    lv_style_t * style = &lv_style_plain;
-
-    switch(style_name) {
-        case LV_STYLE_SCR:
-            style = &lv_style_scr;
-            break;
-        case LV_STYLE_PLAIN:
-            style = &lv_style_plain;
-            break;
-        case LV_STYLE_PLAIN_COLOR:
-            style = &lv_style_plain_color;
-            break;
-        case LV_STYLE_PRETTY:
-            style = &lv_style_pretty;
-            break;
-        case LV_STYLE_PRETTY_COLOR:
-            style = &lv_style_pretty_color;
-            break;
-        case LV_STYLE_TRANSP:
-            style = &lv_style_transp;
-            break;
-        case LV_STYLE_TRANSP_TIGHT:
-            style = &lv_style_transp_tight;
-            break;
-        case LV_STYLE_BTN_REL:
-            style = &lv_style_btn_rel;
-            break;
-        case LV_STYLE_BTN_PR:
-            style = &lv_style_btn_pr;
-            break;
-        case LV_STYLE_BTN_TREL:
-            style = &lv_style_btn_trel;
-            break;
-        case LV_STYLE_BTN_TPR:
-            style = &lv_style_btn_tpr;
-            break;
-        case LV_STYLE_BTN_INA:
-            style = &lv_style_btn_ina;
-            break;
-        default:
-            style =  &lv_style_plain;
-    }
-
-    if(copy != NULL) memcpy(copy, style, sizeof(lv_style_t));
-
-    return style;
-}
-
-/**
- * Copy a style to an other
- * @param dest pointer to the destination style
- * @param src pointer to the source style
- */
-void lv_style_cpy(lv_style_t * dest, const lv_style_t * src)
-{
-    memcpy(dest, src, sizeof(lv_style_t));
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/

lv_obj/lv_style.h

@@ -1,105 +0,0 @@
-/**
- * @file lv_style.h
- *
- */
-
-#ifndef LV_STYLE_H
-#define LV_STYLE_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include <stdbool.h>
-#include "misc/gfx/color.h"
-#include "misc/gfx/area.h"
-#include "misc/gfx/font.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_RADIUS_CIRCLE      (CORD_MAX)    /*A very big radius to always draw as circle*/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-typedef enum {
-    LV_TXT_ALIGN_LEFT = 0,
-    LV_TXT_ALIGN_MID,
-}lv_txt_align_t;
-
-
-/*Shadow types*/
-typedef enum
-{
-    LV_STYPE_BOTTOM = 0,
-    LV_STYPE_FULL,
-}lv_stype_t;
-
-typedef struct
-{
-    /*Object level styles*/
-    color_t ccolor;     /*Content color (e.g. text or image re-color )*/
-    opa_t opa;          /*Opacity of the object*/
-    uint8_t glass :1;   /*1: Do not inherit this style*/
-    uint8_t empty :1;   /*Transparent background (border drawn)*/
-    uint8_t stype :2;   /*Shadow type from 'lv_shadow_type_t'*/
-    uint8_t txt_align:2;
-    color_t mcolor;     /*Main color of background*/
-    color_t gcolor;     /*Gradient color of background*/
-    color_t bcolor;     /*Border color of background*/
-    color_t scolor;     /*Shadow color of background*/
-    cord_t radius;      /*Corner radius of background*/
-    cord_t bwidth;      /*Width of the background border*/
-    cord_t swidth;      /*Width of the background shadow effect*/
-    cord_t vpad;        /*Vertical padding*/
-    cord_t hpad;        /*Horizontal padding*/
-    cord_t opad;        /*Object padding on the background*/
-    opa_t bopa;         /*Opacity of background border*/
-    const font_t * font;
-    cord_t letter_space;
-    cord_t line_space;
-    opa_t img_recolor;
-    cord_t line_width;
-}lv_style_t;
-
-typedef enum {
-    LV_STYLE_SCR,
-    LV_STYLE_TRANSP,
-    LV_STYLE_TRANSP_TIGHT,
-    LV_STYLE_PLAIN,
-    LV_STYLE_PLAIN_COLOR,
-    LV_STYLE_PRETTY,
-    LV_STYLE_PRETTY_COLOR,
-    LV_STYLE_BTN_REL,
-    LV_STYLE_BTN_PR,
-    LV_STYLE_BTN_TREL,
-    LV_STYLE_BTN_TPR,
-    LV_STYLE_BTN_INA,
-}lv_style_name_t;
-
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- *  Init the basic styles
- */
-void lv_style_init (void);
-
-/**
- * Get style from its name
- * @param style_name an element of the 'lv_style_name_t' enum
- * @return pointer to the requested style (lv_style_def by default)
- */
-lv_style_t * lv_style_get(lv_style_name_t style_name, lv_style_t * copy);
-
-void lv_style_cpy(lv_style_t * dest, const lv_style_t * src);
-
-
-/**********************
- *      MACROS
- **********************/
-
-#endif

lv_obj/lv_vdb.c

@@ -1,114 +0,0 @@
-/**
- * @file lv_vdb.c
- * 
- */
-#include "lv_conf.h"
-#if LV_VDB_SIZE != 0
-
-#include "hal/disp/disp.h"
-#include <stddef.h>
-#include "lv_vdb.h"
-
-/*********************
- *      INCLUDES
- *********************/
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_vdb_t vdb;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Get the vdb variable
- * @return pointer to the vdb variable
- */
-lv_vdb_t * lv_vdb_get(void)
-{
-    return &vdb;
-}
-
-/**
- * Flush the content of the vdb
- */
-void lv_vdb_flush(void)
-{
-#if LV_ANTIALIAS == 0
-	disp_map(vdb.area.x1, vdb.area.y1, vdb.area.x2, vdb.area.y2, vdb.buf);
-#else
-	/* Get the average of 2x2 pixels and put the result back to the VDB
-	 * The reading goes much faster then the write back
-	 * so useful data won't be overwritten
-	 * Example:
-	 * -----------------------------
-	 * in1_buf  |2,2|6,8|      3,7
-	 * in2_buf  |4,4|7,7|      1,2
-	 *           ---------  ==>
-	 * in1_buf  |1,1|1,3|
-	 * in2_buf  |1,1|1,3|
-	 * */
-	cord_t x;
-	cord_t y;
-	cord_t w = area_get_width(&vdb.area);
-	color_t * in1_buf = vdb.buf;      /*Pointer to the first row*/
-    color_t * in2_buf = vdb.buf + w;  /*Pointer to the second row*/
-    color_t * out_buf = vdb.buf;      /*Store the result here*/
-	for(y = vdb.area.y1; y < vdb.area.y2; y += 2) {
-        for(x = vdb.area.x1; x < vdb.area.x2; x += 2) {
-        
-            /*If the pixels are the same do not calculate the average */
-            if(in1_buf->full == (in1_buf + 1)->full &&
-               in1_buf->full == in2_buf->full &&
-               in1_buf->full == (in2_buf + 1)->full) {
-                out_buf->full = in1_buf->full;
-            } else {
-                /*Get the average of 2x2 red*/
-                out_buf->red = (in1_buf->red + (in1_buf + 1)->red +
-                                in2_buf->red + (in2_buf+ 1)->red) >> 2;
-                /*Get the average of 2x2 green*/
-                out_buf->green = (in1_buf->green + (in1_buf + 1)->green +
-                                  in2_buf->green + (in2_buf + 1)->green) >> 2;
-                /*Get the average of 2x2 blue*/
-                out_buf->blue = (in1_buf->blue + (in1_buf + 1)->blue +
-                                 in2_buf->blue + (in2_buf + 1)->blue) >> 2;
-            }
-            
-			in1_buf += 2; /*Skip the next pixel because it is already used above*/
-            in2_buf += 2;
-			out_buf ++;
-		}
-		/*2 row is ready so go the next 2*/
-		in1_buf += w; /*Skip the next row because it is processed from in2_buf*/
-        in2_buf += w;
-	}
-
-	/* Now the full the VDB is filtered and the result is stored in the first quarter of it
-	 * Write out the filtered map to the display*/
-    disp_map(vdb.area.x1 >> 1, vdb.area.y1 >> 1, vdb.area.x2 >> 1, vdb.area.y2 >> 1, vdb.buf);
-#endif
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-#endif

lv_obj/lv_vdb.h

@@ -1,56 +0,0 @@
-/**
- * @file lv_vdb.h
- * 
- */
-
-#ifndef LV_VDB_H
-#define LV_VDB_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-
-#if LV_VDB_SIZE != 0
-
-#include "misc/gfx/color.h"
-#include "misc/gfx/area.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-typedef struct
-{
-    area_t area;
-    color_t buf[LV_VDB_SIZE];
-}lv_vdb_t;
-
-
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Get the vdb variable
- * @return pointer to the vdb variable
- */
-lv_vdb_t * lv_vdb_get(void);
-
-/**
- * Flush the content of the vdb
- */
-void lv_vdb_flush(void);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_bar.c

@@ -1,306 +0,0 @@
-
-
-/**
- * @file lv_bar.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_BAR != 0
-
-#include <lvgl/lv_objx/lv_bar.h>
-#include "../lv_draw/lv_draw.h"
-#include "misc/gfx/anim.h"
-#include <stdio.h>
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_bar_design(lv_obj_t * bar, const area_t * mask, lv_design_mode_t mode);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_f_t ancestor_design_f;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a bar objects
- * @param par pointer to an object, it will be the parent of the new bar
- * @param copy pointer to a bar object, if not NULL then the new object will be copied from it
- * @return pointer to the created bar
- */
-lv_obj_t * lv_bar_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor basic object*/
-    lv_obj_t * new_bar = lv_obj_create(par, copy);
-    dm_assert(new_bar);
-
-    /*Allocate the object type specific extended data*/
-    lv_bar_ext_t * ext = lv_obj_alloc_ext(new_bar, sizeof(lv_bar_ext_t));
-    dm_assert(ext);
-    ext->min_value = 0;
-    ext->max_value = 100;
-    ext->act_value = 0;
-    ext->style_indic = lv_style_get(LV_STYLE_PRETTY_COLOR, NULL);
-
-    /* Save the ancient design function.
-     * It will be used in the bar design function*/
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_f(new_bar);
-
-    lv_obj_set_signal_f(new_bar, lv_bar_signal);
-    lv_obj_set_design_f(new_bar, lv_bar_design);
-
-    /*Init the new  bar object*/
-    if(copy == NULL) {
-        lv_obj_set_click(new_bar, false);
-    	lv_obj_set_size(new_bar, LV_DPI * 2, LV_DPI / 3);
-        lv_obj_set_style(new_bar, lv_style_get(LV_STYLE_PRETTY, NULL));
-    	lv_bar_set_value(new_bar, ext->act_value);
-    } else {
-    	lv_bar_ext_t * ext_copy = lv_obj_get_ext(copy);
-		ext->min_value = ext_copy->min_value;
-		ext->max_value = ext_copy->max_value;
-		ext->act_value = ext_copy->act_value;
-        ext->style_indic = ext_copy->style_indic;
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_bar);
-
-        lv_bar_set_value(new_bar, ext->act_value);
-    }
-    return new_bar;
-}
-
-/**
- * Signal function of the bar
- * @param bar pointer to a bar object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_bar_signal(lv_obj_t * bar, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_obj_signal(bar, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-        if(sign == LV_SIGNAL_REFR_EXT_SIZE) {
-            lv_style_t * style_indic = lv_bar_get_style_indic(bar);
-            if(style_indic->swidth > bar->ext_size) bar->ext_size = style_indic->swidth;
-        }
-
-    }
-
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a new value on the bar
- * @param bar pointer to a bar object
- * @param value new value
- */
-void lv_bar_set_value(lv_obj_t * bar, int16_t value)
-{
-	lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-	ext->act_value = value > ext->max_value ? ext->max_value : value;
-    ext->act_value = ext->act_value < ext->min_value ? ext->min_value : ext->act_value;
-	lv_obj_inv(bar);
-}
-
-/**
- * Set a new value with animation on the bar
- * @param bar pointer to a bar object
- * @param value new value
- * @param anim_time animation time in milliseconds
- */
-void lv_bar_set_value_anim(lv_obj_t * bar, int16_t value, uint16_t anim_time)
-{
-
-    lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-    int16_t new_value;
-    new_value = value > ext->max_value ? ext->max_value : value;
-    new_value = new_value < ext->min_value ? ext->min_value : new_value;
-
-    anim_t a;
-    a.var = bar;
-    a.start = ext->act_value;
-    a.end = new_value;
-    a.fp = (anim_fp_t)lv_bar_set_value;
-    a.path = anim_get_path(ANIM_PATH_LIN);
-    a.end_cb = NULL;
-    a.act_time = 0;
-    a.time = anim_time;
-    a.playback = 0;
-    a.playback_pause = 0;
-    a.repeat = 0;
-    a.repeat_pause = 0;
-
-    anim_create(&a);
-
-}
-
-
-/**
- * Set minimum and the maximum values of a bar
- * @param bar pointer to he bar object
- * @param min minimum value
- * @param max maximum value
- */
-void lv_bar_set_range(lv_obj_t * bar, int16_t min, int16_t max)
-{
-	lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-	ext->max_value = max;
-	ext->max_value = max;
-	if(ext->act_value > max) {
-		ext->act_value = max;
-		lv_bar_set_value(bar, ext->act_value);
-	}
-	lv_obj_inv(bar);
-}
-
-/**
- * Set the style of bar indicator
- * @param bar pointer to a bar object
- * @param style pointer to a style
- */
-void lv_bar_set_style_indic(lv_obj_t * bar, lv_style_t * style)
-{
-    lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-
-    ext->style_indic = style;
-
-    bar->signal_f(bar, LV_SIGNAL_REFR_EXT_SIZE, NULL);
-
-    lv_obj_inv(bar);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the value of a bar
- * @param bar pointer to a bar object
- * @return the value of the bar
- */
-int16_t lv_bar_get_value(lv_obj_t * bar)
-{
-	lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-	return ext->act_value;
-}
-
-/**
- * Get the minimum value of a bar
- * @param bar pointer to a bar object
- * @return the minimum value of the bar
- */
-int16_t lv_bar_get_min_value(lv_obj_t * bar)
-{
-    lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-    return ext->min_value;
-}
-
-/**
- * Get the maximum value of a bar
- * @param bar pointer to a bar object
- * @return the maximum value of the bar
- */
-int16_t lv_bar_get_max_value(lv_obj_t * bar)
-{
-    lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-    return ext->max_value;
-}
-
-/**
- * Get the style of bar indicator
- * @param bar pointer to a bar object
- * @return pointer to the bar indicator style
- */
-lv_style_t * lv_bar_get_style_indic(lv_obj_t * bar)
-{
-    lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-
-    if(ext->style_indic == NULL) return lv_obj_get_style(bar);
-
-    return ext->style_indic;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the bars
- * @param bar pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_bar_design(lv_obj_t * bar, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	/*Return false if the object is not covers the mask area*/
-    	return  ancestor_design_f(bar, mask, mode);;
-    } else if(mode == LV_DESIGN_DRAW_MAIN) {
-        ancestor_design_f(bar, mask, mode);
-
-		lv_bar_ext_t * ext = lv_obj_get_ext(bar);
-
-        lv_style_t * style_indic = lv_bar_get_style_indic(bar);
-		area_t indic_area;
-		area_cpy(&indic_area, &bar->cords);
-		indic_area.x1 += style_indic->hpad;
-		indic_area.x2 -= style_indic->hpad;
-		indic_area.y1 += style_indic->vpad;
-		indic_area.y2 -= style_indic->vpad;
-
-		cord_t w = area_get_width(&indic_area);
-        cord_t h = area_get_height(&indic_area);
-
-		if(w >= h) {
-		    indic_area.x2 = (int32_t) ((int32_t)w * ext->act_value) / (ext->max_value - ext->min_value);
-            indic_area.x2 += indic_area.x1;
-		} else {
-		    indic_area.y1 = (int32_t) ((int32_t)h * ext->act_value) / (ext->max_value - ext->min_value);
-            indic_area.y1 = indic_area.y2 - indic_area.y1;
-		}
-
-		/*Draw the indicator*/
-        lv_draw_rect(&indic_area, mask, style_indic);
-    }
-    return true;
-}
-
-#endif

lv_objx/lv_bar.h

@@ -1,123 +0,0 @@
-/**
- * @file lv_bar.h
- * 
- */
-
-#ifndef LV_BAR_H
-#define LV_BAR_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_BAR != 0
-
-#include "../lv_obj/lv_obj.h"
-#include <lvgl/lv_objx/lv_cont.h>
-#include "lv_btn.h"
-#include "lv_label.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of bar*/
-typedef struct
-{
-    /*No inherited ext*/        /*Ext. of ancestor*/
-    /*New data for this type */
-    int16_t act_value;          /*Current value of the bar*/
-    int16_t min_value;          /*Minimum value of the bar*/
-    int16_t max_value;          /*Maximum value of the bar*/
-    lv_style_t * style_indic;   /*Style of the indicator*/
-}lv_bar_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a bar objects
- * @param par pointer to an object, it will be the parent of the new bar
- * @param copy pointer to a bar object, if not NULL then the new object will be copied from it
- * @return pointer to the created bar
- */
-lv_obj_t * lv_bar_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the bar
- * @param bar pointer to a bar object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_bar_signal(lv_obj_t * bar, lv_signal_t sign, void * param);
-
-/**
- * Set a new value on the bar
- * @param bar pointer to a bar object
- * @param value new value
- */
-void lv_bar_set_value(lv_obj_t * bar, int16_t value);
-
-/**
- * Set a new value with animation on the bar
- * @param bar pointer to a bar object
- * @param value new value
- * @param anim_time animation time in milliseconds
- */
-void lv_bar_set_value_anim(lv_obj_t * bar, int16_t value, uint16_t anim_time);
-
-/**
- * Set minimum and the maximum values of a bar
- * @param bar pointer to he bar object
- * @param min minimum value
- * @param max maximum value
- */
-void lv_bar_set_range(lv_obj_t * bar, int16_t min, int16_t max);
-
-/**
- * Set the style of bar indicator
- * @param bar pointer to a bar object
- * @param style pointer to a style
- */
-void lv_bar_set_style_indic(lv_obj_t * bar, lv_style_t * style);
-
-/**
- * Get the value of a bar
- * @param bar pointer to a bar object
- * @return the value of the bar
- */
-int16_t lv_bar_get_value(lv_obj_t * bar);
-
-/**
- * Get the minimum value of a bar
- * @param bar pointer to a bar object
- * @return the minimum value of the bar
- */
-int16_t lv_bar_get_min_value(lv_obj_t * bar);
-
-/**
- * Get the maximum value of a bar
- * @param bar pointer to a bar object
- * @return the maximum value of the bar
- */
-int16_t lv_bar_get_max_value(lv_obj_t * bar);
-
-/**
- * Get the style of bar indicator
- * @param bar pointer to a bar object
- * @return pointer to the bar indicator style
- */
-lv_style_t * lv_bar_get_style_indic(lv_obj_t * bar);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_btn.c

@@ -1,368 +0,0 @@
-/**
- * @file lv_btn.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-
-#include "lv_conf.h"
-#if USE_LV_BTN != 0
-
-#include "lvgl/lv_obj/lv_obj.h"
-#include "misc/gfx/area.h"
-#include "misc/gfx/color.h"
-#include "../lv_draw/lv_draw.h"
-#include "lv_btn.h"
-#include <stdbool.h>
-#include <string.h>
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-#if 0
-static bool lv_btn_design(lv_obj_t * btn, const area_t * mask, lv_design_mode_t mode);
-#endif
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a button objects
- * @param par pointer to an object, it will be the parent of the new button
- * @param copy pointer to a button object, if not NULL then the new object will be copied from it
- * @return pointer to the created button
- */
-lv_obj_t * lv_btn_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    lv_obj_t * new_btn;
-    
-    new_btn = lv_cont_create(par, copy);
-    dm_assert(new_btn);
-    /*Allocate the extended data*/
-    lv_btn_ext_t * ext = lv_obj_alloc_ext(new_btn, sizeof(lv_btn_ext_t));
-    dm_assert(ext);
-    ext->state = LV_BTN_STATE_REL;
-    ext->pr_action = NULL;
-    ext->rel_action = NULL;
-    ext->lpr_action = NULL;
-    ext->lpr_rep_action = NULL;
-    ext->styles[LV_BTN_STATE_REL] = lv_style_get(LV_STYLE_BTN_REL, NULL);
-    ext->styles[LV_BTN_STATE_PR] = lv_style_get(LV_STYLE_BTN_PR, NULL);
-    ext->styles[LV_BTN_STATE_TREL] = lv_style_get(LV_STYLE_BTN_TREL, NULL);
-    ext->styles[LV_BTN_STATE_TPR] = lv_style_get(LV_STYLE_BTN_TPR, NULL);
-    ext->styles[LV_BTN_STATE_INA] = lv_style_get(LV_STYLE_BTN_INA, NULL);
-    ext->lpr_exec = 0;
-    ext->tgl = 0;
-
-    lv_obj_set_signal_f(new_btn, lv_btn_signal);
-    
-    /*If no copy do the basic initialization*/
-    if(copy == NULL) {
-	    lv_cont_set_layout(new_btn, LV_CONT_LAYOUT_CENTER);
-	    lv_obj_set_style(new_btn, ext->styles[LV_BTN_STATE_REL]);
-    }
-    /*Copy 'copy'*/
-    else {
-    	lv_btn_ext_t * copy_ext = lv_obj_get_ext(copy);
-    	ext->state = copy_ext->state;
-    	ext->pr_action = copy_ext->pr_action;
-    	ext->rel_action = copy_ext->rel_action;
-    	ext->lpr_action = copy_ext->lpr_action;
-        ext->lpr_rep_action = copy_ext->lpr_action;
-        ext->styles[LV_BTN_STATE_REL] = copy_ext->styles[LV_BTN_STATE_REL];
-        ext->styles[LV_BTN_STATE_PR] = copy_ext->styles[LV_BTN_STATE_PR];
-        ext->styles[LV_BTN_STATE_TREL] = copy_ext->styles[LV_BTN_STATE_TREL];
-        ext->styles[LV_BTN_STATE_TPR] = copy_ext->styles[LV_BTN_STATE_TPR];
-        ext->styles[LV_BTN_STATE_INA] = copy_ext->styles[LV_BTN_STATE_INA];
-    	ext->tgl = copy_ext->tgl;
-
-    	/*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_btn);
-    }
-    
-    return new_btn;
-}
-
-/**
- * Signal function of the button
- * @param btn pointer to a button object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param)
-{   
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_cont_signal(btn, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-        lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-    	lv_btn_state_t state = lv_btn_get_state(btn);
-        bool tgl = lv_btn_get_tgl(btn);
-
-        if(sign == LV_SIGNAL_PRESSED) {
-            /*Refresh the state*/
-            if(ext->state == LV_BTN_STATE_REL) {
-                lv_btn_set_state(btn, LV_BTN_STATE_PR);
-            } else if(ext->state == LV_BTN_STATE_TREL) {
-                lv_btn_set_state(btn, LV_BTN_STATE_TPR);
-            }
-
-            ext->lpr_exec = 0;
-            /*Call the press action, 'param' is the caller dispi*/
-            if(ext->pr_action != NULL && state != LV_BTN_STATE_INA) {
-                valid = ext->pr_action(btn, param);
-            }
-        }
-        else if(sign ==  LV_SIGNAL_PRESS_LOST) {
-            /*Refresh the state*/
-            if(ext->state == LV_BTN_STATE_PR) lv_btn_set_state(btn, LV_BTN_STATE_REL);
-            else if(ext->state == LV_BTN_STATE_TPR) lv_btn_set_state(btn, LV_BTN_STATE_TREL);
-        }
-        else if(sign == LV_SIGNAL_PRESSING) {
-            /*When the button begins to drag revert pressed states to released*/
-            if(lv_dispi_is_dragging(param) != false) {
-                if(ext->state == LV_BTN_STATE_PR) lv_btn_set_state(btn, LV_BTN_STATE_REL);
-                else if(ext->state == LV_BTN_STATE_TPR) lv_btn_set_state(btn, LV_BTN_STATE_TREL);
-            }
-        }
-        else if(sign == LV_SIGNAL_RELEASED) {
-            /*If not dragged and it was not long press action then
-             *change state and run the action*/
-            if(lv_dispi_is_dragging(param) == false && ext->lpr_exec == 0) {
-                if(ext->state == LV_BTN_STATE_PR && tgl == false) {
-                    lv_btn_set_state(btn, LV_BTN_STATE_REL);
-                } else if(ext->state == LV_BTN_STATE_TPR && tgl == false) {
-                    lv_btn_set_state(btn, LV_BTN_STATE_TREL);
-                } else if(ext->state == LV_BTN_STATE_PR && tgl == true) {
-                    lv_btn_set_state(btn, LV_BTN_STATE_TREL);
-                } else if(ext->state == LV_BTN_STATE_TPR && tgl == true) {
-                    lv_btn_set_state(btn, LV_BTN_STATE_REL);
-                }
-
-                if(ext->rel_action != NULL && state != LV_BTN_STATE_INA) {
-                    valid = ext->rel_action(btn, param);
-                }
-            } else { /*If dragged change back the state*/
-                if(ext->state == LV_BTN_STATE_PR) {
-                    lv_btn_set_state(btn, LV_BTN_STATE_REL);
-                } else if(ext->state == LV_BTN_STATE_TPR) {
-                    lv_btn_set_state(btn, LV_BTN_STATE_TREL);
-                }
-            }
-        }
-        else if(sign == LV_SIGNAL_LONG_PRESS) {
-                /*Call the long press action, 'param' is the caller dispi*/
-                if(ext->lpr_action != NULL && state != LV_BTN_STATE_INA) {
-                	ext->lpr_exec = 1;
-                	valid = ext->lpr_action(btn, param);
-                }
-        }
-        else if(sign == LV_SIGNAL_LONG_PRESS_REP) {
-            /*Call the release action, 'param' is the caller dispi*/
-            if(ext->lpr_rep_action != NULL && state != LV_BTN_STATE_INA) {
-                valid = ext->lpr_rep_action(btn, param);
-            }
-        }
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions 
- *====================*/
-
-/**
- * Enable the toggled states
- * @param btn pointer to a button object
- * @param tgl true: enable toggled states, false: disable
- */
-void lv_btn_set_tgl(lv_obj_t * btn, bool tgl)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-    
-    ext->tgl = tgl != false ? 1 : 0;
-}
-
-/**
- * Set the state of the button
- * @param btn pointer to a button object
- * @param state the new state of the button (from lv_btn_state_t enum)
- */
-void lv_btn_set_state(lv_obj_t * btn, lv_btn_state_t state)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-    if(ext->state != state) {
-        ext->state = state;
-        lv_obj_set_style(btn, ext->styles[state]);
-    }
-}
-
-/**
- * Set a function to call when the button is pressed
- * @param btn pointer to a button object
- * @param pr_action pointer to function
- */
-void lv_btn_set_pr_action(lv_obj_t * btn, lv_action_t pr_action)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-    
-    ext->pr_action = pr_action;
-}
-
-/**
- * Set a function to call when the button is released
- * @param btn pointer to a button object
- * @param rel_action pointer to functionREL
- */
-void lv_btn_set_rel_action(lv_obj_t * btn, lv_action_t rel_action)
-{
-    lv_btn_ext_t * btn_p = lv_obj_get_ext(btn);
-    
-    btn_p->rel_action = rel_action;
-}
-
-/**
- * Set a function to call when the button is long pressed
- * @param btn pointer to a button object
- * @param lpr_action pointer to function
- */
-void lv_btn_set_lpr_action(lv_obj_t * btn, lv_action_t lpr_action)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-    
-    ext->lpr_action = lpr_action;
-}
-
-/**
- * Set a function to called periodically after long press.
- * @param btn pointer to a button object
- * @param lpr_rep_action pointer to function
- */
-void lv_btn_set_lpr_rep_action(lv_obj_t * btn, lv_action_t lpr_rep_action)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-
-    ext->lpr_rep_action = lpr_rep_action;
-}
-
-/**
- * Set styles of a button is each state
- * @param btn pointer to button object
- * @param rel pointer to a style for releases state
- * @param pr  pointer to a style for pressed state
- * @param trel pointer to a style for toggled releases state
- * @param tpr pointer to a style for toggled pressed state
- * @param ina pointer to a style for inactive state
- */
-void lv_btn_set_styles(lv_obj_t * btn, lv_style_t * rel, lv_style_t * pr,
-                                       lv_style_t * trel, lv_style_t * tpr,
-                                       lv_style_t * ina)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-    ext->styles[LV_BTN_STATE_REL] = rel;
-    ext->styles[LV_BTN_STATE_PR] = pr;
-    ext->styles[LV_BTN_STATE_TREL] = trel;
-    ext->styles[LV_BTN_STATE_TPR] = tpr;
-    ext->styles[LV_BTN_STATE_INA] = ina;
-
-    lv_obj_set_style(btn, ext->styles[ext->state]);
-
-}
-
-/*=====================
- * Getter functions 
- *====================*/
-
-/**
- * Get the current state of the button
- * @param btn pointer to a button object
- * @return the state of the button (from lv_btn_state_t enum)
- */
-lv_btn_state_t lv_btn_get_state(lv_obj_t * btn)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-    
-    return ext->state;
-}
-
-/**
- * Get the toggle enable attribute of the button
- * @param btn pointer to a button object
- * @return ture: toggle enabled, false: disabled
- */
-bool lv_btn_get_tgl(lv_obj_t * btn)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-    
-    return ext->tgl != 0 ? true : false;
-}
-
-/**
- * Get the style of a button in a given state
- * @param btn pointer to a button object
- * @param state a state from 'lv_btn_state_t' in which style should be get
- * @return pointer to the style in the given state
- */
-lv_style_t * lv_btn_get_style(lv_obj_t * btn, lv_btn_state_t state)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(btn);
-
-    if(ext->styles[state] == NULL) return lv_obj_get_style(btn->par);
-
-    return ext->styles[state];
-}
-
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-#if 0
-/**
- * Handle the drawing related tasks of the buttons
- * @param btn pointer to a button object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'        
- */
-static bool lv_btn_design(lv_obj_t * btn, const area_t * mask, lv_design_mode_t mode)
-{
-
-    /* Because of the radius it is not sure the area is covered*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-        return false;
-
-    } else if(mode == LV_DESIGN_DRAW_MAIN || mode == LV_DESIGN_DRAW_POST) {
-
-    }
-    return true;
-}
-#endif
-#endif

lv_objx/lv_btn.h

@@ -1,161 +0,0 @@
-/**
- * @file lv_btn.h
- * 
- */
-
-#ifndef LV_BTN_H
-#define LV_BTN_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_BTN != 0
-
-/*Testing of dependencies*/
-#if USE_LV_CONT == 0
-#error "lv_btn: lv_cont is required. Enable it in lv_conf.h (USE_LV_CONT  1) "
-#endif
-
-#include <lvgl/lv_objx/lv_cont.h>
-#include "../lv_obj/lv_dispi.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Button states*/
-typedef enum
-{
-    LV_BTN_STATE_REL,
-    LV_BTN_STATE_PR,
-    LV_BTN_STATE_TREL,
-    LV_BTN_STATE_TPR,
-    LV_BTN_STATE_INA,
-    LV_BTN_STATE_NUM,
-}lv_btn_state_t;
-
-/*Data of button*/
-typedef struct
-{
-	lv_cont_ext_t cont; /*Ext. of ancestor*/
-	/*New data for this type */
-	lv_action_t pr_action;      /*A function to call when the button is pressed (NULL if unused)*/
-	lv_action_t rel_action;     /*A function to call when the button is released (NULL if unused)*/
-	lv_action_t lpr_action;     /*A function to call when the button is long pressed (NULL if unused)*/
-	lv_action_t lpr_rep_action; /*A function to call periodically after long press (NULL if unused)*/
-
-	lv_style_t * styles[LV_BTN_STATE_NUM];    /*Styles in each state*/
-
-    lv_btn_state_t state;       /*Current state of the button from 'lv_btn_state_t' enum*/
-    uint8_t tgl :1;             /*1: Toggle enabled*/
-    uint8_t lpr_exec :1;        /*1: Long press action executed (Handled by the library)*/
-}lv_btn_ext_t;
-
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a button objects
- * @param par pointer to an object, it will be the parent of the new button
- * @param copy pointer to a button object, if not NULL then the new object will be copied from it
- * @return pointer to the created button
- */
-lv_obj_t * lv_btn_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the button
- * @param btn pointer to a button object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_btn_signal(lv_obj_t * btn, lv_signal_t sign, void * param);
-
-/**
- * Enable the toggled states
- * @param btn pointer to a button object
- * @param tgl true: enable toggled states, false: disable
- */
-void lv_btn_set_tgl(lv_obj_t * btn, bool tgl);
-
-/**
- * Set the state of the button
- * @param btn pointer to a button object
- * @param state the new state of the button (from lv_btn_state_t enum)
- */
-void lv_btn_set_state(lv_obj_t * btn, lv_btn_state_t state);
-
-/**
- * Set a function to call when the button is pressed
- * @param btn pointer to a button object
- * @param pr_action pointer to function
- */
-void lv_btn_set_pr_action(lv_obj_t * btn, lv_action_t pr_action);
-
-/**
- * Set a function to call when the button is released
- * @param btn pointer to a button object
- * @param rel_action pointer to functionREL
- */
-void lv_btn_set_rel_action(lv_obj_t * btn, lv_action_t rel_action);
-
-/**
- * Set a function to call when the button is long pressed
- * @param btn pointer to a button object
- * @param lpr_action pointer to function
- */
-void lv_btn_set_lpr_action(lv_obj_t * btn, lv_action_t lpr_action);
-
-/**
- * Set a function to called periodically after long press.
- * @param btn pointer to a button object
- * @param lpr_rep_action pointer to function
- */
-void lv_btn_set_lpr_rep_action(lv_obj_t * btn, lv_action_t lpr_rep_action);
-
-/**
- * Set styles of a button is each state
- * @param btn pointer to button object
- * @param rel pointer to a style for releases state
- * @param pr  pointer to a style for pressed state
- * @param trel pointer to a style for toggled releases state
- * @param tpr pointer to a style for toggled pressed state
- * @param ina pointer to a style for inactive state
- */
-void lv_btn_set_styles(lv_obj_t * btn, lv_style_t * rel, lv_style_t * pr, lv_style_t * trel, lv_style_t * tpr, lv_style_t * ina);
-
-/**
- * Get the current state of the button
- * @param btn pointer to a button object
- * @return the state of the button (from lv_btn_state_t enum)
- */
-lv_btn_state_t lv_btn_get_state(lv_obj_t * btn);
-
-/**
- * Get the toggle enable attribute of the button
- * @param btn pointer to a button object
- * @return ture: toggle enabled, false: disabled
- */
-bool lv_btn_get_tgl(lv_obj_t * btn);
-
-/**
- * Get the style of a button in a given state
- * @param btn pointer to a button object
- * @param state a state from 'lv_btn_state_t' in which style should be get
- * @return pointer to the style in the given state
- */
-lv_style_t * lv_btn_get_style(lv_obj_t * btn, lv_btn_state_t state);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_btnm.c

@@ -1,514 +0,0 @@
-/**
- * @file lv_btnm.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_BTNM != 0
-
-#include "lv_btnm.h"
-#include "misc/gfx/text.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_obj/lv_refr.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_BTNM_PR_NONE 0xFFFF
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_btnm_design(lv_obj_t * btnm, const area_t * mask, lv_design_mode_t mode);
-static uint8_t lv_btnm_get_width_unit(const char * btn_str);
-static uint16_t lv_btnm_get_btn_from_point(lv_obj_t * btnm, point_t * p);
-static void lv_btnm_create_btns(lv_obj_t * btnm, const char ** map);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static const char * lv_btnm_def_map[] = {"Btn1","Btn2", "Btn3","\n",
-										 "\002Btn4","Btn5", ""};
-
-static lv_design_f_t ancestor_design_f;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a button matrix objects
- * @param par pointer to an object, it will be the parent of the new button matrix
- * @param copy pointer to a button matrix object, if not NULL then the new object will be copied from it
- * @return pointer to the created button matrix
- */
-lv_obj_t * lv_btnm_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor object*/
-    lv_obj_t * new_btnm = lv_cont_create(par, copy);
-    dm_assert(new_btnm);
-    
-    /*Allocate the object type specific extended data*/
-    lv_btnm_ext_t * ext = lv_obj_alloc_ext(new_btnm, sizeof(lv_btnm_ext_t));
-    dm_assert(ext);
-    ext->btn_cnt = 0;
-    ext->btn_pr = LV_BTNM_PR_NONE;
-    ext->btn_areas = NULL;
-    ext->cb = NULL;
-    ext->map_p = NULL;
-    ext->style_btn_rel = lv_style_get(LV_STYLE_BTN_REL, NULL);
-    ext->style_btn_pr =  lv_style_get(LV_STYLE_BTN_PR, NULL);
-
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_f(new_btnm);
-
-    lv_obj_set_signal_f(new_btnm, lv_btnm_signal);
-    lv_obj_set_design_f(new_btnm, lv_btnm_design);
-
-    /*Init the new button matrix object*/
-    if(copy == NULL) {
-    	lv_obj_set_size(new_btnm, LV_HOR_RES, LV_VER_RES / 2);
-    	lv_obj_set_style(new_btnm, lv_style_get(LV_STYLE_PLAIN, NULL));
-    	lv_btnm_set_map(new_btnm, lv_btnm_def_map);
-    }
-    /*Copy an existing object*/
-    else {
-        lv_btnm_ext_t * copy_ext = lv_obj_get_ext(copy);
-        ext->style_btn_rel = copy_ext->style_btn_rel;
-        ext->style_btn_pr = copy_ext->style_btn_pr;
-        lv_btnm_set_map(new_btnm, lv_btnm_get_map(copy));
-        ext->cb = copy_ext->cb;
-    }
-    
-    return new_btnm;
-}
-
-/**
- * Signal function of the button matrix
- * @param btnm pointer to a button matrix object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_cont_signal(btnm, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-    	area_t btnm_area;
-        area_t btn_area;
-    	point_t p;
-    	if(sign == LV_SIGNAL_CLEANUP) {
-            dm_free(ext->btn_areas);
-    	}
-    	else if(sign == LV_SIGNAL_STYLE_CHG || sign == LV_SIGNAL_CORD_CHG) {
-            lv_btnm_set_map(btnm, ext->map_p);
-    	}
-    	else if(sign == LV_SIGNAL_PRESSING) {
-            uint16_t btn_pr;
-            /*Search the pressed area*/
-            lv_dispi_get_point(param, &p);
-            btn_pr = lv_btnm_get_btn_from_point(btnm, &p);
-            /*Invalidate to old and the new areas*/;
-            lv_obj_get_cords(btnm, &btnm_area);
-            if(btn_pr != ext->btn_pr) {
-                lv_dispi_reset_lpr(param);
-                if(ext->btn_pr != LV_BTNM_PR_NONE) {
-                    area_cpy(&btn_area, &ext->btn_areas[ext->btn_pr]);
-                    btn_area.x1 += btnm_area.x1;
-                    btn_area.y1 += btnm_area.y1;
-                    btn_area.x2 += btnm_area.x1;
-                    btn_area.y2 += btnm_area.y1;
-                    lv_inv_area(&btn_area);
-                }
-                if(btn_pr != LV_BTNM_PR_NONE) {
-                    area_cpy(&btn_area, &ext->btn_areas[btn_pr]);
-                    btn_area.x1 += btnm_area.x1;
-                    btn_area.y1 += btnm_area.y1;
-                    btn_area.x2 += btnm_area.x1;
-                    btn_area.y2 += btnm_area.y1;
-                    lv_inv_area(&btn_area);
-                }
-            }
-
-            ext->btn_pr = btn_pr;
-    	}
-    	else if(sign ==  LV_SIGNAL_RELEASED || sign == LV_SIGNAL_LONG_PRESS_REP) {
-            if(ext->cb != NULL && ext->btn_pr != LV_BTNM_PR_NONE) {
-                uint16_t txt_i = 0;
-                uint16_t btn_i = 0;
-
-                /* Search the text of ext->btn_pr the buttons text in the map
-                 * Skip "\n"-s*/
-                while(btn_i != ext->btn_pr) {
-                    btn_i ++;
-                    txt_i ++;
-                    if(strcmp(ext->map_p[txt_i], "\n") == 0) txt_i ++;
-                }
-
-                ext->cb(btnm, txt_i);
-            }
-
-            if(sign == LV_SIGNAL_RELEASED && ext->btn_pr != LV_BTNM_PR_NONE) {
-                /*Invalidate to old area*/;
-                lv_obj_get_cords(btnm, &btnm_area);
-                area_cpy(&btn_area, &ext->btn_areas[ext->btn_pr]);
-                btn_area.x1 += btnm_area.x1;
-                btn_area.y1 += btnm_area.y1;
-                btn_area.x2 += btnm_area.x1;
-                btn_area.y2 += btnm_area.y1;
-                lv_inv_area(&btn_area);
-
-                ext->btn_pr = LV_BTNM_PR_NONE;
-            }
-    	}
-        else if(sign == LV_SIGNAL_PRESS_LOST) {
-            ext->btn_pr = LV_BTNM_PR_NONE;
-            lv_obj_inv(btnm);
-
-        }
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a new map. Buttons will be created/deleted according to the map.
- * @param btnm pointer to a button matrix object
- * @param map pointer a string array. The last string has to be: "".
- *            Use "\n" to begin a new line.
- *            Use octal numbers (e.g. "\003") to set the relative
- *            width of a button. (max. 9 -> \011)
- *            (e.g. const char * str[] = {"a", "b", "\n", "\004c", "d", ""}).
- *            The button do not copy the array so it can not be a local variable.
- */
-void lv_btnm_set_map(lv_obj_t * btnm, const char ** map)
-{
-	if(map == NULL) return;
-
-	lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-	ext->map_p = map;
-
-	/*Analyze the map and create the required number of buttons*/
-	lv_btnm_create_btns(btnm, map);
-
-	/*Set size and positions of the buttons*/
-	lv_style_t * btnms = lv_obj_get_style(btnm);
-	cord_t max_w = lv_obj_get_width(btnm) - 2 * btnms->hpad;
-	cord_t max_h = lv_obj_get_height(btnm) - 2 * btnms->vpad;
-	cord_t act_y = btnms->vpad;
-
-	/*Count the lines to calculate button height*/
-	uint8_t line_cnt = 1;
-	uint8_t li;
-	for(li = 0; strlen(map[li]) != 0; li++) {
-			if(strcmp(map[li], "\n") == 0) line_cnt ++;
-	}
-
-	cord_t btn_h = max_h - ((line_cnt - 1) * btnms->opad);
-	btn_h = btn_h / line_cnt;
-
-	/* Count the units and the buttons in a line
-	 * (A button can be 1,2,3... unit wide)*/
-	uint16_t unit_cnt;      /*Number of units in a row*/
-    uint16_t unit_act_cnt;  /*Number of units currently put in a row*/
-	uint16_t btn_cnt;		/*Number of buttons in a row*/
-	uint16_t i_tot = 0;		/*Act. index in the str map*/
-	uint16_t btn_i = 0;		/*Act. index of button areas*/
-	const char  ** map_p_tmp = map;
-
-	/*Count the units and the buttons in a line*/
-	while(1) {
-		unit_cnt = 0;
-		btn_cnt = 0;
-		/*Count the buttons in a line*/
-		while(strcmp(map_p_tmp[btn_cnt], "\n") != 0 &&
-			  strlen(map_p_tmp[btn_cnt]) != 0) { /*Check a line*/
-			unit_cnt += lv_btnm_get_width_unit(map_p_tmp[btn_cnt]);
-			btn_cnt ++;
-		}
-
-		/*Only deal with the non empty lines*/
-		if(btn_cnt != 0) {
-			/*Calculate the width of all units*/
-			cord_t all_unit_w = max_w - ((btn_cnt-1) * btnms->opad);
-
-			/*Set the button size and positions and set the texts*/
-			uint16_t i;
-			cord_t act_x = btnms->hpad;
-			cord_t act_unit_w;
-			unit_act_cnt = 0;
-			for(i = 0; i < btn_cnt; i++) {
-				/* one_unit_w = all_unit_w / unit_cnt
-				 * act_unit_w = one_unit_w * button_width
-				 * do this two operation but the multiply first to divide a greater number */
-				act_unit_w = (all_unit_w * lv_btnm_get_width_unit(map_p_tmp[i])) / unit_cnt;
-
-				/*Always recalculate act_x because of rounding errors */
-				act_x = (unit_act_cnt * all_unit_w) / unit_cnt + i * btnms->opad + btnms->hpad;
-
-				area_set(&ext->btn_areas[btn_i], act_x,
-						                         act_y,
-						                         act_x + act_unit_w,
-				                                 act_y + btn_h);
-
-				unit_act_cnt += lv_btnm_get_width_unit(map_p_tmp[i]);
-
-				i_tot ++;
-				btn_i ++;
-			}
-		}
-		act_y += btn_h + btnms->opad;
-		if(strlen(map_p_tmp[btn_cnt]) == 0) break; /*Break on end of map*/
-		map_p_tmp = &map_p_tmp[btn_cnt + 1]; /*Set the map to the next line*/
-		i_tot ++;	/*Skip the '\n'*/
-	}
-
-	lv_obj_inv(btnm);
-}
-
-/**
- * Set a new callback function for the buttons (It will be called when a button is released)
- * @param btnm: pointer to button matrix object
- * @param cb pointer to a callback function
- */
-void lv_btnm_set_action(lv_obj_t * btnm, lv_btnm_callback_t cb)
-{
-    lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-	ext->cb = cb;
-}
-
-/**
- * Set the styles of the buttons of the button matrox
- * @param btnm pointer to a button matrix object
- * @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL)
- * @param style pointer to style
- */
-void lv_btnm_set_styles_btn(lv_obj_t * btnm, lv_style_t *  rel, lv_style_t *  pr)
-{
-    lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-    ext->style_btn_rel = rel;
-    ext->style_btn_pr = pr;
-
-    lv_obj_inv(btnm);
-
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the current map of a button matrix
- * @param btnm pointer to a button matrix object
- * @return the current map
- */
-const char ** lv_btnm_get_map(lv_obj_t * btnm)
-{
-    lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-	return ext->map_p;
-}
-
-/**
- * Get a the callback function of the buttons on a button matrix
- * @param btnm: pointer to button matrix object
- * @return pointer to the callback function
- */
-lv_btnm_callback_t lv_btnm_get_action(lv_obj_t * btnm)
-{
-    lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-	return ext->cb;
-}
-
-/**
- * Get the style of buttons in button matrix
- * @param btnm pointer to a button matrix object
- * @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL)
- * @return pointer the button style in the given state
- */
-lv_style_t * lv_btnm_get_style_btn(lv_obj_t * btnm, lv_btn_state_t state)
-{
-    lv_style_t * style;
-    lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-
-    switch(state) {
-        case LV_BTN_STATE_PR:
-            style = ext->style_btn_pr;
-            break;
-        case LV_BTN_STATE_REL:
-            style = ext->style_btn_rel;
-            break;
-        default:
-            style = NULL;
-    }
-
-    if(style == NULL) style = lv_obj_get_style(btnm);
-
-    return style;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the button matrixs
- * @param btnm pointer to a button matrix object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_btnm_design(lv_obj_t * btnm, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-        return ancestor_design_f(btnm, mask, mode);
-    	/*Return false if the object is not covers the mask_p area*/
-    }
-    /*Draw the object*/
-    else if (mode == LV_DESIGN_DRAW_MAIN) {
-    	ancestor_design_f(btnm, mask, mode);
-
-    	lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-        lv_style_t * btn_style;
-
-    	area_t area_btnm;
-    	area_t area_tmp;
-    	cord_t btn_w;
-    	cord_t btn_h;
-
-    	uint16_t btn_i = 0;
-    	uint16_t txt_i = 0;
-    	for(btn_i = 0; btn_i < ext->btn_cnt; btn_i ++) {
-			lv_obj_get_cords(btnm, &area_btnm);
-
-			area_cpy(&area_tmp, &ext->btn_areas[btn_i]);
-			area_tmp.x1 += area_btnm.x1;
-			area_tmp.y1 += area_btnm.y1;
-			area_tmp.x2 += area_btnm.x1;
-			area_tmp.y2 += area_btnm.y1;
-
-			btn_w = area_get_width(&area_tmp);
-			btn_h = area_get_height(&area_tmp);
-
-			/*Load the style*/
-			btn_style = lv_btnm_get_style_btn(btnm, ext->btn_pr == btn_i ? LV_BTN_STATE_PR : LV_BTN_STATE_REL);
-
-			lv_draw_rect(&area_tmp, mask, btn_style);
-
-			/*Search the next valid text in the map*/
-			while(strcmp(ext->map_p[txt_i], "\n") == 0) txt_i ++;
-
-			/*Calculate the size of the text*/
-			const font_t * font = btn_style->font;
-			point_t txt_size;
-			txt_get_size(&txt_size, ext->map_p[txt_i], font,
-			             btn_style->letter_space, btn_style->line_space,
-					     area_get_width(&area_btnm), TXT_FLAG_NONE);
-
-			area_tmp.x1 += (btn_w - txt_size.x) / 2;
-			area_tmp.y1 += (btn_h - txt_size.y) / 2;
-			area_tmp.x2 = area_tmp.x1 + txt_size.x;
-			area_tmp.y2 = area_tmp.y1 + txt_size.y;
-
-			lv_draw_label(&area_tmp, mask, btn_style, ext->map_p[txt_i], TXT_FLAG_NONE);
-			txt_i ++;
-    	}
-    }
-
-
-    return true;
-}
-
-/**
- * Create the required number of buttons according to a map
- * @param btnm pointer to button matrix object
- * @param map_p pointer to a string array
- */
-static void lv_btnm_create_btns(lv_obj_t * btnm, const char ** map)
-{
-	/*Count the buttons in the map*/
-	uint16_t btn_cnt = 0;
-	uint16_t i = 0;
-	while(strlen(map[i]) != 0) {
-			if(strcmp(map[i], "\n") != 0) { /*Do not count line breaks*/
-			btn_cnt ++;
-		}
-		i++;
-	}
-
-	lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-
-	if(ext->btn_areas != NULL) {
-		dm_free(ext->btn_areas);
-		ext->btn_areas = NULL;
-	}
-
-	ext->btn_areas = dm_alloc(sizeof(area_t) * btn_cnt);
-	ext->btn_cnt = btn_cnt;
-}
-
-/**
- * Get the width of a button in units. It comes from the first "letter".
- * @param btn_str The descriptor string of a button. E.g. "apple" or "\004banana"
- * @return the width of the button in units
- */
-static uint8_t lv_btnm_get_width_unit(const char * btn_str)
-{
-	if(btn_str[0] <= '\011') return btn_str[0];
-
-	return 1;
-}
-
-static uint16_t lv_btnm_get_btn_from_point(lv_obj_t * btnm, point_t * p)
-{
-    area_t btnm_cords;
-    area_t btn_area;
-    lv_btnm_ext_t * ext = lv_obj_get_ext(btnm);
-    uint16_t i;
-    lv_obj_get_cords(btnm, &btnm_cords);
-
-    for(i = 0; i < ext->btn_cnt; i++) {
-        area_cpy(&btn_area, &ext->btn_areas[i]);
-        btn_area.x1 += btnm_cords.x1;
-        btn_area.y1 += btnm_cords.y1;
-        btn_area.x2 += btnm_cords.x1;
-        btn_area.y2 += btnm_cords.y1;
-        if(area_is_point_on(&btn_area, p) != false) {
-            break;
-        }
-    }
-
-    if(i == ext->btn_cnt) i = LV_BTNM_PR_NONE;
-
-    return i;
-}
-
-
-#endif

lv_objx/lv_btnm.h

@@ -1,123 +0,0 @@
-/**
- * @file lv_btnm.h
- * 
- */
-
-
-#ifndef LV_BTNM_H
-#define LV_BTNM_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_BTNM != 0
-
-#include "../lv_obj/lv_obj.h"
-#include "lv_label.h"
-#include "lv_btn.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/* Type of callback function which is called when a button is released on the button matrix
- * Parameters: button matrix, released button index in the map string
- * return LV_ACTION_RES_INV:  the button matrix is deleted else LV_ACTION_RES_OK*/
-typedef lv_action_res_t (*lv_btnm_callback_t) (lv_obj_t *, uint16_t);
-
-/*Data of button matrix*/
-typedef struct
-{
-    lv_cont_ext_t bg; /*Ext. of ancestor*/
-    /*New data for this type */
-    const char ** map_p;    /*Pointer to the current map*/
-    area_t * btn_areas;     /*Array of areas for the buttons (Handled by the library)*/
-    uint16_t btn_cnt;       /*Number of button in 'map_p'(Handled by the library)*/
-    uint16_t btn_pr;        /*Index of the currently pressed button or LV_BTNM_PR_NONE (Handled by the library)*/
-    lv_btnm_callback_t cb;  /*A function to call when a button is releases*/
-    lv_style_t * style_btn_rel; /*Style of the released buttons*/
-    lv_style_t * style_btn_pr;  /*Style of the pressed buttons*/
-}lv_btnm_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a button matrix objects
- * @param par pointer to an object, it will be the parent of the new button matrix
- * @param copy pointer to a button matrix object, if not NULL then the new object will be copied from it
- * @return pointer to the created button matrix
- */
-lv_obj_t * lv_btnm_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the button matrix
- * @param btnm pointer to a button matrix object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_btnm_signal(lv_obj_t * btnm, lv_signal_t sign, void * param);
-
-/**
- * Set a new map. Buttons will be created/deleted according to the map.
- * @param btnm pointer to a button matrix object
- * @param map pointer a string array. The last string has to be: "".
- *            Use "\n" to begin a new line.
- *            Use octal numbers (e.g. "\003") to set the relative
- *            width of a button. (max. 9 -> \011)
- *            (e.g. const char * str[] = {"a", "b", "\n", "\004c", "d", ""}).
- *            The button do not copy the array so it can not be a local variable.
- */
-void lv_btnm_set_map(lv_obj_t * btnm, const char ** map);
-
-/**
- * Set a new callback function for the buttons (It will be called when a button is released)
- * @param btnm: pointer to button matrix object
- * @param cb pointer to a callback function
- */
-void lv_btnm_set_action(lv_obj_t * btnm, lv_btnm_callback_t cb);
-
-/**
- * Set the styles of the buttons of the button matrox
- * @param btnm pointer to a button matrix object
- * @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL)
- * @param style pointer to style
- */
-void lv_btnm_set_styles_btn(lv_obj_t * btnm, lv_style_t *  rel, lv_style_t *  pr);
-
-/**
- * Get the current map of a button matrix
- * @param btnm pointer to a button matrix object
- * @return the current map
- */
-const char ** lv_btnm_get_map(lv_obj_t * btnm);
-
-/**
- * Get a the callback function of the buttons on a button matrix
- * @param btnm: pointer to button matrix object
- * @return pointer to the callback function
- */
-lv_btnm_callback_t lv_btnm_get_action(lv_obj_t * btnm);
-
-/**
- * Get the style of buttons in button matrix
- * @param btnm pointer to a button matrix object
- * @param state style in this state (LV_BTN_STATE_PR or LV_BTN_STATE_REL)
- * @return pointer the button style in the given state
- */
-lv_style_t * lv_btnm_get_style_btn(lv_obj_t * btnm, lv_btn_state_t state);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif /*USE_LV_BTNM*/
-
-#endif /*LV_BTNM_H*/

lv_objx/lv_cb.c

@@ -1,206 +0,0 @@
-/**
- * @file lv_cb.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_CB != 0
-
-#include "lv_cb.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_cb_design(lv_obj_t * cb, const area_t * mask, lv_design_mode_t mode);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_f_t ancestor_design_f;
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a check box objects
- * @param par pointer to an object, it will be the parent of the new check box
- * @param copy pointer to a check box object, if not NULL then the new object will be copied from it
- * @return pointer to the created check box
- */
-lv_obj_t * lv_cb_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor basic object*/
-    lv_obj_t * new_cb = lv_btn_create(par, copy);
-    dm_assert(new_cb);
-    
-    lv_cb_ext_t * ext = lv_obj_alloc_ext(new_cb, sizeof(lv_cb_ext_t));
-    dm_assert(ext);
-    ext->bullet = NULL;
-    ext->label = NULL;
-
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_f(new_cb);
-
-    lv_obj_set_signal_f(new_cb, lv_cb_signal);
-    lv_obj_set_design_f(new_cb, lv_cb_design);
-
-    /*Init the new checkbox object*/
-    if(copy == NULL) {
-        ext->bullet = lv_btn_create(new_cb, NULL);
-        lv_btn_set_styles(new_cb, lv_style_get(LV_STYLE_TRANSP, NULL), lv_style_get(LV_STYLE_TRANSP, NULL),
-                                  lv_style_get(LV_STYLE_TRANSP, NULL), lv_style_get(LV_STYLE_TRANSP, NULL),
-                                  lv_style_get(LV_STYLE_TRANSP, NULL));
-        lv_cont_set_layout(new_cb, LV_CONT_LAYOUT_ROW_M);
-        lv_cont_set_fit(new_cb, true, true);
-        lv_btn_set_tgl(new_cb, true);
-
-        lv_obj_set_click(ext->bullet, false);
-        lv_btn_set_styles(ext->bullet, lv_style_get(LV_STYLE_PRETTY, NULL), lv_style_get(LV_STYLE_PRETTY_COLOR, NULL),
-                                       lv_style_get(LV_STYLE_BTN_TREL, NULL), lv_style_get(LV_STYLE_BTN_TPR, NULL),
-                                       lv_style_get(LV_STYLE_BTN_INA, NULL));
-
-        ext->label = lv_label_create(new_cb, NULL);
-        lv_obj_set_style(ext->label, NULL);     /*Inherit the style of the parent*/
-        lv_label_set_text(ext->label, "Check box");
-    } else {
-    	lv_cb_ext_t * copy_ext = lv_obj_get_ext(copy);
-    	ext->bullet = lv_btn_create(new_cb, copy_ext->bullet);
-    	ext->label = lv_label_create(new_cb, copy_ext->label);
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_cb);
-    }
-    
-    return new_cb;
-}
-
-
-/**
- * Signal function of the check box
- * @param cb pointer to a check box object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_btn_signal(cb, sign, param);
-
-    lv_cb_ext_t * ext = lv_obj_get_ext(cb);
-    lv_style_t * style = lv_obj_get_style(cb);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	if(sign == LV_SIGNAL_STYLE_CHG) {
-    		lv_obj_set_size(ext->bullet, font_get_height(style->font), font_get_height(style->font));
-    	}
-        if(sign == LV_SIGNAL_PRESSED ||
-            sign == LV_SIGNAL_RELEASED ||
-            sign == LV_SIGNAL_PRESS_LOST) {
-            lv_btn_set_state(lv_cb_get_bullet(cb), lv_btn_get_state(cb));
-        }
-    }
-    
-    return valid;
-}
-
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the text of a check box
- * @param cb pointer to a check box
- * @param txt the text of the check box
- */
-void lv_cb_set_text(lv_obj_t * cb, const char * txt)
-{
-	lv_cb_ext_t * ext = lv_obj_get_ext(cb);
-	lv_label_set_text(ext->label, txt);
-}
-
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the text of a check box
- * @param cb pointer to check box object
- * @return pointer to the text of the check box
- */
-const char * lv_cb_get_text(lv_obj_t * cb)
-{
-	lv_cb_ext_t * ext = lv_obj_get_ext(cb);
-	return lv_label_get_text(ext->label);
-}
-
-/**
- * Get the bullet (lv_btn) of a check box
- * @param cb pointer to check box object
- * @return pointer to the bullet of the check box (lv_btn)
- */
-lv_obj_t *  lv_cb_get_bullet(lv_obj_t * cb)
-{
-    lv_cb_ext_t * ext = lv_obj_get_ext(cb);
-    return ext->bullet;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the check boxes
- * @param cb pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_cb_design(lv_obj_t * cb, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	/*Return false if the object is not covers the mask_p area*/
-    	return ancestor_design_f(cb, mask, mode);
-    } else if(mode == LV_DESIGN_DRAW_MAIN || mode == LV_DESIGN_DRAW_POST) {
-        lv_cb_ext_t * cb_ext = lv_obj_get_ext(cb);
-        lv_btn_ext_t * bullet_ext = lv_obj_get_ext(cb_ext->bullet);
-
-        /*Be sure he state of the bullet is the same as the parent button*/
-        bullet_ext->state = cb_ext->bg_btn.state;
-
-        return ancestor_design_f(cb, mask, mode);
-
-    }
-
-    /*Draw the object*/
-
-    return true;
-}
-
-#endif

lv_objx/lv_cb.h

@@ -1,92 +0,0 @@
-/**
- * @file lv_cb.h
- * 
- */
-
-#ifndef LV_CB_H
-#define LV_CB_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_CB != 0
-
-/*Testing of dependencies*/
-#if USE_LV_BTN == 0
-#error "lv_cb: lv_btn is required. Enable it in lv_conf.h (USE_LV_BTN  1) "
-#endif
-
-#if USE_LV_LABEL == 0
-#error "lv_cb: lv_label is required. Enable it in lv_conf.h (USE_LV_LABEL  1) "
-#endif
-
-#include "../lv_obj/lv_obj.h"
-#include "lv_btn.h"
-#include "lv_label.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of check box*/
-typedef struct
-{
-    lv_btn_ext_t bg_btn; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * bullet;  /*Pointer to button*/
-    lv_obj_t * label;   /*Pointer to label*/
-}lv_cb_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a check box objects
- * @param par pointer to an object, it will be the parent of the new check box
- * @param copy pointer to a check box object, if not NULL then the new object will be copied from it
- * @return pointer to the created check box
- */
-lv_obj_t * lv_cb_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the check box
- * @param cb pointer to a check box object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_cb_signal(lv_obj_t * cb, lv_signal_t sign, void * param);
-
-/**
- * Set the text of a check box
- * @param cb pointer to a check box
- * @param txt the text of the check box
- */
-void lv_cb_set_text(lv_obj_t * cb, const char * txt);
-
-/**
- * Get the text of a check box
- * @param cb pointer to check box object
- * @return pointer to the text of the check box
- */
-const char * lv_cb_get_text(lv_obj_t * cb);
-
-/**
- * Get the bullet (lv_btn) of a check box
- * @param cb pointer to check box object
- * @return pointer to the bullet of the check box (lv_btn)
- */
-lv_obj_t *  lv_cb_get_bullet(lv_obj_t * cb);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_chart.c

@@ -1,614 +0,0 @@
-/**
- * @file lv_chart.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_CHART != 0
-
-#include "lv_chart.h"
-#include "../lv_draw/lv_draw.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_CHART_YMIN_DEF	0
-#define LV_CHART_YMAX_DEF	100
-#define LV_CHART_HDIV_DEF	3
-#define LV_CHART_VDIV_DEF	5
-#define LV_CHART_PNUM_DEF	10
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_chart_design(lv_obj_t * chart, const area_t * mask, lv_design_mode_t mode);
-static void lv_chart_draw_div(lv_obj_t * chart, const area_t * mask);
-static void lv_chart_draw_lines(lv_obj_t * chart, const area_t * mask);
-static void lv_chart_draw_points(lv_obj_t * chart, const area_t * mask);
-static void lv_chart_draw_cols(lv_obj_t * chart, const area_t * mask);
-
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_f_t ancestor_design_f;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*-----------------
- * Create function
- *-----------------*/
-
-/**
- * Create a chart background objects
- * @param par pointer to an object, it will be the parent of the new chart background
- * @param copy pointer to a chart background object, if not NULL then the new object will be copied from it
- * @return pointer to the created chart background
- */
-lv_obj_t * lv_chart_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor basic object*/
-    lv_obj_t * new_chart = lv_obj_create(par, copy);
-    dm_assert(new_chart);
-
-    /*Allocate the object type specific extended data*/
-    lv_chart_ext_t * ext = lv_obj_alloc_ext(new_chart, sizeof(lv_chart_ext_t));
-    dm_assert(ext);
-    ll_init(&ext->dl_ll, sizeof(lv_chart_dl_t));
-    ext->dl_num = 0;
-    ext->ymin = LV_CHART_YMIN_DEF;
-    ext->ymax = LV_CHART_YMAX_DEF;
-    ext->hdiv_num = LV_CHART_HDIV_DEF;
-    ext->vdiv_num = LV_CHART_VDIV_DEF;
-    ext->pnum = LV_CHART_PNUM_DEF;
-    ext->type = LV_CHART_LINE;
-    ext->dl_opa = OPA_COVER;
-    ext->dl_dark = OPA_50;
-    ext->dl_width = 2 * LV_DOWNSCALE;
-
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_f(new_chart);
-
-    lv_obj_set_signal_f(new_chart, lv_chart_signal);
-    lv_obj_set_design_f(new_chart, lv_chart_design);
-
-    /*Init the new chart background object*/
-    if(copy == NULL) {
-    	lv_obj_set_style(new_chart, lv_style_get(LV_STYLE_PRETTY, NULL));
-    } else {
-    	lv_chart_ext_t * ext_copy = lv_obj_get_ext(copy);
-        ext->type = ext_copy->type;
-		ext->ymin = ext_copy->ymin;
-		ext->ymax = ext_copy->ymax;
-		ext->hdiv_num = ext_copy->hdiv_num;
-		ext->vdiv_num = ext_copy->vdiv_num;
-        ext->pnum = ext_copy->pnum;
-        ext->dl_opa =  ext_copy->dl_opa;
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_chart);
-    }
-
-    return new_chart;
-}
-
-/**
- * Signal function of the chart background
- * @param chart pointer to a chart background object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_chart_signal(lv_obj_t * chart, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_obj_signal(chart, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	cord_t ** datal;
-    	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-    	if(sign == LV_SIGNAL_CLEANUP) {
-            LL_READ(ext->dl_ll, datal) {
-                dm_free(*datal);
-            }
-            ll_clear(&ext->dl_ll);
-    	}
-    }
-
-    return valid;
-}
-
-/**
- * Allocate and add a data line to the chart
- * @param chart pointer to a chart object
- * @param color color of the data line
- * @return pointer to the allocated data line (
- */
-lv_chart_dl_t * lv_chart_add_data_line(lv_obj_t * chart, color_t color)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-	lv_chart_dl_t * dl = ll_ins_head(&ext->dl_ll);
-	cord_t def = (ext->ymin + ext->ymax) >> 1;	/*half range as default value*/
-
-	if(dl == NULL) return NULL;
-
-    dl->color = color;
-
-	dl->points = dm_alloc(sizeof(cord_t) * ext->pnum);
-
-	uint16_t i;
-	cord_t * p_tmp = dl->points;
-	for(i = 0; i < ext->pnum; i++) {
-		*p_tmp = def;
-		p_tmp++;
-	}
-
-	ext->dl_num++;
-
-	return dl;
-}
-
-/**
- * Refresh a chart if its data line has changed
- * @param chart pointer to chart object
- */
-void lv_chart_refr(lv_obj_t * chart)
-{
-	lv_obj_inv(chart);
-}
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the number of horizontal and vertical division lines
- * @param chart pointer to a graph background object
- * @param hdiv number of horizontal division lines
- * @param vdiv number of vertical division lines
- */
-void lv_chart_set_hvdiv(lv_obj_t * chart, uint8_t hdiv, uint8_t vdiv)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-
-	ext->hdiv_num = hdiv;
-	ext->vdiv_num = vdiv;
-
-	lv_obj_inv(chart);
-}
-
-/**
- * Set the minimal and maximal x and y values
- * @param chart pointer to a graph background object
- * @param xmin x minimum value
- * @param xmax x maximum value
- * @param ymin y minimum value
- * @param ymax y maximum value
- */
-void lv_chart_set_range(lv_obj_t * chart, cord_t ymin, cord_t ymax)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-
-	ext->ymin = ymin;
-	ext->ymax = ymax;
-
-	lv_chart_refr(chart);
-}
-
-/**
- * Set a new type for a chart
- * @param chart pointer to a chart object
- * @param type new type of the chart (from 'lv_chart_type_t' enum)
- */
-void lv_chart_set_type(lv_obj_t * chart, lv_chart_type_t type)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-	ext->type = type;
-
-	lv_chart_refr(chart);
-}
-
-/**
- * Set the number of points on a data line on a chart
- * @param chart pointer r to chart object
- * @param pnum new number of points on the data lines
- */
-void lv_chart_set_pnum(lv_obj_t * chart, uint16_t pnum)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-	lv_chart_dl_t * dl;
-
-	if(pnum < 1) pnum = 1;
-
-	LL_READ_BACK(ext->dl_ll, dl) {
-		dl->points = dm_realloc(dl->points, sizeof(cord_t) * pnum);
-	}
-
-	ext->pnum = pnum;
-	lv_chart_refr(chart);
-}
-
-/**
- * Set the opacity of the data lines
- * @param chart pointer to chart object
- * @param opa opacity of the data lines
- */
-void lv_chart_set_dl_opa(lv_obj_t * chart, opa_t opa)
-{
-    lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-    ext->dl_opa = opa;
-    lv_obj_inv(chart);
-}
-
-/**
- * Set the line width or point radius of the data lines
- * @param chart pointer to chart object
- * @param width the new width
- */
-void lv_chart_set_dl_width(lv_obj_t * chart, cord_t width)
-{
-    lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-    ext->dl_width = width;
-    lv_obj_inv(chart);
-}
-/**
- * Set the dark effect on the bottom of the points or columns
- * @param chart pointer to chart object
- * @param dark_eff dark effect level (OPA_TRANSP to turn off)
- */
-void lv_chart_set_dl_dark(lv_obj_t * chart, opa_t dark_eff)
-{
-    lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-    ext->dl_dark = dark_eff;
-}
-/**
- * Shift all data right and set the most right data on a data line
- * @param chart pointer to chart object
- * @param dl pointer to a data line on 'chart'
- * @param y the new value of the most right data
- */
-void lv_chart_set_next(lv_obj_t * chart, lv_chart_dl_t * dl, cord_t y)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-
-	uint16_t i;
-	for(i = 0; i < ext->pnum - 1; i++) {
-		dl->points[i] = dl->points[i + 1];
-	}
-
-	dl->points[ext->pnum - 1] = y;
-	lv_chart_refr(chart);
-
-}
-
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the type of a chart
- * @param chart pointer to chart object
- * @return type of the chart (from 'lv_chart_t' enum)
- */
-lv_chart_type_t lv_chart_get_type(lv_obj_t * chart)
-{
-    lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-
-    return ext->type;
-}
-
-/**
- * Get the data point number per data line on chart
- * @param chart pointer to chart object
- * @return point number on each data line
- */
-uint16_t lv_chart_get_pnum(lv_obj_t * chart)
-{
-    lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-
-    return ext->pnum;
-}
-
-/**
- * Get the opacity of the data lines
- * @param chart pointer to chart object
- * @return the opacity of the data lines
- */
-opa_t lv_chart_get_dl_opa(lv_obj_t * chart)
-{
-    lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-    return ext->dl_opa;
-}
-
-/**
- * Get the data line width
- * @param chart pointer to chart object
- * @return the width the data lines (lines or points)
- */
-cord_t lv_chart_get_dl_width(lv_obj_t * chart)
-{
-    lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-    return ext->dl_width;
-}
-
-/**
- * Get the dark effect level on the bottom of the points or columns
- * @param chart pointer to chart object
- * @return dark effect level (OPA_TRANSP to turn off)
- */
-opa_t lv_chart_get_dl_dark(lv_obj_t * chart, opa_t dark_eff)
-{
-    lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-    return ext->dl_dark;
-}
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-
-/**
- * Handle the drawing related tasks of the chart backgrounds
- * @param chart pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_chart_design(lv_obj_t * chart, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	/*Return false if the object is not covers the mask_p area*/
-    	return ancestor_design_f(chart, mask, mode);
-    } else if(mode == LV_DESIGN_DRAW_MAIN) {
-		/*Draw the background*/
-        lv_draw_rect(&chart->cords, mask, lv_obj_get_style(chart));
-
-		lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-
-		lv_chart_draw_div(chart, mask);
-
-		if(ext->type & LV_CHART_LINE) lv_chart_draw_lines(chart, mask);
-		if(ext->type & LV_CHART_COL) lv_chart_draw_cols(chart, mask);
-		if(ext->type & LV_CHART_POINT) lv_chart_draw_points(chart, mask);
-    }
-    return true;
-}
-
-/**
- * Draw the division lines on chart background
- * @param chart pointer to chart object
- * @param mask mask, inherited from the design function
- */
-static void lv_chart_draw_div(lv_obj_t * chart, const area_t * mask)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-	lv_style_t * style = lv_obj_get_style(chart);
-
-	uint8_t div_i;
-    uint8_t div_i_end;
-    uint8_t div_i_start;
-	point_t p1;
-	point_t p2;
-	cord_t w = lv_obj_get_width(chart);
-	cord_t h = lv_obj_get_height(chart);
-	cord_t x_ofs = chart->cords.x1;
-	cord_t y_ofs = chart->cords.y1;
-
-	if(ext->hdiv_num != 0) {
-        /*Draw slide lines if no border*/
-        if(style->bwidth != 0) {
-            div_i_start = 1;
-            div_i_end = ext->hdiv_num;
-        } else {
-            div_i_start = 0;
-            div_i_end = ext->hdiv_num + 1;
-        }
-
-        p1.x = 0 + x_ofs;
-        p2.x = w + x_ofs;
-        for(div_i = div_i_start; div_i <= div_i_end; div_i++) {
-            p1.y = (int32_t)((int32_t)h * div_i) / (ext->hdiv_num + 1);
-            p1.y +=  y_ofs;
-            if(div_i == div_i_start) p1.y += (style->line_width >> 1) + 1;  /*The first line might not be visible*/
-            if(div_i == div_i_end) p1.y -= (style->line_width >> 1) + 1;  /*The last line might not be visible*/
-
-            p2.y = p1.y;
-            lv_draw_line(&p1, &p2, mask, style);
-        }
-	}
-
-	if(ext->vdiv_num != 0) {
-        /*Draw slide lines if no border*/
-        if(style->bwidth != 0) {
-            div_i_start = 1;
-            div_i_end = ext->vdiv_num;
-        } else {
-            div_i_start = 0;
-            div_i_end = ext->vdiv_num + 1;
-        }
-
-        p1.y = 0 + y_ofs;
-        p2.y = h + y_ofs;
-        for(div_i = div_i_start; div_i <= div_i_end; div_i ++) {
-            p1.x = (int32_t)((int32_t)w * div_i) / (ext->vdiv_num + 1);
-            p1.x +=  x_ofs;
-            if(div_i == div_i_start) p1.x += (style->line_width >> 1) + 1;  /*The first line might not be visible*/
-            if(div_i == div_i_end) p1.x -= (style->line_width >> 1) + 1;  /*The last line might not be visible*/
-            p2.x = p1.x;
-            lv_draw_line(&p1, &p2, mask, style);
-        }
-	}
-}
-
-/**
- * Draw the data lines as lines on a chart
- * @param obj pointer to chart object
- */
-static void lv_chart_draw_lines(lv_obj_t * chart, const area_t * mask)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-	lv_style_t * style = lv_obj_get_style(chart);
-
-	uint8_t i;
-	point_t p1;
-	point_t p2;
-	cord_t w = lv_obj_get_width(chart);
-	cord_t h = lv_obj_get_height(chart);
-    cord_t x_ofs = chart->cords.x1;
-    cord_t y_ofs = chart->cords.y1;
-	int32_t y_tmp;
-	lv_chart_dl_t * dl;
-	lv_style_t lines;
-	lv_style_get(LV_STYLE_PLAIN, &lines);
-	lines.opa = (uint16_t)((uint16_t)style->opa * ext->dl_opa) >> 8;
-    lines.line_width = ext->dl_width;
-
-	/*Go through all data lines*/
-	LL_READ_BACK(ext->dl_ll, dl) {
-		lines.ccolor = dl->color;
-
-		p1.x = 0 + x_ofs;
-		p2.x = 0 + x_ofs;
-		y_tmp = (int32_t)((int32_t) dl->points[0] - ext->ymin) * h;
-		y_tmp = y_tmp / (ext->ymax - ext->ymin);
-		p2.y = h - y_tmp + y_ofs;
-
-		for(i = 1; i < ext->pnum; i ++) {
-			p1.x = p2.x;
-			p1.y = p2.y;
-
-			p2.x = ((w * i) / (ext->pnum - 1)) + x_ofs;
-
-			y_tmp = (int32_t)((int32_t) dl->points[i] - ext->ymin) * h;
-			y_tmp = y_tmp / (ext->ymax - ext->ymin);
-			p2.y = h - y_tmp + y_ofs;
-
-			lv_draw_line(&p1, &p2, mask, &lines);
-		}
-	}
-}
-
-/**
- * Draw the data lines as points on a chart
- * @param chart pointer to chart object
- * @param mask mask, inherited from the design function
- */
-static void lv_chart_draw_points(lv_obj_t * chart, const area_t * mask)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-	lv_style_t * style = lv_obj_get_style(chart);
-
-	uint8_t i;
-	area_t cir_a;
-	cord_t w = lv_obj_get_width(chart);
-	cord_t h = lv_obj_get_height(chart);
-    cord_t x_ofs = chart->cords.x1;
-    cord_t y_ofs = chart->cords.y1;
-	int32_t y_tmp;
-    lv_chart_dl_t * dl;
-    uint8_t dl_cnt = 0;
-    lv_style_t style_point;
-    lv_style_get(LV_STYLE_PLAIN, &style_point);
-
-	style_point.bwidth = 0;
-	style_point.empty = 0;
-	style_point.radius = LV_RADIUS_CIRCLE;
-    style_point.opa = (uint16_t)((uint16_t)style->opa * ext->dl_opa) >> 8;
-    style_point.radius = ext->dl_width;
-
-	/*Go through all data lines*/
-	LL_READ_BACK(ext->dl_ll, dl) {
-		style_point.mcolor = dl->color;
-		style_point.gcolor = color_mix(COLOR_BLACK, dl->color, ext->dl_dark);
-
-		for(i = 0; i < ext->pnum; i ++) {
-			cir_a.x1 = ((w * i) / (ext->pnum - 1)) + x_ofs;
-			cir_a.x2 = cir_a.x1 + style_point.radius;
-			cir_a.x1 -= style_point.radius;
-
-			y_tmp = (int32_t)((int32_t) dl->points[i] - ext->ymin) * h;
-			y_tmp = y_tmp / (ext->ymax - ext->ymin);
-			cir_a.y1 = h - y_tmp + y_ofs;
-			cir_a.y2 = cir_a.y1 + style_point.radius;
-			cir_a.y1 -= style_point.radius;
-
-			lv_draw_rect(&cir_a, mask, &style_point);
-		}
-		dl_cnt++;
-	}
-}
-
-/**
- * Draw the data lines as columns on a chart
- * @param chart pointer to chart object
- * @param mask mask, inherited from the design function
- */
-static void lv_chart_draw_cols(lv_obj_t * chart, const area_t * mask)
-{
-	lv_chart_ext_t * ext = lv_obj_get_ext(chart);
-	lv_style_t * style = lv_obj_get_style(chart);
-
-	uint8_t i;
-	area_t col_a;
-	area_t col_mask;
-	bool mask_ret;
-	cord_t w = lv_obj_get_width(chart);
-	cord_t h = lv_obj_get_height(chart);
-	int32_t y_tmp;
-    lv_chart_dl_t * dl;
-    lv_style_t rects;
-	cord_t col_w = w / ((ext->dl_num + 1) * ext->pnum); /* Suppose + 1 dl as separator*/
-	cord_t x_ofs = col_w / 2; /*Shift with a half col.*/
-
-	lv_style_get(LV_STYLE_PLAIN, &rects);
-	rects.bwidth = 0;
-	rects.empty = 0;
-	rects.radius = 0;
-	rects.opa = (uint16_t)((uint16_t)style->opa * ext->dl_opa) >> 8;
-
-	col_a.y2 = chart->cords.y2;
-
-	cord_t x_act;
-
-	/*Go through all points*/
-    for(i = 0; i < ext->pnum; i ++) {
-        x_act = (int32_t)((int32_t) w * i) / ext->pnum;
-        x_act += chart->cords.x1 + x_ofs;
-
-        /*Draw the current point of all data line*/
-        LL_READ_BACK(ext->dl_ll, dl) {
-            rects.mcolor = dl->color;
-            rects.gcolor = color_mix(COLOR_BLACK, dl->color, ext->dl_dark);
-            col_a.x1 = x_act;
-            col_a.x2 = col_a.x1 + col_w;
-            x_act += col_w;
-
-            y_tmp = (int32_t)((int32_t) dl->points[i] - ext->ymin) * h;
-            y_tmp = y_tmp / (ext->ymax - ext->ymin);
-            col_a.y1 = h - y_tmp + chart->cords.y1;
-
-            mask_ret = area_union(&col_mask, mask, &col_a);
-            if(mask_ret != false) {
-                lv_draw_rect(&chart->cords, &col_mask, &rects);
-            }
-        }
-	}
-}
-#endif

lv_objx/lv_chart.h

@@ -1,195 +0,0 @@
-/**
- * @file lv_chart.h
- *
- */
-
-#ifndef LV_CHART_H
-#define LV_CHART_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_CHART != 0
-
-#include "../lv_obj/lv_obj.h"
-#include "lv_line.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-typedef struct
-{
-    cord_t * points;
-    color_t color;
-}lv_chart_dl_t;
-
-/*Data of chart */
-typedef struct
-{
-    /*No inherited ext*/ /*Ext. of ancestor*/
-    /*New data for this type */
-    ll_dsc_t dl_ll;       /*Linked list for the data line pointers (stores lv_chart_dl_t)*/
-    cord_t ymin;          /*y min value (used to scale the data)*/
-    cord_t ymax;          /*y max value (used to scale the data)*/
-    uint8_t hdiv_num;     /*Number of horizontal division lines*/
-    uint8_t vdiv_num;     /*Number of vertical division lines*/
-    uint16_t pnum;        /*Point number in a data line*/
-    cord_t dl_width;      /*Line width or point radius*/
-    uint8_t dl_num;       /*Number of data lines in dl_ll*/
-    opa_t dl_opa;       /*Opacity of data lines*/
-    opa_t dl_dark;       /*Dark level of the point/column bottoms*/
-    uint8_t type    :3;   /*Line, column or point chart (from 'lv_chart_type_t')*/
-}lv_chart_ext_t;
-
-/*Chart types*/
-typedef enum
-{
-    LV_CHART_NONE = 0,
-	LV_CHART_LINE = 0x01,
-	LV_CHART_COL = 0x02,
-	LV_CHART_POINT = 0x04,
-}lv_chart_type_t;
-
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a chart background objects
- * @param par pointer to an object, it will be the parent of the new chart background
- * @param copy pointer to a chart background object, if not NULL then the new object will be copied from it
- * @return pointer to the created chart background
- */
-lv_obj_t * lv_chart_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the chart background
- * @param chart pointer to a chart background object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_chart_signal(lv_obj_t * chart, lv_signal_t sign, void * param);
-
-/**
- * Allocate and add a data line to the chart
- * @param chart pointer to a chart object
- * @param color color of the data line
- * @return pointer to the allocated data line (
- */
-lv_chart_dl_t * lv_chart_add_data_line(lv_obj_t * chart, color_t color);
-
-/**
- * Refresh a chart if its data line has changed
- * @param chart pointer to chart object
- */
-void lv_chart_refr(lv_obj_t * chart);
-
-/**
- * Set the number of horizontal and vertical division lines
- * @param chart pointer to a graph background object
- * @param hdiv number of horizontal division lines
- * @param vdiv number of vertical division lines
- */
-void lv_chart_set_hvdiv(lv_obj_t * chart, uint8_t hdiv, uint8_t vdiv);
-
-/**
- * Set the minimal and maximal x and y values
- * @param chart pointer to a graph background object
- * @param xmin x minimum value
- * @param xmax x maximum value
- * @param ymin y minimum value
- * @param ymax y maximum value
- */
-void lv_chart_set_range(lv_obj_t * chart, cord_t ymin, cord_t ymax);
-
-/**
- * Set a new type for a chart
- * @param chart pointer to a chart object
- * @param type new type of the chart (from 'lv_chart_type_t' enum)
- */
-void lv_chart_set_type(lv_obj_t * chart, lv_chart_type_t type);
-
-/**
- * Set the number of points on a data line on a chart
- * @param chart pointer r to chart object
- * @param pnum new number of points on the data lines
- */
-void lv_chart_set_pnum(lv_obj_t * chart, uint16_t pnum);
-
-/**
- * Set the opacity of the data lines
- * @param chart pointer to chart object
- * @param opa opacity of the data lines
- */
-void lv_chart_set_dl_opa(lv_obj_t * chart, opa_t opa);
-
-/**
- * Set the line width or point radius of the data lines
- * @param chart pointer to chart object
- * @param width the new width
- */
-void lv_chart_set_dl_width(lv_obj_t * chart, cord_t width);
-
-/**
- * Set the dark effect on the bottom of the points or columns
- * @param chart pointer to chart object
- * @param dark_eff dark effect level (OPA_TRANSP to turn off)
- */
-void lv_chart_set_dl_dark(lv_obj_t * chart, opa_t dark_eff);
-
-/**
- * Shift all data right and set the most right data on a data line
- * @param chart pointer to chart object
- * @param dl pointer to a data line on 'chart'
- * @param y the new value of the most right data
- */
-void lv_chart_set_next(lv_obj_t * chart, lv_chart_dl_t * dl, cord_t y);
-
-/**
- * Get the type of a chart
- * @param chart pointer to chart object
- * @return type of the chart (from 'lv_chart_t' enum)
- */
-lv_chart_type_t lv_chart_get_type(lv_obj_t * chart);
-
-/**
- * Get the data point number per data line on chart
- * @param chart pointer to chart object
- * @return point number on each data line
- */
-uint16_t lv_chart_get_pnum(lv_obj_t * chart);
-
-/**
- * Get the opacity of the data lines
- * @param chart pointer to chart object
- * @return the opacity of the data lines
- */
-opa_t lv_chart_get_dl_opa(lv_obj_t * chart);
-
-/**
- * Get the data line width
- * @param chart pointer to chart object
- * @return the width the data lines (lines or points)
- */
-cord_t lv_chart_get_dl_width(lv_obj_t * chart);
-
-/**
- * Get the dark effect level on the bottom of the points or columns
- * @param chart pointer to chart object
- * @return dark effect level (OPA_TRANSP to turn off)
- */
-opa_t lv_chart_get_dl_dark(lv_obj_t * chart, opa_t dark_eff);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_cont.c

@@ -1,613 +0,0 @@
-/**
- * @file lv_rect.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-
-#if USE_LV_CONT != 0
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "lv_cont.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_draw/lv_draw_vbasic.h"
-#include "misc/gfx/area.h"
-
-#include "misc/gfx/color.h"
-#include "misc/math/math_base.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-#if 0
-static bool lv_cont_design(lv_obj_t * cont, const area_t * mask, lv_design_mode_t mode);
-#endif
-
-static void lv_cont_refr_layout(lv_obj_t * cont);
-static void lv_cont_layout_col(lv_obj_t * cont);
-static void lv_cont_layout_row(lv_obj_t * cont);
-static void lv_cont_layout_center(lv_obj_t * cont);
-static void lv_cont_layout_pretty(lv_obj_t * cont);
-static void lv_cont_layout_grid(lv_obj_t * cont);
-static void lv_cont_refr_autofit(lv_obj_t * cont);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a container objects
- * @param par pointer to an object, it will be the parent of the new container
- * @param copy pointer to a container object, if not NULL then the new object will be copied from it
- * @return pointer to the created container
- */
-lv_obj_t * lv_cont_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create a basic object*/
-    lv_obj_t * new_rect = lv_obj_create(par, copy);
-    dm_assert(new_rect);
-    lv_obj_alloc_ext(new_rect, sizeof(lv_cont_ext_t));
-    lv_cont_ext_t * ext = lv_obj_get_ext(new_rect);
-    dm_assert(ext);
-    ext->hfit_en = 0;
-    ext->vfit_en = 0;
-    ext->layout = LV_CONT_LAYOUT_OFF;
-
-    lv_obj_set_signal_f(new_rect, lv_cont_signal);
-
-    /*Init the new container*/
-    if(copy == NULL) {
-		lv_obj_set_style(new_rect, lv_style_get(LV_STYLE_PLAIN, NULL));
-    }
-    /*Copy an existing object*/
-    else {
-    	lv_cont_ext_t * copy_ext = lv_obj_get_ext(copy);
-    	ext->hfit_en = copy_ext->hfit_en;
-    	ext->vfit_en = copy_ext->vfit_en;
-    	ext->layout = copy_ext->layout;
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_rect);
-
-    }
-
-    return new_rect;
-}
-
-/**
- * Signal function of the container
- * @param cont pointer to a container object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_obj_signal(cont, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	switch(sign) {
-    	case LV_SIGNAL_STYLE_CHG: /*Recalculate the padding if the style changed*/
-        	lv_cont_refr_layout(cont);
-        	lv_cont_refr_autofit(cont);
-        	break;
-        case LV_SIGNAL_CHILD_CHG:
-        	lv_cont_refr_layout(cont);
-        	lv_cont_refr_autofit(cont);
-        	break;
-        case LV_SIGNAL_CORD_CHG:
-        	if(lv_obj_get_width(cont) != area_get_width(param) ||
-    		  lv_obj_get_height(cont) != area_get_height(param)) {
-            	lv_cont_refr_layout(cont);
-            	lv_cont_refr_autofit(cont);
-        	}
-        	break;
-    		default:
-    			break;
-    	}
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the layout on a container
- * @param cont pointer to a container object
- * @param layout a layout from 'lv_cont_layout_t'
- */
-void lv_cont_set_layout(lv_obj_t * cont, lv_cont_layout_t layout)
-{
-	lv_cont_ext_t * ext = lv_obj_get_ext(cont);
-	ext->layout = layout;
-
-	/*Send a signal to refresh the layout*/
-	cont->signal_f(cont, LV_SIGNAL_CHILD_CHG, NULL);
-}
-
-
-/**
- * Enable the horizontal or vertical fit.
- * The container size will be set to involve the children horizontally or vertically.
- * @param cont pointer to a container object
- * @param hor_en true: enable the horizontal padding
- * @param ver_en true: enable the vertical padding
- */
-void lv_cont_set_fit(lv_obj_t * cont, bool hor_en, bool ver_en)
-{
-	lv_obj_inv(cont);
-	lv_cont_ext_t * ext = lv_obj_get_ext(cont);
-	ext->hfit_en = hor_en == false ? 0 : 1;
-	ext->vfit_en = ver_en == false ? 0 : 1;
-
-	/*Send a signal to set a new size*/
-	cont->signal_f(cont, LV_SIGNAL_CORD_CHG, cont);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the layout of a container
- * @param cont pointer to container object
- * @return the layout from 'lv_cont_layout_t'
- */
-lv_cont_layout_t lv_cont_get_layout(lv_obj_t * cont)
-{
-	lv_cont_ext_t * ext = lv_obj_get_ext(cont);
-	return ext->layout;
-}
-
-/**
- * Get horizontal fit enable attribute of a container
- * @param cont pointer to a container object
- * @return true: horizontal padding is enabled
- */
-bool lv_cont_get_hfit(lv_obj_t * cont)
-{
-	lv_cont_ext_t * ext = lv_obj_get_ext(cont);
-	return ext->hfit_en == 0 ? false : true;
-}
-
-/**
- * Get vertical fit enable attribute of a container
- * @param cont pointer to a container object
- * @return true: vertical padding is enabled
- */
-bool lv_cont_get_vfit(lv_obj_t * cont)
-{
-	lv_cont_ext_t * ext = lv_obj_get_ext(cont);
-	return ext->vfit_en == 0 ? false : true;
-}
-
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-#if 0
-/**
- * Handle the drawing related tasks of the containers
- * @param cont pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_cont_design(lv_obj_t * cont, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-
-    	return false;
-    } else if(mode == LV_DESIGN_DRAW_MAIN) {
-
-
-    } else if(mode == LV_DESIGN_DRAW_POST) {
-
-    }
-    return true;
-}
-#endif
-
-
-/**
- * Refresh the layout of a container
- * @param cont pointer to an object which layout should be refreshed
- */
-static void lv_cont_refr_layout(lv_obj_t * cont)
-{
-	lv_cont_layout_t type = lv_cont_get_layout(cont);
-
-	/*'rect' has to be at least 1 child*/
-	if(lv_obj_get_child(cont, NULL) == NULL) return;
-
-	if(type == LV_CONT_LAYOUT_OFF) return;
-
-	if(type == LV_CONT_LAYOUT_CENTER) {
-		lv_cont_layout_center(cont);
-	} else if(type == LV_CONT_LAYOUT_COL_L || type == LV_CONT_LAYOUT_COL_M || type == LV_CONT_LAYOUT_COL_R) {
-		lv_cont_layout_col(cont);
-	} else if(type == LV_CONT_LAYOUT_ROW_T || type == LV_CONT_LAYOUT_ROW_M || type == LV_CONT_LAYOUT_ROW_B) {
-		lv_cont_layout_row(cont);
-	} else if(type == LV_CONT_LAYOUT_PRETTY) {
-		lv_cont_layout_pretty(cont);
-	}  else if(type == LV_CONT_LAYOUT_GRID) {
-		lv_cont_layout_grid(cont);
-	}
-}
-
-/**
- * Handle column type layouts
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_col(lv_obj_t * cont)
-{
-	lv_cont_layout_t type = lv_cont_get_layout(cont);
-	lv_obj_t * child;
-
-	/*Adjust margin and get the alignment type*/
-	lv_align_t align;
-	lv_style_t * style = lv_obj_get_style(cont);
-	cord_t hpad_corr;
-
-	switch(type) {
-		case LV_CONT_LAYOUT_COL_L:
-            hpad_corr = style->hpad;
-			align = LV_ALIGN_IN_TOP_LEFT;
-			break;
-		case LV_CONT_LAYOUT_COL_M:
-			hpad_corr = 0;
-			align = LV_ALIGN_IN_TOP_MID;
-			break;
-		case LV_CONT_LAYOUT_COL_R:
-			hpad_corr = -style->hpad;
-			align = LV_ALIGN_IN_TOP_RIGHT;
-			break;
-		default:
-			hpad_corr = 0;
-			align = LV_ALIGN_IN_TOP_LEFT;
-			break;
-	}
-
-	/* Disable child change action because the children will be moved a lot
-	 * an unnecessary child change signals could be sent*/
-	lv_obj_set_protect(cont, LV_PROTECT_CHILD_CHG);
-	/* Align the children */
-	cord_t last_cord = style->vpad;
-	LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false ||
-           lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-
-		lv_obj_align(child, cont, align, hpad_corr , last_cord);
-		last_cord += lv_obj_get_height(child) + style->opad;
-	}
-
-    lv_obj_clr_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle row type layouts
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_row(lv_obj_t * cont)
-{
-	lv_cont_layout_t type = lv_cont_get_layout(cont);
-	lv_obj_t * child;
-
-	/*Adjust margin and get the alignment type*/
-	lv_align_t align;
-	lv_style_t * style = lv_obj_get_style(cont);
-	cord_t vpad_corr = style->vpad;
-
-	switch(type) {
-		case LV_CONT_LAYOUT_ROW_T:
-			vpad_corr = style->vpad;
-			align = LV_ALIGN_IN_TOP_LEFT;
-			break;
-		case LV_CONT_LAYOUT_ROW_M:
-			vpad_corr = 0;
-			align = LV_ALIGN_IN_LEFT_MID;
-			break;
-		case LV_CONT_LAYOUT_ROW_B:
-			vpad_corr = -style->vpad;
-			align = LV_ALIGN_IN_BOTTOM_LEFT;
-			break;
-		default:
-			vpad_corr = 0;
-			align = LV_ALIGN_IN_TOP_LEFT;
-			break;
-	}
-
-	/* Disable child change action because the children will be moved a lot
-	 * an unnecessary child change signals could be sent*/
-    lv_obj_set_protect(cont, LV_PROTECT_CHILD_CHG);
-
-	/* Align the children */
-	cord_t last_cord = style->hpad;
-	LL_READ_BACK(cont->child_ll, child) {
-		if(lv_obj_get_hidden(child) != false ||
-           lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-
-		lv_obj_align(child, cont, align, last_cord, vpad_corr);
-		last_cord += lv_obj_get_width(child) + style->opad;
-	}
-
-    lv_obj_clr_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the center layout
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_center(lv_obj_t * cont)
-{
-	lv_obj_t * child;
-	lv_style_t * style = lv_obj_get_style(cont);
-	uint32_t obj_num = 0;
-	cord_t h_tot = 0;
-
-	LL_READ(cont->child_ll, child) {
-		h_tot += lv_obj_get_height(child) + style->opad;
-		obj_num ++;
-	}
-
-	if(obj_num == 0) return;
-
-	h_tot -= style->opad;
-
-	/* Disable child change action because the children will be moved a lot
-	 * an unnecessary child change signals could be sent*/
-    lv_obj_set_protect(cont, LV_PROTECT_CHILD_CHG);
-
-	/* Align the children */
-	cord_t last_cord = - (h_tot / 2);
-	LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false ||
-           lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-
-		lv_obj_align(child, cont, LV_ALIGN_CENTER, 0, last_cord + lv_obj_get_height(child) / 2);
-		last_cord += lv_obj_get_height(child) + style->opad;
-	}
-
-    lv_obj_clr_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the pretty layout. Put as many object as possible in row
- * then begin a new row
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_pretty(lv_obj_t * cont)
-{
-	lv_obj_t * child_rs;    /* Row starter child */
-	lv_obj_t * child_rc;    /* Row closer child */
-	lv_obj_t * child_tmp;   /* Temporary child */
-	lv_style_t * style = lv_obj_get_style(cont);
-	cord_t w_obj = lv_obj_get_width(cont);
-	cord_t act_y = style->vpad;
-	/* Disable child change action because the children will be moved a lot
-	 * an unnecessary child change signals could be sent*/
-
-	child_rs = ll_get_tail(&cont->child_ll); /*Set the row starter child*/
-	if(child_rs == NULL) return;	/*Return if no child*/
-
-    lv_obj_set_protect(cont, LV_PROTECT_CHILD_CHG);
-
-	child_rc = child_rs; /*Initially the the row starter and closer is the same*/
-	while(child_rs != NULL) {
-		cord_t h_row = 0;
-		cord_t w_row = style->hpad * 2; /*The width is at least the left+right hpad*/
-		uint32_t obj_num = 0;
-
-		/*Find the row closer object and collect some data*/
-		do {
-			if(lv_obj_get_hidden(child_rc) == false &&
-			   lv_obj_is_protected(child_rc, LV_PROTECT_POS) == false) {
-				if(w_row + lv_obj_get_width(child_rc) > w_obj) break; /*If the next object is already not fit then break*/
-				w_row += lv_obj_get_width(child_rc) + style->opad; /*Add the object width + opad*/
-				h_row = MATH_MAX(h_row, lv_obj_get_height(child_rc)); /*Search the highest object*/
-				obj_num ++;
-			}
-			child_rc = ll_get_prev(&cont->child_ll, child_rc); /*Load the next object*/
-			if(obj_num == 0) child_rs = child_rc; /*If the first object was hidden (or too long) then set the next as first */
-		}while(child_rc != NULL);
-
-		/*Step back one child because the last already not fit*/
-		if(child_rc != NULL  && obj_num != 0) child_rc = ll_get_next(&cont->child_ll, child_rc);
-
-		/*If the object is too long  then align it to the middle*/
-		if(obj_num == 0) {
-			if(child_rc != NULL) {
-				lv_obj_align(child_rc, cont, LV_ALIGN_IN_TOP_MID, 0, act_y);
-			}
-		}
-		/*If here is only one object in the row then align it to the left*/
-		else if (obj_num == 1) {
-			lv_obj_align(child_rs, cont, LV_ALIGN_IN_TOP_MID, 0, act_y);
-		}
-		/* Align the children (from child_rs to child_rc)*/
-		else {
-			w_row -= style->opad * obj_num;
-			cord_t new_opad = (w_obj -  w_row) / (obj_num  - 1);
-			cord_t act_x = style->hpad; /*x init*/
-			child_tmp = child_rs;
-			while(child_tmp != NULL) {
-				if(lv_obj_get_hidden(child_tmp) == false &&
-				   lv_obj_is_protected(child_tmp, LV_PROTECT_POS) == false) {
-					lv_obj_align(child_tmp, cont, LV_ALIGN_IN_TOP_LEFT, act_x, act_y);
-					act_x += lv_obj_get_width(child_tmp) + new_opad;
-				}
-				if(child_tmp == child_rc) break;
-				child_tmp = ll_get_prev(&cont->child_ll, child_tmp);
-			}
-
-		}
-
-		if(child_rc == NULL) break;
-		act_y += style->opad + h_row; /*y increment*/
-		child_rs = ll_get_prev(&cont->child_ll, child_rc); /*Go to the next object*/
-		child_rc = child_rs;
-	}
-    lv_obj_clr_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle the grid layout. Align same-sized objects in a grid
- * @param cont pointer to an object which layout should be handled
- */
-static void lv_cont_layout_grid(lv_obj_t * cont)
-{
-	lv_obj_t * child;
-	lv_style_t * style = lv_obj_get_style(cont);
-	cord_t w_tot = lv_obj_get_width(cont);
-	cord_t w_obj = lv_obj_get_width(lv_obj_get_child(cont, NULL));
-	cord_t h_obj = lv_obj_get_height(lv_obj_get_child(cont, NULL));
-	uint16_t obj_row = (w_tot - (2 * style->hpad)) / (w_obj + style->opad); /*Obj. num. in a row*/
-	cord_t x_ofs;
-	if(obj_row > 1) {
-		x_ofs = w_obj + (w_tot - (2 * style->hpad) - (obj_row * w_obj)) / (obj_row - 1);
-	} else {
-		x_ofs = w_tot / 2 - w_obj / 2;
-	}
-	cord_t y_ofs = h_obj + style->opad;
-
-	/* Disable child change action because the children will be moved a lot
-	 * an unnecessary child change signals could be sent*/
-    lv_obj_set_protect(cont, LV_PROTECT_CHILD_CHG);
-
-	/* Align the children */
-	cord_t act_x = style->hpad;
-	cord_t act_y = style->vpad;
-	uint16_t obj_cnt = 0;
-	LL_READ_BACK(cont->child_ll, child) {
-        if(lv_obj_get_hidden(child) != false ||
-           lv_obj_is_protected(child, LV_PROTECT_POS) != false) continue;
-
-		if(obj_row > 1) {
-			lv_obj_set_pos(child, act_x, act_y);
-			act_x += x_ofs;
-		} else {
-			lv_obj_set_pos(child, x_ofs, act_y);
-		}
-		obj_cnt ++;
-
-		if(obj_cnt >= obj_row) {
-			obj_cnt = 0;
-			act_x = style->hpad;
-			act_y += y_ofs;
-		}
-	}
-
-    lv_obj_clr_protect(cont, LV_PROTECT_CHILD_CHG);
-}
-
-/**
- * Handle auto fit. Set the size of the object to involve all children.
- * @param cont pointer to an object which size will be modified
- */
-static void lv_cont_refr_autofit(lv_obj_t * cont)
-{
-	lv_cont_ext_t * ext = lv_obj_get_ext(cont);
-
-	if(ext->hfit_en == 0 &&
-	   ext->vfit_en == 0) {
-		return;
-	}
-
-	area_t new_cords;
-	area_t ori;
-	lv_style_t * style = lv_obj_get_style(cont);
-	lv_obj_t * i;
-	cord_t hpad = style->hpad;
-	cord_t vpad = style->vpad;
-
-	/*Search the side coordinates of the children*/
-	lv_obj_get_cords(cont, &ori);
-	lv_obj_get_cords(cont, &new_cords);
-
-	new_cords.x1 = CORD_MAX;
-	new_cords.y1 = CORD_MAX;
-	new_cords.x2 = CORD_MIN;
-	new_cords.y2 = CORD_MIN;
-
-    LL_READ(cont->child_ll, i) {
-		if(lv_obj_get_hidden(i) != false) continue;
-    	new_cords.x1 = MATH_MIN(new_cords.x1, i->cords.x1);
-    	new_cords.y1 = MATH_MIN(new_cords.y1, i->cords.y1);
-        new_cords.x2 = MATH_MAX(new_cords.x2, i->cords.x2);
-        new_cords.y2 = MATH_MAX(new_cords.y2, i->cords.y2);
-    }
-
-    /*If the value is not the init value then the page has >=1 child.*/
-    if(new_cords.x1 != CORD_MAX) {
-    	if(ext->hfit_en != 0) {
-			new_cords.x1 -= hpad;
-			new_cords.x2 += hpad;
-    	} else {
-    		new_cords.x1 = cont->cords.x1;
-    		new_cords.x2 = cont->cords.x2;
-    	}
-    	if(ext->vfit_en != 0) {
-			new_cords.y1 -= vpad;
-			new_cords.y2 += vpad;
-    	} else {
-    		new_cords.y1 = cont->cords.y1;
-    		new_cords.y2 = cont->cords.y2;
-    	}
-
-    	/*Do nothing if the coordinates are not changed*/
-    	if(cont->cords.x1 != new_cords.x1 ||
-    	   cont->cords.y1 != new_cords.y1 ||
-           cont->cords.x2 != new_cords.x2 ||
-           cont->cords.y2 != new_cords.y2) {
-
-            lv_obj_inv(cont);
-            area_cpy(&cont->cords, &new_cords);
-            lv_obj_inv(cont);
-
-            /*Notify the object about its new coordinates*/
-            cont->signal_f(cont, LV_SIGNAL_CORD_CHG, &ori);
-
-            /*Inform the parent about the new coordinates*/
-            lv_obj_t * par = lv_obj_get_parent(cont);
-            par->signal_f(par, LV_SIGNAL_CHILD_CHG, cont);
-    	}
-    }
-}
-
-#endif

lv_objx/lv_cont.h

@@ -1,112 +0,0 @@
-/**
- * @file lv_cont.h
- * 
- */
-
-#ifndef LV_CONT_H
-#define LV_CONT_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_CONT != 0
-
-#include "../lv_obj/lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Layout options*/
-typedef enum
-{
-	LV_CONT_LAYOUT_OFF = 0,
-	LV_CONT_LAYOUT_CENTER,
-	LV_CONT_LAYOUT_COL_L,	/*Column left align*/
-	LV_CONT_LAYOUT_COL_M,	/*Column middle align*/
-	LV_CONT_LAYOUT_COL_R,	/*Column right align*/
-	LV_CONT_LAYOUT_ROW_T,	/*Row top align*/
-	LV_CONT_LAYOUT_ROW_M,	/*Row middle align*/
-	LV_CONT_LAYOUT_ROW_B,	/*Row bottom align*/
-	LV_CONT_LAYOUT_PRETTY,	/*Put as many object as possible in row and begin a new row*/
-	LV_CONT_LAYOUT_GRID,	/*Align same-sized object into a grid*/
-}lv_cont_layout_t;
-
-typedef struct
-{
-    /*Inherited from 'base_obj' so no inherited ext. */ /*Ext. of ancestor*/
-    /*New data for this type */
-    uint8_t layout  :5;     /*A layout from 'lv_cont_layout_t' enum*/
-    uint8_t hfit_en :1;     /*Enable horizontal padding to involve all children*/
-    uint8_t vfit_en :1;     /*Enable horizontal padding to involve all children*/
-}lv_cont_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a container objects
- * @param par pointer to an object, it will be the parent of the new container
- * @param copy pointer to a container object, if not NULL then the new object will be copied from it
- * @return pointer to the created container
- */
-lv_obj_t * lv_cont_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the container
- * @param cont pointer to a container object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_cont_signal(lv_obj_t * cont, lv_signal_t sign, void * param);
-
-/**
- * Set the layout on a container
- * @param cont pointer to a container object
- * @param layout a layout from 'lv_cont_layout_t'
- */
-void lv_cont_set_layout(lv_obj_t * cont, lv_cont_layout_t layout);
-
-/**
- * Enable the horizontal or vertical fit.
- * The container size will be set to involve the children horizontally or vertically.
- * @param cont pointer to a container object
- * @param hor_en true: enable the horizontal padding
- * @param ver_en true: enable the vertical padding
- */
-void lv_cont_set_fit(lv_obj_t * cont, bool hor_en, bool ver_en);
-
-/**
- * Get the layout of a container
- * @param cont pointer to container object
- * @return the layout from 'lv_cont_layout_t'
- */
-lv_cont_layout_t lv_cont_get_layout(lv_obj_t * cont);
-
-/**
- * Get horizontal fit enable attribute of a container
- * @param cont pointer to a container object
- * @return true: horizontal padding is enabled
- */
-bool lv_cont_get_hfit(lv_obj_t * cont);
-
-/**
- * Get vertical fit enable attribute of a container
- * @param cont pointer to a container object
- * @return true: vertical padding is enabled
- */
-bool lv_cont_get_vfit(lv_obj_t * cont);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_ddlist.c

@@ -1,445 +0,0 @@
-/**
- * @file lv_ddlist.c
- * 
- */
-
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_DDLIST != 0
-
-#include "lv_ddlist.h"
-#include "../lv_draw/lv_draw.h"
-#include "misc/gfx/anim.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_DDLIST_DEF_ANIM_TIME 200 /*ms*/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_ddlist_design(lv_obj_t * ddlist, const area_t * mask, lv_design_mode_t mode);
-static lv_action_res_t lv_ddlist_rel_action(lv_obj_t * ddlist, lv_dispi_t * dispi);
-static void lv_ddlist_refr_size(lv_obj_t * ddlist, uint16_t anim_time);
-static void lv_ddlist_pos_act_option(lv_obj_t * ddlist);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_f_t  ancestor_design_f;
-static const char * def_options[] = {"Option 1", "Option 2", "Option 3", ""};
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a drop down list objects
- * @param par pointer to an object, it will be the parent of the new drop down list
- * @param copy pointer to a drop down list object, if not NULL then the new object will be copied from it
- * @return pointer to the created drop down list
- */
-lv_obj_t * lv_ddlist_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor drop down list*/
-    lv_obj_t * new_ddlist = lv_page_create(par, copy);
-    dm_assert(new_ddlist);
-    
-    /*Allocate the drop down list type specific extended data*/
-    lv_ddlist_ext_t * ext = lv_obj_alloc_ext(new_ddlist, sizeof(lv_ddlist_ext_t));
-    dm_assert(ext);
-
-    /*Initialize the allocated 'ext' */
-    ext->opt_label = NULL;
-    ext->cb = NULL;
-    ext->opened = 0;
-    ext->auto_size = 0;
-    ext->sel_opt = 0;
-    ext->anim_time = LV_DDLIST_DEF_ANIM_TIME;
-    ext->style_sel = lv_style_get(LV_STYLE_PLAIN_COLOR, NULL);
-
-    /*The signal and design functions are not copied so set them here*/
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_f(new_ddlist);
-
-    lv_obj_set_signal_f(new_ddlist, lv_ddlist_signal);
-    lv_obj_set_design_f(new_ddlist, lv_ddlist_design);
-
-    /*Init the new drop down list drop down list*/
-    if(copy == NULL) {
-        lv_obj_t * scrl = lv_page_get_scrl(new_ddlist);
-        lv_obj_set_drag(scrl, false);
-        lv_obj_set_style(scrl, lv_style_get(LV_STYLE_TRANSP, NULL));
-
-        ext->opt_label = lv_label_create(new_ddlist, NULL);
-        lv_cont_set_fit(new_ddlist, true, false);
-        lv_page_set_rel_action(new_ddlist, lv_ddlist_rel_action);
-        lv_page_set_sb_mode(new_ddlist, LV_PAGE_SB_MODE_DRAG);
-        lv_obj_set_style(new_ddlist, lv_style_get(LV_STYLE_PRETTY, NULL));
-        lv_ddlist_set_options(new_ddlist, def_options);
-    }
-    /*Copy an existing drop down list*/
-    else {
-    	lv_ddlist_ext_t * copy_ext = lv_obj_get_ext(copy);
-        ext->opt_label = lv_label_create(new_ddlist, copy_ext->opt_label);
-        lv_label_set_text(ext->opt_label, lv_label_get_text(copy_ext->opt_label));
-        ext->sel_opt = copy_ext->sel_opt;
-        ext->auto_size = copy_ext->auto_size;
-        ext->cb = copy_ext->cb;
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_ddlist);
-    }
-    
-    return new_ddlist;
-}
-
-/**
- * Signal function of the drop down list
- * @param ddlist pointer to a drop down list object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_ddlist_signal(lv_obj_t * ddlist, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_page_signal(ddlist, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	if(sign == LV_SIGNAL_STYLE_CHG) {
-    	    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    	    lv_obj_set_style(ext->opt_label, lv_obj_get_style(ddlist));
-            lv_ddlist_refr_size(ddlist, 0);
-    	}
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the options in a drop down list
- * @param ddlist pointer to drop down list object
- * @param options an array of strings wit the text of the options.
- *                The lest element has to be "" (empty string)
- *                E.g. const char * opts[] = {"apple", "banana", "orange", ""};
- */
-void lv_ddlist_set_options(lv_obj_t * ddlist, const char ** options)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-
-    lv_label_set_text(ext->opt_label, "");
-    uint16_t i = 0;
-    while(options[i][0] != '\0') {
-        lv_label_append_text(ext->opt_label, options[i]);
-        if(options[i + 1][0] != '\0') lv_label_append_text(ext->opt_label, "\n");
-        i++;
-    }
-
-    lv_ddlist_refr_size(ddlist, 0);
-}
-
-/**
- * Set the selected option
- * @param ddlist pointer to drop down list object
- * @param sel_opt id of the selected option (0 ... number of option - 1);
- */
-void lv_ddlist_set_selected(lv_obj_t * ddlist, uint16_t sel_opt)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-
-    ext->sel_opt = sel_opt;
-
-    /*Move the list to show the current option*/
-    if(ext->opened == 0) {
-        lv_ddlist_pos_act_option(ddlist);
-    }
-}
-
-/**
- * Set a function to call when a new option is chosen
- * @param ddlist pointer to a drop down list
- * @param cb pointer to a call back function
- */
-void lv_ddlist_set_action(lv_obj_t * ddlist, lv_action_t cb)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    ext->cb = cb;
-}
-
-/**
- * Set the auto size attribute. If enabled the height will reduced to be visible on the parent.
- * In this case the drop down list can be scrolled.
- * @param ddlist pointer to a drop down list
- * @param auto_size true: enable auto size, false: disable
- */
-void lv_ddlist_set_auto_size(lv_obj_t * ddlist, bool auto_size)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    ext->auto_size = auto_size == false ? 0 : 1;
-}
-
-/**
- * Set the open/close animation time.
- * @param ddlist pointer to a drop down list
- * @param anim_time: open/close animation time [ms]
- */
-void lv_ddlist_set_anim_time(lv_obj_t * ddlist, uint16_t anim_time)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    ext->anim_time = anim_time;
-}
-
-/**
- * Set the style of the rectangle on the selected option
- * @param ddlist pointer to a drop down list object
- * @param style pointer the new style of the select rectangle
- */
-void lv_dlist_set_style_select(lv_obj_t * ddlist, lv_style_t * style)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    ext->style_sel = style;
-
-}
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the options of a drop down list
- * @param ddlist pointer to drop down list object
- * @return the options separated by '\n'-s (E.g. "Option1\nOption2\nOption3")
- */
-const char * lv_ddlist_get_options(lv_obj_t * ddlist)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    return lv_label_get_text(ext->opt_label);
-}
-
-/**
- * Get the selected option
- * @param ddlist pointer to drop down list object
- * @return id of the selected option (0 ... number of option - 1);
- */
-uint16_t lv_ddlist_get_selected(lv_obj_t * ddlist)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-
-    return ext->sel_opt;
-}
-
-/**
- * Get the auto size attribute.
- * @param ddlist pointer to a drop down list object
- * @return true: the auto_size is enabled, false: disabled
- */
-bool lv_ddlist_get_auto_size(lv_obj_t * ddlist, bool auto_size)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    return ext->auto_size == 0 ? false : true;
-}
-
-/**
- * Get the style of the rectangle on the selected option
- * @param ddlist pointer to a drop down list object
- * @return pointer the style of the select rectangle
- */
-lv_style_t * lv_ddlist_get_style_select(lv_obj_t * ddlist)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    if(ext->style_sel == NULL) return lv_obj_get_style(ddlist);
-
-    return ext->style_sel;
-}
-/**
- * Get the open/close animation time.
- * @param ddlist pointer to a drop down list
- * @return open/close animation time [ms]
- */
-uint16_t lv_ddlist_get_anim_time(lv_obj_t * ddlist)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    return ext->anim_time;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the drop down lists
- * @param ddlist pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_ddlist_design(lv_obj_t * ddlist, const area_t * mask, lv_design_mode_t mode)
-{
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	return ancestor_design_f(ddlist, mask, mode);
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        ancestor_design_f(ddlist, mask, mode);
-
-        /*If the list is opened draw a rectangle below the selected item*/
-        lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-        if(ext->opened != 0) {
-            lv_style_t * style = lv_obj_get_style(ddlist);
-            const font_t * font = style->font;
-            cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS;
-            area_t rect_area;
-            lv_style_t * style_page_scrl = lv_obj_get_style(lv_page_get_scrl(ddlist));
-            rect_area.y1 = ext->opt_label->cords.y1;
-            rect_area.y1 += ext->sel_opt * (font_h + style->line_space);
-            rect_area.y1 -= style->line_space / 2;
-
-            rect_area.y2 = rect_area.y1 + font_h + style->line_space;
-            rect_area.x1 = ext->opt_label->cords.x1 - style_page_scrl->hpad;
-            rect_area.x2 = rect_area.x1 + lv_obj_get_width(lv_page_get_scrl(ddlist));
-
-            lv_draw_rect(&rect_area, mask, ext->style_sel);
-        }
-    }
-    /*Post draw when the children are drawn*/
-    else if(mode == LV_DESIGN_DRAW_POST) {
-        ancestor_design_f(ddlist, mask, mode);
-    }
-
-    return true;
-}
-
-/**
- * Called when a drop down list is released to open it or set new option
- * @param ddlist pointer to a drop down list object
- * @param dispi pointer to the called display input
- * @return LV_ACTION_RES_INV if the ddlist it deleted in the user callback else LV_ACTION_RES_OK
- */
-static lv_action_res_t lv_ddlist_rel_action(lv_obj_t * ddlist, lv_dispi_t * dispi)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-
-    if(ext->opened == 0) { /*Open the list*/
-        ext->opened = 1;
-        lv_obj_set_drag(lv_page_get_scrl(ddlist), true);
-    } else {
-        ext->opened = 0;
-        lv_obj_set_drag(lv_page_get_scrl(ddlist), false);
-
-        /*Search the clicked option*/
-        point_t p;
-        lv_dispi_get_point(dispi, &p);
-        p.x -= ext->opt_label->cords.x1;
-        p.y -= ext->opt_label->cords.y1;
-        uint16_t letter_i;
-        letter_i = lv_label_get_letter_on(ext->opt_label, &p);
-
-        uint16_t new_opt = 0;
-        const char * txt = lv_label_get_text(ext->opt_label);
-        uint16_t i;
-        for(i = 0; i < letter_i; i++) {
-            if(txt[i] == '\n') new_opt ++;
-        }
-
-        ext->sel_opt = new_opt;
-
-        if(ext->cb != NULL) {
-            ext->cb(ddlist, dispi);
-        }
-    }
-    lv_ddlist_refr_size(ddlist, ext->anim_time);
-
-    return LV_ACTION_RES_OK;
-
-}
-
-/**
- * Refresh the size of drop down list according its start (open or closed)
- * @param ddlist pointer to a drop down list object
- * @param anim_time animations time for open/close [ms]
- */
-static void lv_ddlist_refr_size(lv_obj_t * ddlist, uint16_t anim_time)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    lv_style_t * style = lv_obj_get_style(ddlist);
-    cord_t new_height;
-    if(ext->opened != 0) { /*Open the list*/
-        new_height = lv_obj_get_height(lv_page_get_scrl(ddlist)) + 2 * style->vpad;
-        lv_obj_t * parent = lv_obj_get_parent(ddlist);
-        /*Reduce the height if enabled and required*/
-        if(ext->auto_size != 0 && new_height + ddlist->cords.y1 > parent->cords.y2) {
-            new_height = parent->cords.y2 - ddlist->cords.y1;
-        }
-    } else { /*Close the list*/
-        const font_t * font = style->font;
-        lv_style_t * label_style = lv_obj_get_style(ext->opt_label);
-        cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS;
-        new_height = font_h + 2 * label_style->line_space;
-    }
-    if(anim_time == 0) {
-        lv_obj_set_height(ddlist, new_height);
-        lv_ddlist_pos_act_option(ddlist);
-    } else {
-        anim_t a;
-        a.var = ddlist;
-        a.start = lv_obj_get_height(ddlist);
-        a.end = new_height;
-        a.fp = (anim_fp_t)lv_obj_set_height;
-        a.path = anim_get_path(ANIM_PATH_LIN);
-        a.end_cb = (anim_cb_t)lv_ddlist_pos_act_option;
-        a.act_time = 0;
-        a.time = ext->anim_time;
-        a.playback = 0;
-        a.playback_pause = 0;
-        a.repeat = 0;
-        a.repeat_pause = 0;
-
-        anim_create(&a);
-    }
-}
-
-/**
- * Set the position of list when it is closed to show the selected item
- * @param ddlist pointer to a drop down list
- */
-static void lv_ddlist_pos_act_option(lv_obj_t * ddlist)
-{
-    lv_ddlist_ext_t * ext = lv_obj_get_ext(ddlist);
-    lv_style_t * style = lv_obj_get_style(ddlist);
-    const font_t * font = style->font;
-    cord_t font_h = font_get_height(font) >> FONT_ANTIALIAS;
-    lv_style_t * label_style = lv_obj_get_style(ext->opt_label);
-    lv_obj_t * scrl = lv_page_get_scrl(ddlist);
-    lv_style_t * style_scrl = lv_obj_get_style(scrl);
-
-    lv_obj_set_y(scrl, -(ext->sel_opt * (font_h + label_style->line_space) - label_style->line_space) - style_scrl->hpad);
-
-}
-
-#endif

lv_objx/lv_ddlist.h

@@ -1,144 +0,0 @@
-/**
- * @file lv_ddlist.h
- * 
- */
-
-#ifndef LV_DDLIST_H
-#define LV_DDLIST_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_DDLIST != 0
-
-/*Testing of dependencies*/
-#if USE_LV_PAGE == 0
-#error "lv_ddlist: lv_page is required. Enable it in lv_conf.h (USE_LV_PAGE  1) "
-#endif
-
-#if USE_LV_LABEL == 0
-#error "lv_ddlist: lv_label is required. Enable it in lv_conf.h (USE_LV_LABEL  1) "
-#endif
-
-#include "../lv_obj/lv_obj.h"
-#include "../lv_objx/lv_page.h"
-#include "../lv_objx/lv_label.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-/*Data of drop down list*/
-typedef struct
-{
-    lv_page_ext_t page; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * opt_label;                           /*Label for the options*/
-    lv_style_t * style_sel;                         /*Style of the selected option*/
-    lv_action_t cb;                                 /*Pointer to function to call when an option is slected*/
-    uint16_t sel_opt;                               /*Index of the current option*/
-    uint16_t anim_time;                             /*Open/Close animation time [ms]*/
-    uint8_t opened :1;                              /*1: The list is opened*/
-    uint8_t auto_size :1;                           /*1: Set height to show all options. 0: Set height maximum to the parent bottom*/
-}lv_ddlist_ext_t;
-
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a drop down list objects
- * @param par pointer to an object, it will be the parent of the new drop down list
- * @param copy pointer to a drop down list object, if not NULL then the new object will be copied from it
- * @return pointer to the created drop down list
- */
-lv_obj_t * lv_ddlist_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the drop down list
- * @param ddlist pointer to a drop down list object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_ddlist_signal(lv_obj_t * ddlist, lv_signal_t sign, void * param);
-
-/**
- * Set the options in a drop down list
- * @param ddlist pointer to drop down list object
- * @param options an array of strings wit the text of the options.
- *                The lest element has to be "" (empty string)
- *                E.g. const char * opts[] = {"apple", "banana", "orange", ""};
- */
-void lv_ddlist_set_options(lv_obj_t * ddlist, const char ** options);
-
-/**
- * Set the selected option
- * @param ddlist pointer to drop down list object
- * @param sel_opt id of the selected option (0 ... number of option - 1);
- */
-void lv_ddlist_set_selected(lv_obj_t * ddlist, uint16_t sel_opt);
-
-
-/**
- * Set a function to call when a new option is chosen
- * @param ddlist pointer to a drop down list
- * @param cb pointer to a call back function
- */
-void lv_ddlist_set_action(lv_obj_t * ddlist, lv_action_t cb);
-
-/**
- * Set the auto size attribute. If enabled the height will reduced to be visible on the parent.
- * In this case the drop down list can be scrolled.
- * @param ddlist pointer to a drop down list
- * @param auto_size true: enable auto size, false: disable
- */
-void lv_ddlist_set_auto_size(lv_obj_t * ddlist, bool auto_size);
-
-/**
- * Set the style of the rectangle on the selected option
- * @param ddlist pointer to a drop down list object
- * @param style pointer the new style of the select rectangle
- */
-void lv_dlist_set_style_select(lv_obj_t * ddlist, lv_style_t * style);
-
-/**
- * Get the options of a drop down list
- * @param ddlist pointer to drop down list object
- * @return the options separated by '\n'-s (E.g. "Option1\nOption2\nOption3")
- */
-const char * lv_ddlist_get_options(lv_obj_t * ddlist);
-
-/**
- * Get the selected option
- * @param ddlist pointer to drop down list object
- * @return id of the selected option (0 ... number of option - 1);
- */
-uint16_t lv_ddlist_get_selected(lv_obj_t * ddlist);
-
-/**
- * Get the auto size attribute.
- * @param ddlist pointer to a drop down list object
- * @return true: the auto_size is enabled, false: disabled
- */
-bool lv_ddlist_get_auto_size(lv_obj_t * ddlist, bool auto_size);
-
-/**
- * Get the style of the rectangle on the selected option
- * @param ddlist pointer to a drop down list object
- * @return pointer the style of the select rectangle
- */
-lv_style_t * lv_ddlist_get_style_select(lv_obj_t * ddlist);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_gauge.c

@@ -1,457 +0,0 @@
-/**
- * @file lv_gauge.c
- * 
- */
-
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_GAUGE != 0
-
-#include "lv_gauge.h"
-#include "../lv_draw/lv_draw.h"
-#include "misc/gfx/text.h"
-#include "misc/math/trigo.h"
-#include "misc/math/math_base.h"
-#include <stdio.h>
-#include <string.h>
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_GAUGE_DEF_NEEDLE_COLOR   COLOR_RED
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_gauge_design(lv_obj_t * gauge, const area_t * mask, lv_design_mode_t mode);
-static void lv_gauge_draw_scale(lv_obj_t * gauge, const area_t * mask, lv_style_t * style);
-static void lv_gauge_draw_needle(lv_obj_t * gauge, const area_t * mask, lv_style_t * style);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_f_t ancestor_design_f = NULL;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a gauge objects
- * @param par pointer to an object, it will be the parent of the new gauge
- * @param copy pointer to a gauge object, if not NULL then the new object will be copied from it
- * @return pointer to the created gauge
- */
-lv_obj_t * lv_gauge_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor gauge*/
-    lv_obj_t * new_gauge = lv_lmeter_create(par, copy);
-    dm_assert(new_gauge);
-    
-    /*Allocate the gauge type specific extended data*/
-    lv_gauge_ext_t * ext = lv_obj_alloc_ext(new_gauge, sizeof(lv_gauge_ext_t));
-    dm_assert(ext);
-
-    /*Initialize the allocated 'ext' */
-    ext->needle_num = 0;
-    ext->values = NULL;
-    ext->needle_colors = NULL;
-    ext->low_critical = 0;
-    ext->style_critical = lv_style_get(LV_STYLE_PRETTY_COLOR, NULL);
-
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_f(new_gauge);
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_f(new_gauge, lv_gauge_signal);
-    lv_obj_set_design_f(new_gauge, lv_gauge_design);
-
-    /*Init the new gauge gauge*/
-    if(copy == NULL) {
-        lv_lmeter_set_scale(new_gauge, 220, 6);
-        lv_gauge_set_needle_num(new_gauge, 1, NULL);
-        lv_obj_set_size(new_gauge, 2 * LV_DPI, 2 * LV_DPI);
-        lv_obj_set_style(new_gauge, lv_style_get(LV_STYLE_PRETTY, NULL));
-    }
-    /*Copy an existing gauge*/
-    else {
-    	lv_gauge_ext_t * copy_ext = lv_obj_get_ext(copy);
-        ext->low_critical = copy_ext->low_critical;
-        lv_gauge_set_style_critical(new_gauge, lv_gauge_get_style_critical(copy));
-        lv_gauge_set_needle_num(new_gauge, copy_ext->needle_num, copy_ext->needle_colors);
-
-        uint8_t i;
-        for(i = 0; i < ext->needle_num; i++) {
-            ext->values[i] = copy_ext->values[i];
-        }
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_gauge);
-    }
-    
-    return new_gauge;
-}
-
-/**
- * Signal function of the gauge
- * @param gauge pointer to a gauge object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_gauge_signal(lv_obj_t * gauge, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_lmeter_signal(gauge, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-        lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-    	if(sign == LV_SIGNAL_CLEANUP) {
-            dm_free(ext->values);
-            ext->values = NULL;
-    	}
-    	else if(sign == LV_SIGNAL_REFR_EXT_SIZE) {
-    	    lv_style_t * style_crit = lv_gauge_get_style_critical(gauge);
-            if(style_crit->swidth > gauge->ext_size) gauge->ext_size = style_crit->swidth;
-    	}
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the number of needles
- * @param gauge pointer to gauge object
- * @param num number of needles
- * @param colors an array of colors for needles (with 'num' elements)
- */
-void lv_gauge_set_needle_num(lv_obj_t * gauge, uint8_t num, color_t * colors)
-{
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-    if(ext->values != NULL) {
-        dm_free(ext->values);
-        ext->values = NULL;
-    }
-
-    ext->values = dm_realloc(ext->values, num * sizeof(int16_t));
-
-    int16_t min = lv_bar_get_min_value(gauge);
-    uint8_t n;
-    for(n = ext->needle_num; n < num; n++) {
-        ext->values[n] = min;
-    }
-
-    ext->needle_num = num;
-    ext->needle_colors = colors;
-    lv_obj_inv(gauge);
-}
-
-
-/**
- * Set the value of a needle
- * @param gauge pointer to gauge
- * @param needle the id of the needle
- * @param value the new value
- */
-void lv_gauge_set_value(lv_obj_t * gauge, uint8_t needle, int16_t value)
-{
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-
-    if(needle >= ext->needle_num) return;
-
-    int16_t min = lv_bar_get_min_value(gauge);
-    int16_t max = lv_bar_get_max_value(gauge);
-
-    if(value > max) value = max;
-    else if(value < min) value = min;
-
-    ext->values[needle] = value;
-
-    /*To be consistent with bar set the first needle's value for the bar*/
-    if(needle == 0) lv_bar_set_value(gauge, value);
-
-    lv_obj_inv(gauge);
-}
-
-/**
- * Set which value is more critical (lower or higher)
- * @param gauge pointer to a gauge object
- * @param low false: higher / true: lower value is more critical
- */
-void lv_gauge_set_low_critical(lv_obj_t * gauge, bool low)
-{
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-
-    ext->low_critical = low == false ? 0 : 1;
-
-    lv_obj_inv(gauge);
-}
-
-/**
- * Set the critical style of the gauge
- * @param gauge pointer to a gauge object
- * @param style pointer to the new critical style
- */
-void lv_gauge_set_style_critical(lv_obj_t * gauge, lv_style_t * style)
-{
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-    ext->style_critical = style;
-    gauge->signal_f(gauge, LV_SIGNAL_REFR_EXT_SIZE, NULL);
-    lv_obj_inv(gauge);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the number of needles on a gauge
- * @param gauge pointer to gauge
- * @return number of needles
- */
-uint8_t lv_gauge_get_needle_num(lv_obj_t * gauge)
-{
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-    return ext->needle_num;
-}
-
-/**
- * Get the value of a needle
- * @param gauge pointer to gauge object
- * @param needle the id of the needle
- * @return the value of the needle [min,max]
- */
-int16_t lv_gauge_get_value(lv_obj_t * gauge,  uint8_t needle)
-{
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-    int16_t min = lv_bar_get_min_value(gauge);
-
-    if(needle >= ext->needle_num) return min;
-
-    return ext->values[needle];
-}
-
-/**
- * Get which value is more critical (lower or higher)
- * @param gauge pointer to a gauge object
- * @param low false: higher / true: lower value is more critical
- */
-bool lv_gauge_get_low_critical(lv_obj_t * gauge)
-{
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-
-    return ext->low_critical == 0 ? false : true;
-}
-
-/**
- * Get the critical style of the gauge
- * @param gauge pointer to a gauge object
- * @return pointer to the critical style
- */
-lv_style_t * lv_gauge_get_style_critical(lv_obj_t * gauge)
-{
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-
-    if(ext->style_critical == NULL) return lv_obj_get_style(gauge);
-
-    return ext->style_critical;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the gauges
- * @param gauge pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_gauge_design(lv_obj_t * gauge, const area_t * mask, lv_design_mode_t mode)
-{
-
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	return false;
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        lv_style_t * style_base = lv_obj_get_style(gauge);
-        lv_style_t * style_critical = lv_gauge_get_style_critical(gauge);
-        lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-
-        /* Draw the background
-         * Re-color the gauge according to the critical value*/
-        lv_style_t style_bg;
-        int16_t min = lv_bar_get_min_value(gauge);
-        int16_t max = lv_bar_get_max_value(gauge);
-
-        /*To be consistent with bar use the bar value as the first needle*/
-        if(ext->needle_num  != 0) {
-            ext->values[0] = lv_bar_get_value(gauge);
-        }
-
-        int16_t critical_val = ext->low_critical == 0 ? min : max;
-        uint8_t i;
-
-        for(i = 0; i < ext->needle_num; i++) {
-            critical_val = ext->low_critical == 0 ? MATH_MAX(critical_val, ext->values[i]) : MATH_MIN(critical_val, ext->values[i]);
-        }
-
-        opa_t ratio = ((critical_val - min) * OPA_COVER) / (max - min);
-
-        if(ext->low_critical != 0) ratio = OPA_COVER - ratio;
-
-        /*Mix the normal and the critical style*/
-        memcpy(&style_bg, style_base, sizeof(lv_style_t));
-        style_bg.ccolor = color_mix(style_critical->ccolor, style_base->ccolor, ratio);
-        style_bg.mcolor= color_mix(style_critical->mcolor, style_base->mcolor, ratio);
-        style_bg.gcolor = color_mix(style_critical->gcolor, style_base->gcolor, ratio);
-        style_bg.bcolor = color_mix(style_critical->bcolor, style_base->bcolor, ratio);
-        style_bg.scolor = color_mix(style_critical->scolor, style_base->scolor, ratio);
-        style_bg.swidth = (cord_t)(((cord_t)style_critical->swidth * ratio) + ((cord_t)style_base->swidth * (OPA_COVER - ratio))) >> 8;
-        style_bg.opa = (cord_t)(((uint16_t)style_critical->opa * ratio) + ((uint16_t)style_base->opa * (OPA_COVER - ratio))) >> 8;
-
-        lv_draw_rect(&gauge->cords, mask, &style_bg);
-
-        lv_gauge_draw_scale(gauge, mask, &style_bg);
-
-        lv_gauge_draw_needle(gauge, mask, &style_bg);
-    }
-    /*Post draw when the children are drawn*/
-    else if(mode == LV_DESIGN_DRAW_POST) {
-        ancestor_design_f(gauge, mask, mode);
-    }
-
-    return true;
-}
-
-/**
- * Draw the scale on a gauge
- * @param gauge pointer to gauge object
- * @param mask mask of drawing
- */
-static void lv_gauge_draw_scale(lv_obj_t * gauge, const area_t * mask, lv_style_t * style)
-{
-    char scale_txt[16];
-
-    cord_t r = lv_obj_get_width(gauge) / 2 - style->hpad;
-    cord_t x_ofs = lv_obj_get_width(gauge) / 2 + gauge->cords.x1;
-    cord_t y_ofs = lv_obj_get_height(gauge) / 2 + gauge->cords.y1;
-    int16_t scale_angle = lv_lmeter_get_scale_angle(gauge);
-    uint16_t scale_num = lv_lmeter_get_scale_num(gauge);
-    int16_t angle_ofs = 90 + (360 - scale_angle) / 2;
-    int16_t min = lv_bar_get_min_value(gauge);
-    int16_t max = lv_bar_get_max_value(gauge);
-
-    uint8_t i;
-    for(i = 0; i < scale_num; i++) {
-        /*Calculate the position a scale label*/
-        int16_t angle = (i * scale_angle) / (scale_num - 1) + angle_ofs;
-
-        cord_t y = (int32_t)((int32_t)trigo_sin(angle) * r) / TRIGO_SIN_MAX;
-        y += y_ofs;
-
-        cord_t x = (int32_t)((int32_t)trigo_sin(angle + 90) * r) / TRIGO_SIN_MAX;
-        x += x_ofs;
-
-        int16_t scale_act = (int32_t)((int32_t)(max - min) * i) /  (scale_num - 1);
-        scale_act += min;
-        sprintf(scale_txt, "%d", scale_act);
-
-        area_t label_cord;
-        point_t label_size;
-        txt_get_size(&label_size, scale_txt, style->font,
-                style->letter_space, style->line_space,
-                CORD_MAX, TXT_FLAG_NONE);
-
-        /*Draw the label*/
-        label_cord.x1 = x - label_size.x / 2;
-        label_cord.y1 = y - label_size.y / 2;
-        label_cord.x2 = label_cord.x1 + label_size.x;
-        label_cord.y2 = label_cord.y1 + label_size.y;
-
-        lv_draw_label(&label_cord, mask, style, scale_txt, TXT_FLAG_NONE);
-    }
-}
-/**
- * Draw the needles of a gauge
- * @param gauge pointer to gauge object
- * @param mask mask of drawing
- */
-static void lv_gauge_draw_needle(lv_obj_t * gauge, const area_t * mask, lv_style_t * style)
-{
-    lv_style_t style_needle;
-    lv_gauge_ext_t * ext = lv_obj_get_ext(gauge);
-
-    cord_t r = lv_obj_get_width(gauge) / 2 - style->opad;
-    cord_t x_ofs = lv_obj_get_width(gauge) / 2 + gauge->cords.x1;
-    cord_t y_ofs = lv_obj_get_height(gauge) / 2 + gauge->cords.y1;
-    uint16_t angle = lv_lmeter_get_scale_angle(gauge);
-    int16_t angle_ofs = 90 + (360 - angle) / 2;
-    int16_t min = lv_bar_get_min_value(gauge);
-    int16_t max = lv_bar_get_max_value(gauge);
-    point_t p_mid;
-    point_t p_end;
-    uint8_t i;
-
-    memcpy(&style_needle, style, sizeof(lv_style_t));
-
-    p_mid.x = x_ofs;
-    p_mid.y = y_ofs;
-    for(i = 0; i < ext->needle_num; i++) {
-        /*Calculate the end point of a needle*/
-        int16_t needle_angle = (ext->values[i] - min) * angle / (max - min) + angle_ofs;
-        p_end.y = (trigo_sin(needle_angle) * r) / TRIGO_SIN_MAX + y_ofs;
-        p_end.x = (trigo_sin(needle_angle + 90) * r) / TRIGO_SIN_MAX + x_ofs;
-
-        /*Draw the needle with the corresponding color*/
-        if(ext->needle_colors == NULL) style_needle.ccolor = LV_GAUGE_DEF_NEEDLE_COLOR;
-        else style_needle.ccolor = ext->needle_colors[i];
-
-        lv_draw_line(&p_mid, &p_end, mask, &style_needle);
-    }
-
-    /*Draw the needle middle area*/
-    lv_style_t style_neddle_mid;
-    lv_style_get(LV_STYLE_PLAIN, &style_neddle_mid);
-    style_neddle_mid.mcolor = style->bcolor;
-    style_neddle_mid.gcolor = style->bcolor;
-    style_neddle_mid.radius = LV_RADIUS_CIRCLE;
-
-    area_t nm_cord;
-    nm_cord.x1 = x_ofs - style->opad;
-    nm_cord.y1 = y_ofs - style->opad;
-    nm_cord.x2 = x_ofs + style->opad;
-    nm_cord.y2 = y_ofs + style->opad;
-
-    lv_draw_rect(&nm_cord, mask, &style_neddle_mid);
-}
-
-#endif

lv_objx/lv_gauge.h

@@ -1,138 +0,0 @@
-/**
- * @file lv_gauge.h
- * 
- */
-
-#ifndef LV_GAUGE_H
-#define LV_GAUGE_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#include "misc_conf.h"
-#if USE_LV_GAUGE != 0
-
-/*Testing of dependencies*/
-#if USE_LV_LMETER == 0
-#error "lv_gauge: lv_lmeter is required. Enable it in lv_conf.h (USE_LV_LMETER  1) "
-#endif
-
-#if USE_TRIGO == 0
-#error "lv_gauge: trigo is required. Enable it in misc_conf.h (USE_TRIGO  1) "
-#endif
-
-
-#include "../lv_obj/lv_obj.h"
-#include "lv_lmeter.h"
-#include "lv_label.h"
-#include "lv_line.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_GAUGE_MAX_NEEDLE     4   /*Max number of needles. Used in the style.*/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of gauge*/
-typedef struct
-{
-    lv_lmeter_ext_t lmeter;     /*Ext. of ancestor*/
-    /*New data for this type */
-    int16_t * values;               /*Array of the set values (for needles) */
-    lv_style_t * style_critical;    /*Fade to this style nearer to the critical value*/
-    color_t * needle_colors;        /*Color of the needles (color_t my_colors[needle_num])*/
-    uint8_t needle_num;             /*Number of needles*/
-    uint8_t low_critical:1;         /*0: the higher value is more critical, 1: the lower value is more critical*/
-}lv_gauge_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a gauge objects
- * @param par pointer to an object, it will be the parent of the new gauge
- * @param copy pointer to a gauge object, if not NULL then the new object will be copied from it
- * @return pointer to the created gauge
- */
-lv_obj_t * lv_gauge_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the gauge
- * @param gauge pointer to a gauge object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_gauge_signal(lv_obj_t * gauge, lv_signal_t sign, void * param);
-
-/**
- * Set the number of needles
- * @param gauge pointer to gauge object
- * @param num number of needles
- * @param colors an array of colors for needles (with 'num' elements)
- */
-void lv_gauge_set_needle_num(lv_obj_t * gauge, uint8_t num, color_t * colors);
-
-/**
- * Set the value of a needle
- * @param gauge pointer to gauge
- * @param needle the id of the needle
- * @param value the new value
- */
-void lv_gauge_set_value(lv_obj_t * gauge, uint8_t needle, int16_t value);
-
-/**
- * Set which value is more critical (lower or higher)
- * @param gauge pointer to a gauge object
- * @param low false: higher / true: lower value is more critical
- */
-void lv_gauge_set_low_critical(lv_obj_t * gauge, bool low);
-
-/**
- * Set the critical style of the gauge
- * @param gauge pointer to a gauge object
- * @param style pointer to the new critical style
- */
-void lv_gauge_set_style_critical(lv_obj_t * gauge, lv_style_t * style);
-
-/**
- * Get the number of needles on a gauge
- * @param gauge pointer to gauge
- * @return number of needles
- */
-uint8_t lv_gauge_get_needle_num(lv_obj_t * gauge);
-
-/**
- * Get the value of a needle
- * @param gauge pointer to gauge object
- * @param needle the id of the needle
- * @return the value of the needle [min,max]
- */
-int16_t lv_gauge_get_value(lv_obj_t * gauge,  uint8_t needle);
-
-/**
- * Get which value is more critical (lower or higher)
- * @param gauge pointer to a gauge object
- * @param low false: higher / true: lower value is more critical
- */
-bool lv_gauge_get_low_critical(lv_obj_t * gauge);
-
-/**
- * Get the critical style of the gauge
- * @param gauge pointer to a gauge object
- * @return pointer to the critical style
- */
-lv_style_t * lv_gauge_get_style_critical(lv_obj_t * gauge);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_img.c

@@ -1,365 +0,0 @@
-/**
- * @file lv_img.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#include "misc_conf.h"
-#if USE_LV_IMG != 0 && USE_FSINT != 0 && USE_UFS != 0
-
-#include "lv_img.h"
-#include "../lv_draw/lv_draw.h"
-#include "misc/fs/fsint.h"
-#include "misc/fs/ufs/ufs.h"
-
-#if LV_IMG_ENABLE_SYMBOLS != 0
-#include "misc/gfx/text.h"
-#endif
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_img_design(lv_obj_t * img, const area_t * mask, lv_design_mode_t mode);
-
-static bool lv_img_is_symbol(const char * txt);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create an image objects
- * @param par pointer to an object, it will be the parent of the new button
- * @param copy pointer to a image object, if not NULL then the new object will be copied from it
- * @return pointer to the created image
- */
-lv_obj_t * lv_img_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    lv_obj_t * new_img = NULL;
-    
-    /*Create a basic object*/
-    new_img = lv_obj_create(par, copy);
-    dm_assert(new_img);
-    
-    /*Extend the basic object to image object*/
-    lv_img_ext_t * ext = lv_obj_alloc_ext(new_img, sizeof(lv_img_ext_t));
-    dm_assert(ext);
-    ext->fn = NULL;
-    ext->w = lv_obj_get_width(new_img);
-    ext->h = lv_obj_get_height(new_img);
-    ext->transp = 0;
-    ext->upscale = 0;
-    ext->auto_size = 1;
-
-    /*Init the new object*/    
-    lv_obj_set_signal_f(new_img, lv_img_signal);
-    lv_obj_set_design_f(new_img, lv_img_design);
-    
-    if(copy == NULL) {
-		/* Enable auto size for non screens
-		 * because image screens are wallpapers
-		 * and must be screen sized*/
-		if(par != NULL) ext->auto_size = 1;
-		else ext->auto_size = 0;
-		if(par != NULL) lv_obj_set_style(new_img, NULL);    /*Inherit the style  by default*/
-		else lv_obj_set_style(new_img, lv_style_get(LV_STYLE_PLAIN, NULL)); /*Set style for screens*/
-    } else {
-        lv_img_ext_t * copy_ext = lv_obj_get_ext(copy);
-    	ext->auto_size = copy_ext->auto_size;
-        ext->upscale = copy_ext->upscale;
-    	lv_img_set_file(new_img, copy_ext->fn);
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_img);
-    }
-
-    return new_img;
-}
-
-/**
- * Signal function of the image
- * @param img pointer to animage object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param)
-{
-    bool valid = true;
-
-    /* Include the ancient signal function */
-    valid = lv_obj_signal(img, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-        lv_img_ext_t * ext = lv_obj_get_ext(img);
-        if(sign == LV_SIGNAL_CLEANUP) {
-            dm_free(ext->fn);
-        }
-        else if(sign == LV_SIGNAL_STYLE_CHG) {
-            /*Refresh the file name to refresh the symbol text size*/
-            if(lv_img_is_symbol(ext->fn) != false) {
-                lv_img_set_file(img, ext->fn);
-            }
-        }
-    }
-    
-    return valid;
-}
-
-/**
- * Create a file to the RAMFS from a picture data
- * @param fn file name of the new file (e.g. "pic1", will be available at "U:/pic1")
- * @param data pointer to a color map with lv_img_raw_header_t header
- * @return result of the file operation. FS_RES_OK or any error from fs_res_t
- */
-fs_res_t lv_img_create_file(const char * fn, const color_int_t * data)
-{
-	const lv_img_raw_header_t * raw_p = (lv_img_raw_header_t *) data;
-	fs_res_t res;
-	res = ufs_create_const(fn, data, raw_p->w * raw_p->h * sizeof(color_t) + sizeof(lv_img_raw_header_t));
-
-	return res;
-}
-
-/*=====================
- * Setter functions 
- *====================*/
-
-/**
- * Set a file to the image
- * @param img pointer to an image object
- * @param fn file name in the RAMFS to set as picture (e.g. "U:/pic1"). 
- */
-void lv_img_set_file(lv_obj_t * img, const char * fn)
-{
-    lv_img_ext_t * ext = lv_obj_get_ext(img);
-    
-    /*Handle normal images*/
-	if(lv_img_is_symbol(fn) == false) {
-
-        fs_file_t file;
-        fs_res_t res;
-        lv_img_raw_header_t header;
-        uint32_t rn;
-        res = fs_open(&file, fn, FS_MODE_RD);
-        if(res == FS_RES_OK) {
-            res = fs_read(&file, &header, sizeof(header), &rn);
-        }
-
-        /*Create a dummy header on fs error*/
-        if(res != FS_RES_OK || rn != sizeof(header)) {
-            header.w = lv_obj_get_width(img);
-            header.h = lv_obj_get_height(img);
-            header.transp = 0;
-            header.cd = 0;
-        }
-
-        fs_close(&file);
-
-        ext->w = header.w;
-        ext->h = header.h;
-        ext->transp = header.transp;
-
-#if LV_ANTIALIAS != 0
-        if(ext->upscale != 0) {
-            ext->w *=  2;
-            ext->h *=  2;
-        }
-#endif
-	}
-	/*Handle symbol texts*/
-	else {
-#if LV_IMG_ENABLE_SYMBOLS
-        lv_style_t * style = lv_obj_get_style(img);
-        point_t size;
-        txt_get_size(&size, fn, style->font, style->letter_space, style->line_space, CORD_MAX, TXT_FLAG_NONE);
-        ext->w = size.x;
-        ext->h = size.y;
-        ext->transp = 1;    /*Symbols always have transparent parts*/
-#else
-        /*Never goes here, just to be sure handle this */
-        ext->w = lv_obj_get_width(img);
-        ext->h = lv_obj_get_height(img);
-        ext->transp = 0;
-#endif
-
-	}
-
-	if(fn != NULL) {
-	    ext->fn = dm_realloc(ext->fn, strlen(fn) + 1);
-		strcpy(ext->fn, fn);
-	} else {
-		ext->fn = NULL;
-	}
-
-
-    if(lv_img_get_auto_size(img) != false) {
-        lv_obj_set_size(img, ext->w, ext->h);
-    }
-
-    lv_obj_inv(img);
-}
-
-/**
- * Enable the auto size feature.
- * If enabled the object size will be same as the picture size.
- * @param img pointer to an image
- * @param en true: auto size enable, false: auto size disable
- */
-void lv_img_set_auto_size(lv_obj_t * img, bool en)
-{
-    lv_img_ext_t * ext = lv_obj_get_ext(img);
-
-    ext->auto_size = (en == false ? 0 : 1);
-}
-
-
-/**
- * Enable the upscaling with LV_DOWNSCALE.
- * If enabled the object size will be same as the picture size.
- * @param img pointer to an image
- * @param en true: upscale enable, false: upscale disable
- */
-void lv_img_set_upscale(lv_obj_t * img, bool en)
-{
-    lv_img_ext_t * ext = lv_obj_get_ext(img);
-    
-    /*Upscale works only if antialiassing is enabled*/
-#if LV_ANTIALIAS == 0
-    en = false;
-#endif
-    ext->upscale = (en == false ? 0 : 1);
-
-    /*Refresh the image with the new size*/
-    lv_img_set_file(img, ext->fn);
-}
-
-/*=====================
- * Getter functions 
- *====================*/
-
-/**
- * Get the auto size enable attribute
- * @param img pointer to an image
- * @return true: auto size is enabled, false: auto size is disabled
- */
-bool lv_img_get_auto_size(lv_obj_t * img)
-{
-    lv_img_ext_t * ext = lv_obj_get_ext(img);
-
-    return ext->auto_size == 0 ? false : true;
-}
-
-/**
- * Get the upscale enable attribute
- * @param img pointer to an image
- * @return true: upscale is enabled, false: upscale is disabled
- */
-bool lv_img_get_upscale(lv_obj_t * img)
-{
-    lv_img_ext_t * ext = lv_obj_get_ext(img);
-
-    return ext->upscale == 0 ? false : true;
-}
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the images
- * @param img pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'        
- */
-static bool lv_img_design(lv_obj_t * img, const area_t * mask, lv_design_mode_t mode)
-{
-    lv_style_t * style = lv_obj_get_style(img);
-    lv_img_ext_t * ext = lv_obj_get_ext(img);
-
-    if(mode == LV_DESIGN_COVER_CHK) {
-        bool cover = false;
-        if(ext->transp == 0) cover = area_is_in(mask, &img->cords);
-        return cover;
-
-    } else if(mode == LV_DESIGN_DRAW_MAIN) {
-        if(ext->h == 0 || ext->w == 0) return true;
-		area_t cords;
-/*Create a default style for symbol texts*/
-#if LV_IMG_ENABLE_SYMBOLS != 0
-        bool sym = lv_img_is_symbol(ext->fn);
-#endif
-
-		lv_obj_get_cords(img, &cords);
-
-		area_t cords_tmp;
-		cords_tmp.y1 = cords.y1;
-		cords_tmp.y2 = cords.y1 + ext->h - 1;
-
-		for(; cords_tmp.y1 < cords.y2; cords_tmp.y1 += ext->h, cords_tmp.y2 += ext->h) {
-			cords_tmp.x1 = cords.x1;
-			cords_tmp.x2 = cords.x1 + ext->w - 1;
-			for(; cords_tmp.x1 < cords.x2; cords_tmp.x1 += ext->w, cords_tmp.x2 += ext->w) {
-
-#if LV_IMG_ENABLE_SYMBOLS == 0
-			    lv_draw_img(&cords_tmp, mask, style, opa, ext->fn);
-#else
-			    if(sym == false) lv_draw_img(&cords_tmp, mask, style, ext->fn);
-			    else lv_draw_label(&cords_tmp, mask, style, ext->fn, TXT_FLAG_NONE);
-#endif
-			}
-		}
-    }
-    
-    return true;
-}
-
-
-/**
- * From the settings in lv_conf.h and the file name
- * tells it a filename or a symbol text.
- * @param txt a file name (e.g. "U:/file1") or a symbol (e.g. SYMBOL_OK)
- * @return true: 'txt' is a symbol text, false: 'txt' is a file name
- */
-static bool lv_img_is_symbol(const char * txt)
-{
-    /*If the symbols are not enabled always tell false*/
-#if LV_IMG_ENABLE_SYMBOLS == 0
-    return false;
-#endif
-
-    if(txt == NULL) return false;
-
-    /* if txt begins with an upper case letter then it refers to a driver
-     * so it is a file name*/
-    if(txt[0] >= 'A' && txt[0] <= 'Z') return false;
-
-    /*If not returned during the above tests then it is symbol text*/
-    return true;
-}
-
-
-#endif

lv_objx/lv_img.h

@@ -1,141 +0,0 @@
-/**
- * @file lv_img.h
- * 
- */
-
-#ifndef LV_IMG_H
-#define LV_IMG_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#include "misc_conf.h"
-#if USE_LV_IMG != 0 && USE_FSINT != 0 && USE_UFS != 0
-
-#if USE_FSINT == 0
-#error "lv_img: fsint is required. Enable it in misc_conf.h (USE_FSINT  1) "
-#endif
-
-#if USE_UFS == 0
-#error "lv_img: ufs is required. Enable it in misc_conf.h (USE_UFS  1) "
-#endif
-
-#include "../lv_obj/lv_obj.h"
-#include "misc/fs/fsint.h"
-
-#ifndef LV_IMG_ENABLE_SYMBOLS
-#define LV_IMG_ENABLE_SYMBOLS 0
-#endif
-
-#if LV_IMG_ENABLE_SYMBOLS != 0
-#include "lv_label.h"
-#include "misc/gfx/fonts/symbol_def.h"
-#endif
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-/*Data of image*/
-typedef struct
-{
-    /*No inherited ext. because inherited from the base object*/ /*Ext. of ancestor*/
-    /*New data for this type */
-    char* fn;                   /*Image file name. E.g. "U:/my_image"*/
-    cord_t w;                   /*Width of the image (doubled when upscaled) (Handled by the library)*/
-    cord_t h;                   /*Height of the image (doubled when upscaled) (Handled by the library)*/
-    uint8_t auto_size :1;       /*1: automatically set the object size to the image size*/
-    uint8_t upscale   :1;       /*1: upscale to double size with antialaissing*/
-    uint8_t transp    :1;       /*Transp. bit in the image header (Handled by the library)*/
-}lv_img_ext_t;
-
-/* Image header it is compatible with
- * the result image converter utility*/
-typedef struct
-{
-    uint32_t w:12;        /*Width of the image map*/
-    uint32_t h:12;        /*Height of the image map*/
-    uint32_t transp:1;    /*1: The image contains transparent pixels with LV_COLOR_TRANSP color*/
-    uint32_t cd:3;        /*Color depth (0: reserved, 1: 8 bit, 2: 16 bit or 3: 24 bit, 4-7: reserved)*/
-    uint32_t res :4;      /*Reserved*/
-}lv_img_raw_header_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create an image objects
- * @param par pointer to an object, it will be the parent of the new button
- * @param copy pointer to a image object, if not NULL then the new object will be copied from it
- * @return pointer to the created image
- */
-lv_obj_t * lv_img_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the image
- * @param img pointer to animage object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_img_signal(lv_obj_t * img, lv_signal_t sign, void * param);
-
-/**
- * Create a file to the RAMFS from a picture data
- * @param fn file name of the new file (e.g. "pic1", will be available at "U:/pic1")
- * @param data pointer to a color map with lv_img_raw_header_t header
- * @return result of the file operation. FS_RES_OK or any error from fs_res_t
- */
-fs_res_t lv_img_create_file(const char * fn, const color_int_t * data);
-
-/**
- * Set a file to the image
- * @param img pointer to an image object
- * @param fn file name in the RAMFS to set as picture (e.g. "U:/pic1").
- */
-void lv_img_set_file(lv_obj_t * img, const char * fn);
-
-/**
- * Enable the auto size feature.
- * If enabled the object size will be same as the picture size.
- * @param img pointer to an image
- * @param en true: auto size enable, false: auto size disable
- */
-void lv_img_set_auto_size(lv_obj_t * img, bool en);
-
-/**
- * Enable the upscaling with LV_DOWNSCALE.
- * If enabled the object size will be same as the picture size.
- * @param img pointer to an image
- * @param en true: upscale enable, false: upscale disable
- */
-void lv_img_set_upscale(lv_obj_t * img, bool en);
-
-/**
- * Get the auto size enable attribute
- * @param img pointer to an image
- * @return true: auto size is enabled, false: auto size is disabled
- */
-bool lv_img_get_auto_size(lv_obj_t * img);
-
-/**
- * Get the upscale enable attribute
- * @param img pointer to an image
- * @return true: upscale is enabled, false: upscale is disabled
- */
-bool lv_img_get_upscale(lv_obj_t * img);
-
-/**********************
- *      MACROS
- **********************/
-
-/*Use this macro to declare an image in a c file*/
-#define LV_IMG_DECLARE(var_name) extern const color_int_t var_name[];
-
-#endif
-
-#endif

lv_objx/lv_label.c

@@ -1,625 +0,0 @@
-/**
- * @file lv_rect.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_LABEL != 0
-
-#include "misc/gfx/color.h"
-#include "misc/math/math_base.h"
-#include "lv_label.h"
-#include "../lv_obj/lv_obj.h"
-#include "misc/gfx/text.h"
-#include "misc/gfx/anim.h"
-#include "../lv_draw/lv_draw.h"
-
-/*********************
- *      DEFINES
- *********************/
-/*Test configurations*/
-#ifndef LV_LABEL_SCROLL_SPEED
-#define LV_LABEL_SCROLL_SPEED       (25 * LV_DOWNSCALE) /*Hor, or ver. scroll speed (px/sec) in 'LV_LABEL_LONG_SCROLL' mode*/
-#endif
-
-#ifndef LV_LABEL_SCROLL_SPEED_VER
-#define LV_LABEL_SCROLL_SPEED_VER   (10 * LV_DOWNSCALE) /*Ver. scroll speed if hor. scroll is applied too*/
-#endif
-
-#ifndef LV_LABEL_SCROLL_PLAYBACK_PAUSE
-#define LV_LABEL_SCROLL_PLAYBACK_PAUSE  500 /*Wait before the scroll turns back in ms*/
-#endif
-
-#ifndef LV_LABEL_SCROLL_REPEAT_PAUSE
-#define LV_LABEL_SCROLL_REPEAT_PAUSE    500 /*Wait before the scroll begins again in ms*/
-#endif
-
-#define LV_LABEL_DOT_NUM	3
-#define LV_LABEL_DOT_END_INV 0xFFFF
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_label_design(lv_obj_t * label, const area_t * mask, lv_design_mode_t mode);
-static void lv_label_refr_text(lv_obj_t * label);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a label objects
- * @param par pointer to an object, it will be the parent of the new label
- * @param copy pointer to a button object, if not NULL then the new object will be copied from it
- * @return pointer to the created button
- */
-lv_obj_t * lv_label_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create a basic object*/
-    lv_obj_t * new_label = lv_obj_create(par, copy);
-    dm_assert(new_label);
-    
-    /*Extend the basic object to a label object*/
-    lv_obj_alloc_ext(new_label, sizeof(lv_label_ext_t));
-    
-    lv_label_ext_t * ext = lv_obj_get_ext(new_label);
-    dm_assert(ext);
-    ext->txt = NULL;
-    ext->static_txt = 0;
-    ext->recolor = 0;
-    ext->dot_end = LV_LABEL_DOT_END_INV;
-    ext->long_mode = LV_LABEL_LONG_EXPAND;
-
-	lv_obj_set_design_f(new_label, lv_label_design);
-	lv_obj_set_signal_f(new_label, lv_label_signal);
-
-    /*Init the new label*/
-    if(copy == NULL) {
-		lv_obj_set_click(new_label, false);
-		lv_obj_set_style(new_label, NULL);
-		lv_label_set_long_mode(new_label, LV_LABEL_LONG_EXPAND);
-		lv_label_set_text(new_label, "Text");
-    }
-    /*Copy 'copy' if not NULL*/
-    else {
-        lv_label_ext_t * copy_ext = lv_obj_get_ext(copy);
-        lv_label_set_long_mode(new_label, lv_label_get_long_mode(copy));
-        lv_label_set_recolor(new_label, lv_label_get_recolor(copy));
-        if(copy_ext->static_txt == 0) lv_label_set_text(new_label, lv_label_get_text(copy));
-        else lv_label_set_text_static(new_label, lv_label_get_text(copy));
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_label);
-    }
-    return new_label;
-}
-
-
-/**
- * Signal function of the label
- * @param label pointer to a label object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_label_signal(lv_obj_t * label, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_obj_signal(label, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-        lv_label_ext_t * ext = lv_obj_get_ext(label);
-        /*No signal handling*/
-    	switch(sign) {
-            case LV_SIGNAL_CLEANUP:
-                if(ext->static_txt == 0) {
-                    dm_free(ext->txt);
-                    ext->txt = NULL;
-                }
-                break;
-            case LV_SIGNAL_STYLE_CHG:
-            	lv_label_set_text(label, NULL);
-            	break;
-
-			default:
-				break;
-    	}
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions 
- *====================*/
-
-/**
- * Set a new text for a label. Memory will be allocated to store the text by the label.
- * @param label pointer to a label object
- * @param text '\0' terminated character string. NULL to refresh with the current text.
- */
-void lv_label_set_text(lv_obj_t * label, const char * text)
-{
-    lv_obj_inv(label);
-    
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-
-    /*If trying to set its own text or the text is NULL then refresh */
-    if(text == ext->txt || text == NULL) {
-        lv_label_refr_text(label);
-        return;
-    }
-
-    /*Allocate space for the new text*/
-    uint32_t len = strlen(text) + 1;
-    if(ext->txt != NULL && ext->static_txt == 0) {
-        dm_free(ext->txt);
-        ext->txt = NULL;
-    }
-    ext->txt = dm_alloc(len);
-    strcpy(ext->txt, text);
-    ext->static_txt = 0;    /*Now the text is dynamically allocated*/
-    
-    lv_label_refr_text(label);
-}
-/**
- * Set a new text for a label from a character array. The array don't has to be '\0' terminated.
- * Memory will be allocated to store the array by the label.
- * @param label pointer to a label object
- * @param array array of characters or NULL to refresh the label
- * @param size the size of 'array' in bytes
- */
-void lv_label_set_text_array(lv_obj_t * label, const char * array, uint16_t size)
-{
-    lv_obj_inv(label);
-
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-
-    /*If trying to set its own text or the array is NULL then refresh */
-    if(array == ext->txt || array == NULL) {
-        lv_label_refr_text(label);
-        return;
-    }
-
-    /*Allocate space for the new text*/
-    if(ext->txt != NULL && ext->static_txt == 0) {
-        dm_free(ext->txt);
-        ext->txt = NULL;
-    }
-    ext->txt = dm_alloc(size + 1);
-    memcpy(ext->txt, array, size);
-    ext->txt[size] = '\0';
-    ext->static_txt = 0;    /*Now the text is dynamically allocated*/
-
-    lv_label_refr_text(label);
-}
-
-/**
- * Set a static text. It will not be saved by the label so the 'text' variable
- * has to be 'alive' while the label exist.
- * @param label pointer to a label object
- * @param text pointer to a text. NULL to refresh with the current text.
- */
-void lv_label_set_text_static(lv_obj_t * label, const char * text)
-{
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-    if(ext->static_txt == 0 && ext->txt != NULL) {
-        dm_free(ext->txt);
-        ext->txt = NULL;
-    }
-
-    if(text != NULL) {
-        ext->static_txt = 1;
-        ext->txt = (char *) text;
-    }
-
-    lv_label_refr_text(label);
-}
-
-/**
- * Append a text to the label. The label current label text can not be static.
- * @param label pointer to label object
- * @param text pointe rto the new text
- */
-void lv_label_append_text(lv_obj_t * label, const char * text)
-{
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-
-    /*Can not append to static text*/
-    if(ext->static_txt != 0) return;
-
-    lv_obj_inv(label);
-
-    /*Allocate space for the new text*/
-    uint32_t old_len = strlen(ext->txt);
-    uint32_t app_len = strlen(text);
-    uint32_t new_len = app_len + old_len;
-    ext->txt = dm_realloc(ext->txt, new_len + 1);
-    memcpy(ext->txt + old_len, text, app_len);
-    ext->txt[new_len] = '\0';
-
-    lv_label_refr_text(label);
-}
-
-/**
- * Set the behavior of the label with longer text then the object size
- * @param label pointer to a label object
- * @param long_mode the new mode from 'lv_label_long_mode' enum.
- */
-void lv_label_set_long_mode(lv_obj_t * label, lv_label_long_mode_t long_mode)
-{
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-
-    /*When changing from dot mode reload the characters replaced by dots*/
-    if(ext->long_mode == LV_LABEL_LONG_DOTS &&
-       ext->dot_end != LV_LABEL_DOT_END_INV) {
-    	uint8_t i;
-    	for(i = 0; i < LV_LABEL_DOT_NUM + 1; i++) {
-    		ext->txt[ext->dot_end - LV_LABEL_DOT_NUM + i] = ext->dot_tmp[i];
-    	}
-    }
-
-    /*Delete the scroller animations*/
-    if(ext->long_mode == LV_LABEL_LONG_SCROLL) {
-    	anim_del(label, (anim_fp_t) lv_obj_set_x);
-    	anim_del(label, (anim_fp_t) lv_obj_set_y);
-    }
-
-    ext->long_mode = long_mode;
-    lv_label_refr_text(label);
-}
-
-/**
- * Enable the recoloring by in-line commands
- * @param label pointer to a label object
- * @param recolor true: enable recoloring, false: disable
- */
-void lv_label_set_recolor(lv_obj_t * label, bool recolor)
-{
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-
-    ext->recolor = recolor == false ? 0 : 1;
-
-    lv_label_refr_text(label);
-}
-
-/*=====================
- * Getter functions 
- *====================*/
-
-/**
- * Get the text of a label
- * @param label pointer to a label object
- * @return the text of the label
- */
-const char * lv_label_get_text(lv_obj_t * label)
-{
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-    
-    return ext->txt;
-}
-
-/**
- * Get the long mode of a label
- * @param label pointer to a label object
- * @return the long mode
- */
-lv_label_long_mode_t lv_label_get_long_mode(lv_obj_t * label)
-{
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-    return ext->long_mode;
-}
-
-/**
- * Get the recoloring attribute
- * @param label pointer to a label object
- * @return true: recoloring is enabled, false: disable
- */
-bool lv_label_get_recolor(lv_obj_t * label)
-{
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-    return ext->recolor == 0 ? false : true;
-
-}
-
-/**
- * Get the relative x and y coordinates of a letter
- * @param label pointer to a label object
- * @param index index of the letter (0 ... text length)
- * @param pos store the result here (E.g. index = 0 gives 0;0 coordinates)
- */
-void lv_label_get_letter_pos(lv_obj_t * label, uint16_t index, point_t * pos)
-{
-	const char * text = lv_label_get_text(label);
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-    uint32_t line_start = 0;
-    uint32_t new_line_start = 0;
-    cord_t max_w = lv_obj_get_width(label);
-    lv_style_t * style = lv_obj_get_style(label);
-    const font_t * font = style->font;
-    uint8_t letter_height = font_get_height(font) >> FONT_ANTIALIAS;
-    cord_t y = 0;
-    txt_flag_t flag = TXT_FLAG_NONE;
-
-    if(ext->recolor != 0) flag |= TXT_FLAG_RECOLOR;
-
-    /*If the width will be expanded  the set the max length to very big */
-    if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) {
-        max_w = CORD_MAX;
-    }
-
-    /*Search the line of the index letter */;
-    while (text[new_line_start] != '\0') {
-        new_line_start += txt_get_next_line(&text[line_start], font, style->letter_space, max_w, flag);
-        if(index < new_line_start || text[new_line_start] == '\0') break; /*The line of 'index' letter begins at 'line_start'*/
-
-        y += letter_height + style->line_space;
-        line_start = new_line_start;
-    }
-
-    if((text[index - 1] == '\n' || text[index - 1] == '\r') && text[index] == '\0') {
-        y += letter_height + style->line_space;
-        line_start = index;
-    }
-
-    /*Calculate the x coordinate*/
-    cord_t x = 0;
-	uint32_t i;
-	txt_cmd_state_t cmd_state = TXT_CMD_STATE_WAIT;
-	for(i = line_start; i < index; i++) {
-        /*Handle the recolor command*/
-        if((flag & TXT_FLAG_RECOLOR) != 0) {
-            if(txt_is_cmd(&cmd_state, text[i]) != false) {
-                continue; /*Skip the letter is it is part of a command*/
-            }
-        }
-
-		x += (font_get_width(font, text[i]) >> FONT_ANTIALIAS) + style->letter_space;
-	}
-
-	if(style->txt_align == LV_TXT_ALIGN_MID) {
-		cord_t line_w;
-        line_w = txt_get_width(&text[line_start], new_line_start - line_start,
-                               font, style->letter_space, flag);
-		x += lv_obj_get_width(label) / 2 - line_w / 2;
-    }
-
-    pos->x = x;
-    pos->y = y;
-
-}
-
-/**
- * Get the index of letter on a relative point of a label
- * @param label pointer to label object
- * @param pos pointer to point with coordinates on a the label
- * @return the index of the letter on the 'pos_p' point (E.g. on 0;0 is the 0. letter)
- */
-uint16_t lv_label_get_letter_on(lv_obj_t * label, point_t * pos)
-{
-	const char * text = lv_label_get_text(label);
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-    uint32_t line_start = 0;
-    uint32_t new_line_start = 0;
-    cord_t max_w = lv_obj_get_width(label);
-    lv_style_t * style = lv_obj_get_style(label);
-    const font_t * font = style->font;
-    uint8_t letter_height = font_get_height(font) >> FONT_ANTIALIAS;
-    cord_t y = 0;
-    txt_flag_t flag = TXT_FLAG_NONE;
-
-    if(ext->recolor != 0) flag |= TXT_FLAG_RECOLOR;
-
-    /*If the width will be expanded set the max length to very big */
-    if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) {
-        max_w = CORD_MAX;
-    }
-
-    /*Search the line of the index letter */;
-    while (text[line_start] != '\0') {
-    	new_line_start += txt_get_next_line(&text[line_start], font, style->letter_space, max_w, flag);
-    	if(pos->y <= y + letter_height + style->line_space) break; /*The line is found ('line_start')*/
-    	y += letter_height + style->line_space;
-        line_start = new_line_start;
-    }
-
-    /*Calculate the x coordinate*/
-    cord_t x = 0;
-	if(style->txt_align == LV_TXT_ALIGN_MID) {
-		cord_t line_w;
-        line_w = txt_get_width(&text[line_start], new_line_start - line_start,
-                               font, style->letter_space, flag);
-		x += lv_obj_get_width(label) / 2 - line_w / 2;
-    }
-
-	txt_cmd_state_t cmd_state = TXT_CMD_STATE_WAIT;
-	uint16_t i;
-	for(i = line_start; i < new_line_start - 1; i++) {
-	    /*Handle the recolor command*/
-	    if((flag & TXT_FLAG_RECOLOR) != 0) {
-            if(txt_is_cmd(&cmd_state, text[i]) != false) {
-                continue; /*Skip the letter is it is part of a command*/
-            }
-	    }
-
-		x += (font_get_width(font, text[i]) >> FONT_ANTIALIAS) + style->letter_space;
-		if(pos->x < x) break;
-	}
-
-
-	return i;
-}
-
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the labels
- * @param label pointer to a label object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_label_design(lv_obj_t * label, const area_t * mask, lv_design_mode_t mode)
-{
-    /* A label never covers an area */
-    if(mode == LV_DESIGN_COVER_CHK) return false;
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-		/*TEST: draw a background for the label*/
-		//lv_vfill(&label->cords, mask, COLOR_LIME, OPA_COVER);
-
-		area_t cords;
-		lv_obj_get_cords(label, &cords);
-		lv_label_ext_t * ext = lv_obj_get_ext(label);
-		txt_flag_t flag = TXT_FLAG_NONE;
-		if(ext->recolor != 0) flag |= TXT_FLAG_RECOLOR;
-
-
-		lv_draw_label(&cords, mask, lv_obj_get_style(label), ext->txt, flag);
-
-
-    }
-    return true;
-}
-
-/**
- * Refresh the label with its text stored in its extended data
- * @param label pointer to a label object
- */
-static void lv_label_refr_text(lv_obj_t * label)
-{
-    lv_label_ext_t * ext = lv_obj_get_ext(label);
-
-    if(ext->txt == NULL) return;
-
-    cord_t max_w = lv_obj_get_width(label);
-    lv_style_t * style = lv_obj_get_style(label);
-    const font_t * font = style->font;
-
-    ext->dot_end = LV_LABEL_DOT_END_INV;    /*Initialize the dot end index*/
-
-    /*If the width will be expanded set the max length to very big */
-    if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) {
-        max_w = CORD_MAX;
-    }
-
-    /*Calc. the height and longest line*/
-    point_t size;
-    txt_flag_t flag = TXT_FLAG_NONE;
-    if(ext->recolor != 0) flag |= TXT_FLAG_RECOLOR;
-    txt_get_size(&size, ext->txt, font, style->letter_space, style->line_space, max_w, flag);
-
-    /*Refresh the full size in expand mode*/
-    if(ext->long_mode == LV_LABEL_LONG_EXPAND || ext->long_mode == LV_LABEL_LONG_SCROLL) {
-        lv_obj_set_size(label, size.x, size.y);
-
-        /*Start scrolling if the label is greater then its parent*/
-        if(ext->long_mode == LV_LABEL_LONG_SCROLL) {
-            lv_obj_t * parent = lv_obj_get_parent(label);
-
-            /*Delete the potential previous scroller animations*/
-            anim_del(label, (anim_fp_t) lv_obj_set_x);
-            anim_del(label, (anim_fp_t) lv_obj_set_y);
-
-            anim_t anim;
-            anim.var = label;
-            anim.repeat = 1;
-            anim.playback = 1;
-            anim.start = font_get_width(font, ' ') >> FONT_ANTIALIAS;
-            anim.act_time = 0;
-            anim.end_cb = NULL;
-            anim.path = anim_get_path(ANIM_PATH_LIN);
-            anim.time = 3000;
-            anim.playback_pause = LV_LABEL_SCROLL_PLAYBACK_PAUSE;
-            anim.repeat_pause = LV_LABEL_SCROLL_REPEAT_PAUSE;
-
-            bool hor_anim = false;
-            if(lv_obj_get_width(label) > lv_obj_get_width(parent)) {
-                anim.end = lv_obj_get_width(parent) - lv_obj_get_width(label) -
-                           (font_get_width(font, ' ') >> FONT_ANTIALIAS);
-                anim.fp = (anim_fp_t) lv_obj_set_x;
-                anim.time = anim_speed_to_time(LV_LABEL_SCROLL_SPEED, anim.start, anim.end);
-                anim_create(&anim);
-                hor_anim = true;
-            }
-
-            if(lv_obj_get_height(label) > lv_obj_get_height(parent)) {
-                anim.end =  lv_obj_get_height(parent) - lv_obj_get_height(label) -
-                                   (font_get_height(font) - FONT_ANTIALIAS);
-                anim.fp = (anim_fp_t)lv_obj_set_y;
-
-                /*Different animation speed if horizontal animation is created too*/
-                if(hor_anim == false) {
-                    anim.time = anim_speed_to_time(LV_LABEL_SCROLL_SPEED, anim.start, anim.end);
-                } else {
-                    anim.time = anim_speed_to_time(LV_LABEL_SCROLL_SPEED_VER, anim.start, anim.end);
-                }
-                anim_create(&anim);
-            }
-        }
-    }
-    /*In break mode only the height can change*/
-    else if (ext->long_mode == LV_LABEL_LONG_BREAK) {
-        lv_obj_set_height(label, size.y);
-    }
-    /*Replace the last 'LV_LABEL_DOT_NUM' characters with dots
-     * and save these characters*/
-    else if(ext->long_mode == LV_LABEL_LONG_DOTS) {
-        point_t point;
-        point.x = lv_obj_get_width(label) - 1;
-        point.y = lv_obj_get_height(label) - 1;
-        uint16_t index = lv_label_get_letter_on(label, &point);
-
-        if(index < strlen(ext->txt) - 1) {
-
-            /* Change the last 'LV_LABEL_DOT_NUM' to dots
-             * (if there are at least 'LV_LABEL_DOT_NUM' characters*/
-            if(index > LV_LABEL_DOT_NUM) {
-                uint8_t i;
-                for(i = 0; i < LV_LABEL_DOT_NUM; i++) {
-                    ext->dot_tmp[i] = ext->txt[index - LV_LABEL_DOT_NUM + i];
-                    ext->txt[index - LV_LABEL_DOT_NUM + i] = '.';
-                }
-                /*The last character is '\0'. Save this character from the text too.*/
-                ext->dot_tmp[i] = ext->txt[index];
-                ext->txt[index] = '\0';
-            }
-            /*Else with short text change all characters to dots*/
-            else {
-                uint8_t i;
-                for(i = 0; i < LV_LABEL_DOT_NUM; i++) {
-                    ext->txt[i] = '.';
-                }
-                ext->txt[i] = '\0';
-            }
-            /*Save the dot end index*/
-            ext->dot_end = index;
-        }
-    }
-
-    lv_obj_inv(label);
-}
-
-#endif

lv_objx/lv_label.h

@@ -1,158 +0,0 @@
-/**
- * @file lv_rect.h
- * 
- */
-
-#ifndef LV_LABEL_H
-#define LV_LABEL_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_LABEL != 0
-
-#include "../lv_obj/lv_obj.h"
-#include "misc/gfx/font.h"
-#include "misc/gfx/text.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_LABEL_DOT_NUM 3
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Long mode behaviors. Used in 'lv_label_ext_t' */
-typedef enum
-{
-    LV_LABEL_LONG_EXPAND,   /*Expand the object size to the text size*/
-    LV_LABEL_LONG_BREAK,    /*Keep the object width, break the too long lines and expand the object height*/
-    LV_LABEL_LONG_DOTS,     /*Keep the object size, break the text and write dots in the last line*/
-    LV_LABEL_LONG_SCROLL,   /*Expand the object size and scroll the text on the parent (move the label object)*/
-}lv_label_long_mode_t;
-
-/*Data of label*/
-typedef struct
-{
-    /*Inherited from 'base_obj' so no inherited ext.*/  /*Ext. of ancestor*/
-    /*New data for this type */
-    char * txt;                     /*Text of the label*/
-    lv_label_long_mode_t long_mode; /*Determinate what to do with the long texts*/
-    char dot_tmp[LV_LABEL_DOT_NUM + 1]; /*Store the character which are replaced by dots (Handled by the library)*/
-    uint16_t dot_end;               /*The text end position in dot mode (Handled by the library)*/
-    uint8_t static_txt  :1;         /*Flag to indicate the text is static*/
-    uint8_t recolor  :1;            /*Enable in-line letter re-coloring*/
-}lv_label_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a label objects
- * @param par pointer to an object, it will be the parent of the new label
- * @param copy pointer to a button object, if not NULL then the new object will be copied from it
- * @return pointer to the created button
- */
-lv_obj_t * lv_label_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the label
- * @param label pointer to a label object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_label_signal(lv_obj_t * label, lv_signal_t sign, void * param);
-
-/**
- * Set a new text for a label. Memory will be allocated to store the text by the label.
- * @param label pointer to a label object
- * @param text '\0' terminated character string. NULL to refresh with the current text.
- */
-void lv_label_set_text(lv_obj_t * label, const char * text);
-
-/**
- * Set a new text for a label from a character array. The array don't has to be '\0' terminated.
- * Memory will be allocated to store the array by the label.
- * @param label pointer to a label object
- * @param array array of characters or NULL to refresh the label
- * @param size the size of 'array' in bytes
- */
-void lv_label_set_text_array(lv_obj_t * label, const char * array, uint16_t size);
-
-/**
- * Set a static text. It will not be saved by the label so the 'text' variable
- * has to be 'alive' while the label exist.
- * @param label pointer to a label object
- * @param text pointer to a text. NULL to refresh with the current text.
- */
-void lv_label_set_text_static(lv_obj_t * label, const char * text);
-
-/**
- * Append a text to the label. The label current label text can not be static.
- * @param label pointer to label object
- * @param text pointe rto the new text
- */
-void lv_label_append_text(lv_obj_t * label, const char * text);
-
-/**
- * Set the behavior of the label with longer text then the object size
- * @param label pointer to a label object
- * @param long_mode the new mode from 'lv_label_long_mode' enum.
- */
-void lv_label_set_long_mode(lv_obj_t * label, lv_label_long_mode_t long_mode);
-
-/**
- * Enable the recoloring by in-line commands
- * @param label pointer to a label object
- * @param recolor true: enable recoloring, false: disable
- */
-void lv_label_set_recolor(lv_obj_t * label, bool recolor);
-
-/**
- * Get the text of a label
- * @param label pointer to a label object
- * @return the text of the label
- */
-const char * lv_label_get_text(lv_obj_t * label);
-
-/**
- * Get the long mode of a label
- * @param label pointer to a label object
- * @return the long mode
- */
-lv_label_long_mode_t lv_label_get_long_mode(lv_obj_t * label);
-
-/**
- * Get the recoloring attribute
- * @param label pointer to a label object
- * @return true: recoloring is enabled, false: disable
- */
-bool lv_label_get_recolor(lv_obj_t * label);
-
-/**
- * Get the relative x and y coordinates of a letter
- * @param label pointer to a label object
- * @param index index of the letter (0 ... text length)
- * @param pos store the result here (E.g. index = 0 gives 0;0 coordinates)
- */
-void lv_label_get_letter_pos(lv_obj_t * label, uint16_t index, point_t * pos);
-
-/**
- * Get the index of letter on a relative point of a label
- * @param label pointer to label object
- * @param pos pointer to point with coordinates on a the label
- * @return the index of the letter on the 'pos_p' point (E.g. on 0;0 is the 0. letter)
- */
-uint16_t lv_label_get_letter_on(lv_obj_t * label, point_t * pos);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_led.c

@@ -1,219 +0,0 @@
-/**
- * @file lv_led.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_LED != 0
-
-#include "lv_led.h"
-#include "../lv_draw/lv_draw.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_LED_WIDTH_DEF    (LV_DPI / 3)
-#define LV_LED_HEIGHT_DEF   (LV_DPI / 3)
-#define LV_LED_BRIGHT_OFF	100
-#define LV_LED_BRIGHT_ON	255
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_led_design(lv_obj_t * led, const area_t * mask, lv_design_mode_t mode);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_f_t ancestor_design_f;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a led objects
- * @param par pointer to an object, it will be the parent of the new led
- * @param copy pointer to a led object, if not NULL then the new object will be copied from it
- * @return pointer to the created led
- */
-lv_obj_t * lv_led_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor basic object*/
-	lv_obj_t * new_led = lv_obj_create(par, copy);
-    dm_assert(new_led);
-    
-    /*Allocate the object type specific extended data*/
-    lv_led_ext_t * ext = lv_obj_alloc_ext(new_led, sizeof(lv_led_ext_t));
-    dm_assert(ext);
-    ext->bright = LV_LED_BRIGHT_ON;
-
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_f(new_led);
-
-    lv_obj_set_signal_f(new_led, lv_led_signal);
-    lv_obj_set_design_f(new_led, lv_led_design);
-
-    /*Init the new led object*/
-    if(copy == NULL) {
-    	lv_obj_set_style(new_led, lv_style_get(LV_STYLE_PRETTY_COLOR, NULL));
-    	lv_obj_set_size(new_led, LV_LED_WIDTH_DEF, LV_LED_HEIGHT_DEF);
-    }
-    /*Copy an existing object*/
-    else {
-    	lv_led_ext_t * copy_ext = lv_obj_get_ext(copy);
-    	ext->bright = copy_ext->bright;
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_led);
-    }
-    
-    return new_led;
-}
-
-/**
- * Signal function of the led
- * @param led pointer to a led object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_led_signal(lv_obj_t * led, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_obj_signal(led, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the brightness of a LED object
- * @param led pointer to a LED object
- * @param bright 0 (max. dark) ... 255 (max. light)
- */
-void lv_led_set_bright(lv_obj_t * led, uint8_t bright)
-{
-	/*Set the brightness*/
-	lv_led_ext_t * ext = lv_obj_get_ext(led);
-	ext->bright = bright;
-
-	/*Invalidate the object there fore it will be redrawn*/
-	lv_obj_inv(led);
-}
-
-/**
- * Light on a LED
- * @param led pointer to a LED object
- */
-void lv_led_on(lv_obj_t * led)
-{
-	lv_led_set_bright(led, LV_LED_BRIGHT_ON);
-}
-
-/**
- * Light off a LED
- * @param led pointer to a LED object
- */
-void lv_led_off(lv_obj_t * led)
-{
-	lv_led_set_bright(led, LV_LED_BRIGHT_OFF);
-}
-
-
-/**
- * Toggle the state of a LED
- * @param led pointer to a LED object
- */
-void lv_led_tgl(lv_obj_t * led)
-{
-	uint8_t bright = lv_led_get_bright(led);
-	if(bright > (LV_LED_BRIGHT_OFF + LV_LED_BRIGHT_ON) >> 1) lv_led_off(led);
-	else lv_led_on(led);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the brightness of a LEd object
- * @param led pointer to LED object
- * @return bright 0 (max. dark) ... 255 (max. light)
- */
-uint8_t lv_led_get_bright(lv_obj_t * led)
-{
-	lv_led_ext_t * ext = lv_obj_get_ext(led);
-	return ext->bright;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the leds
- * @param led pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_led_design(lv_obj_t * led, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	/*Return false if the object is not covers the mask area*/
-    	return ancestor_design_f(led, mask, mode);
-    } else if(mode == LV_DESIGN_DRAW_MAIN) {
-		/*Make darker colors in a temporary style according to the brightness*/
-		lv_led_ext_t * ext = lv_obj_get_ext(led);
-		lv_style_t * style = lv_obj_get_style(led);
-
-		/*Create a temporal style*/
-        lv_style_t leds_tmp;
-		memcpy(&leds_tmp, style, sizeof(leds_tmp));
-
-		/*Mix. the color with black proportionally with brightness*/
-		leds_tmp.mcolor = color_mix(leds_tmp.mcolor, COLOR_BLACK, ext->bright);
-		leds_tmp.gcolor = color_mix(leds_tmp.gcolor, COLOR_BLACK, ext->bright);
-        leds_tmp.bcolor = color_mix(leds_tmp.bcolor, COLOR_BLACK, ext->bright);
-
-		/*Set the current swidth according to brightness proportionally between LV_LED_BRIGHT_OFF and LV_LED_BRIGHT_ON*/
-		uint16_t bright_tmp = ext->bright;
-        leds_tmp.swidth = ((bright_tmp - LV_LED_BRIGHT_OFF) * style->swidth) / (LV_LED_BRIGHT_ON - LV_LED_BRIGHT_OFF);
-
-		led->style_p = &leds_tmp;
-		ancestor_design_f(led, mask, mode);
-        led->style_p = style;
-    }
-    return true;
-}
-
-#endif

lv_objx/lv_line.c

@@ -1,293 +0,0 @@
-/**
- * @file lv_line.c
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-
-#if USE_LV_LINE != 0
-#include "lv_line.h"
-#include "../lv_draw/lv_draw.h"
-#include "misc/math/math_base.h"
-#include <stdbool.h>
-#include <stdint.h>
-#include <string.h>
-
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_line_design(lv_obj_t * line, const area_t * mask, lv_design_mode_t mode);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/**
- * Create a line objects
- * @param par pointer to an object, it will be the parent of the new line
- * @return pointer to the created line
- */
-lv_obj_t * lv_line_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create a basic object*/
-    lv_obj_t * new_line = lv_obj_create(par, copy);
-    dm_assert(new_line);
-
-    /*Extend the basic object to line object*/
-    lv_line_ext_t * ext = lv_obj_alloc_ext(new_line, sizeof(lv_line_ext_t));
-    dm_assert(ext);
-    ext->point_num = 0;
-    ext->point_array = NULL;
-    ext->auto_size = 1;
-    ext->y_inv = 0;
-    ext->upscale = 0;
-
-    lv_obj_set_design_f(new_line, lv_line_design);
-    lv_obj_set_signal_f(new_line, lv_line_signal);
-
-    /*Init the new line*/
-    if(copy == NULL) {
-	    lv_obj_set_style(new_line, lv_style_get(LV_STYLE_PLAIN, NULL));
-    }
-    /*Copy an existing object*/
-    else {
-        lv_line_ext_t * copy_ext = lv_obj_get_ext(copy);
-    	lv_line_set_auto_size(new_line,lv_line_get_auto_size(copy));
-    	lv_line_set_y_inv(new_line,lv_line_get_y_inv(copy));
-    	lv_line_set_auto_size(new_line,lv_line_get_auto_size(copy));
-    	lv_line_set_upscale(new_line,lv_line_get_upscale(copy));
-    	lv_line_set_points(new_line, copy_ext->point_array, copy_ext->point_num);
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_line);
-    }
-
-    return new_line;
-}
-
-/**
- * Signal function of the line
- * @param line pointer to a line object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_line_signal(lv_obj_t * line, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_obj_signal(line, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	switch(sign) {
-    		default:
-    			break;
-    	}
-    }
-
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set an array of points. The line object will connect these points.
- * @param line pointer to a line object
- * @param point_a an array of points. Only the address is saved,
- * so the array can NOT be a local variable which will be destroyed
- * @param point_num number of points in 'point_a'
- */
-void lv_line_set_points(lv_obj_t * line, const point_t * point_a, uint16_t point_num)
-{
-	lv_line_ext_t * ext = lv_obj_get_ext(line);
-	ext->point_array = point_a;
-	ext->point_num = point_num;
-
-	uint8_t us = 1;
-	if(ext->upscale != 0) {
-		us = LV_DOWNSCALE;
-	}
-
-	if(point_num > 0 && ext->auto_size != 0) {
-		uint16_t i;
-		cord_t xmax = CORD_MIN;
-		cord_t ymax = CORD_MIN;
-		for(i = 0; i < point_num; i++) {
-			xmax = MATH_MAX(point_a[i].x * us, xmax);
-			ymax = MATH_MAX(point_a[i].y * us, ymax);
-		}
-
-		lv_style_t * lines = lv_obj_get_style(line);
-		lv_obj_set_size(line, xmax + lines->line_width, ymax + lines->line_width);
-	}
-}
-
-/**
- * Enable (or disable) the auto-size option. The size of the object will fit to its points.
- * (set width to x max and height to y max)
- * @param line pointer to a line object
- * @param autosize true: auto size is enabled, false: auto size is disabled
- */
-void lv_line_set_auto_size(lv_obj_t * line, bool autosize)
-{
-	lv_line_ext_t * ext = lv_obj_get_ext(line);
-
-	ext->auto_size = autosize == false ? 0 : 1;
-
-	/*Refresh the object*/
-	if(autosize != false) {
-		lv_line_set_points(line, ext->point_array, ext->point_num);
-	}
-}
-
-/**
- * Enable (or disable) the y coordinate inversion.
- * If enabled then y will be subtracted from the height of the object,
- * therefore the y=0 coordinate will be on the bottom.
- * @param line pointer to a line object
- * @param yinv true: enable the y inversion, false:disable the y inversion
- */
-void lv_line_set_y_inv(lv_obj_t * line, bool yinv)
-{
-	lv_line_ext_t * ext = lv_obj_get_ext(line);
-
-	ext->y_inv = yinv == false ? 0 : 1;
-
-	lv_obj_inv(line);
-}
-
-/**
- * Enable (or disable) the point coordinate upscaling (compensate LV_DOWNSCALE).
- * @param line pointer to a line object
- * @param unscale true: enable the point coordinate upscaling
- */
-void lv_line_set_upscale(lv_obj_t * line, bool unscale)
-{
-	lv_line_ext_t * ext = lv_obj_get_ext(line);
-
-	ext->upscale = unscale == false ? 0 : 1;
-
-	/*Refresh to point to handle auto size*/
-	lv_line_set_points(line, ext->point_array, ext->point_num);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the auto size attribute
- * @param line pointer to a line object
- * @return true: auto size is enabled, false: disabled
- */
-bool lv_line_get_auto_size(lv_obj_t * line)
-{
-	lv_line_ext_t * ext = lv_obj_get_ext(line);
-
-	return ext->auto_size == 0 ? false : true;
-}
-
-/**
- * Get the y inversion attribute
- * @param line pointer to a line object
- * @return true: y inversion is enabled, false: disabled
- */
-bool lv_line_get_y_inv(lv_obj_t * line)
-{
-	lv_line_ext_t * ext = lv_obj_get_ext(line);
-
-	return ext->y_inv == 0 ? false : true;
-}
-
-/**
- * Get the point upscale enable attribute
- * @param obj pointer to a line object
- * @return true: point coordinate upscale is enabled, false: disabled
- */
-bool lv_line_get_upscale(lv_obj_t * line)
-{
-	lv_line_ext_t * ext = lv_obj_get_ext(line);
-
-	return ext->upscale == 0 ? false : true;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the lines
- * @param line pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_line_design(lv_obj_t * line, const area_t * mask, lv_design_mode_t mode)
-{
-    /*A line never covers an area*/
-    if(mode == LV_DESIGN_COVER_CHK) return false;
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-		lv_line_ext_t * ext = lv_obj_get_ext(line);
-
-		if(ext->point_num == 0 || ext->point_array == NULL) return false;
-
-		lv_style_t * style = lv_obj_get_style(line);
-		area_t area;
-		lv_obj_get_cords(line, &area);
-		cord_t x_ofs = area.x1;
-		cord_t y_ofs = area.y1;
-		point_t p1;
-		point_t p2;
-		cord_t h = lv_obj_get_height(line);
-		uint16_t i;
-		uint8_t us = 1;
-		if(ext->upscale != 0) {
-			us = LV_DOWNSCALE;
-		}
-
-		/*Read all pints and draw the lines*/
-		for (i = 0; i < ext->point_num - 1; i++) {
-
-			p1.x = ext->point_array[i].x * us + x_ofs;
-			p2.x = ext->point_array[i + 1].x * us + x_ofs;
-
-			if(ext->y_inv == 0) {
-				p1.y = ext->point_array[i].y * us + y_ofs;
-				p2.y = ext->point_array[i + 1].y * us + y_ofs;
-			} else {
-				p1.y = h - ext->point_array[i].y * us + y_ofs;
-				p2.y = h - ext->point_array[i + 1].y * us + y_ofs;
-			}
-			lv_draw_line(&p1, &p2, mask, style);
-		}
-    }
-    return true;
-}
-
-#endif

lv_objx/lv_line.h

@@ -1,115 +0,0 @@
-/**
- * @file lv_line.h
- *
- */
-
-#ifndef LV_LINE_H
-#define LV_LINE_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_LINE != 0
-
-#include "lvgl/lv_obj/lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of line*/
-typedef struct
-{
-    /*Inherited from 'base_obj' so no inherited ext.*/  /*Ext. of ancestor*/
-    const point_t * point_array;    /*Pointer to an array with the points of the line*/
-    uint16_t  point_num;            /*Number of points in 'point_array' */
-    uint8_t  auto_size  :1;         /*1: set obj. width to x max and obj. height to y max */
-    uint8_t  y_inv      :1;         /*1: y == 0 will be on the bottom*/
-    uint8_t  upscale    :1;         /*1: upscale coordinates with LV_DOWNSCALE*/
-}lv_line_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a line objects
- * @param par pointer to an object, it will be the parent of the new line
- * @return pointer to the created line
- */
-lv_obj_t * lv_line_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the line
- * @param line pointer to a line object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_line_signal(lv_obj_t * line, lv_signal_t sign, void * param);
-
-/**
- * Set an array of points. The line object will connect these points.
- * @param line pointer to a line object
- * @param point_a an array of points. Only the address is saved,
- * so the array can NOT be a local variable which will be destroyed
- * @param point_num number of points in 'point_a'
- */
-void lv_line_set_points(lv_obj_t * line, const point_t * point_a, uint16_t point_num);
-
-/**
- * Enable (or disable) the auto-size option. The size of the object will fit to its points.
- * (set width to x max and height to y max)
- * @param line pointer to a line object
- * @param autosize true: auto size is enabled, false: auto size is disabled
- */
-void lv_line_set_auto_size(lv_obj_t * line, bool autosize);
-
-/**
- * Enable (or disable) the y coordinate inversion.
- * If enabled then y will be subtracted from the height of the object,
- * therefore the y=0 coordinate will be on the bottom.
- * @param line pointer to a line object
- * @param yinv true: enable the y inversion, false:disable the y inversion
- */
-void lv_line_set_y_inv(lv_obj_t * line, bool yinv);
-
-/**
- * Enable (or disable) the point coordinate upscaling (compensate LV_DOWNSCALE).
- * @param line pointer to a line object
- * @param unscale true: enable the point coordinate upscaling
- */
-void lv_line_set_upscale(lv_obj_t * line, bool unscale);
-
-/**
- * Get the auto size attribute
- * @param line pointer to a line object
- * @return true: auto size is enabled, false: disabled
- */
-bool lv_line_get_auto_size(lv_obj_t * line);
-
-/**
- * Get the y inversion attribute
- * @param line pointer to a line object
- * @return true: y inversion is enabled, false: disabled
- */
-bool lv_line_get_y_inv(lv_obj_t * line);
-
-/**
- * Get the point upscale enable attribute
- * @param obj pointer to a line object
- * @return true: point coordinate upscale is enabled, false: disabled
- */
-bool lv_line_get_upscale(lv_obj_t * line);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_list.c

@@ -1,370 +0,0 @@
-/**
- * @file lv_list.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_LIST != 0
-
-#include "lv_list.h"
-#include <lvgl/lv_objx/lv_cont.h>
-#include "misc/math/math_base.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_LIST_LAYOUT_DEF	LV_CONT_LAYOUT_COL_M
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-#if 0
-static bool lv_list_design(lv_obj_t * list, const area_t * mask, lv_design_mode_t mode);
-#endif
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a list objects
- * @param par pointer to an object, it will be the parent of the new list
- * @param copy pointer to a list object, if not NULL then the new object will be copied from it
- * @return pointer to the created list
- */
-lv_obj_t * lv_list_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor basic object*/
-    lv_obj_t * new_list = lv_page_create(par, copy);
-    dm_assert(new_list);
-    lv_list_ext_t * ext = lv_obj_alloc_ext(new_list, sizeof(lv_list_ext_t));
-    dm_assert(ext);
-
-    ext->sb_out = 0;
-    ext->style_img = NULL;
-    ext->styles_btn[LV_BTN_STATE_REL] = lv_style_get(LV_STYLE_BTN_REL, NULL);
-    ext->styles_btn[LV_BTN_STATE_PR] = lv_style_get(LV_STYLE_BTN_PR, NULL);
-    ext->styles_btn[LV_BTN_STATE_TREL] = lv_style_get(LV_STYLE_BTN_TREL, NULL);
-    ext->styles_btn[LV_BTN_STATE_PR] = lv_style_get(LV_STYLE_BTN_TPR, NULL);
-    ext->styles_btn[LV_BTN_STATE_INA] = lv_style_get(LV_STYLE_BTN_INA, NULL);
-
-	lv_obj_set_signal_f(new_list, lv_list_signal);
-
-    /*Init the new list object*/
-    if(copy == NULL) {
-    	lv_obj_set_size(new_list, 2 * LV_DPI, 3 * LV_DPI);
-		lv_cont_set_layout(ext->page.scrl, LV_LIST_LAYOUT_DEF);
-		lv_obj_set_style(new_list, lv_style_get(LV_STYLE_TRANSP_TIGHT, NULL));
-		lv_obj_set_style(lv_page_get_scrl(new_list), lv_style_get(LV_STYLE_PRETTY, NULL));
-		lv_page_set_sb_mode(new_list, LV_PAGE_SB_MODE_AUTO);
-    } else {
-        lv_list_ext_t * copy_ext = lv_obj_get_ext(copy);
-
-        lv_list_set_styles_btn(new_list, copy_ext->styles_btn[LV_BTN_STATE_REL],
-                                         copy_ext->styles_btn[LV_BTN_STATE_PR],
-                                         copy_ext->styles_btn[LV_BTN_STATE_TREL],
-                                         copy_ext->styles_btn[LV_BTN_STATE_TPR],
-                                         copy_ext->styles_btn[LV_BTN_STATE_INA]);
-        lv_list_set_style_img(new_list, copy_ext->style_img);
-
-        lv_list_set_sb_out(new_list, copy_ext->sb_out);
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_list);
-    }
-    
-    return new_list;
-}
-
-/**
- * Signal function of the list
- * @param list pointer to a list object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_page_signal(list, sign, param);
-    
-    return valid;
-}
-
-/**
- * Add a list element to the list
- * @param list pointer to list object
- * @param img_fn file name of an image before the text (NULL if unused)
- * @param txt text of the list element (NULL if unused)
- * @param rel_action pointer to release action function (like with lv_btn)
- * @return pointer to the new list element which can be customized (a button)
- */
-lv_obj_t * lv_list_add(lv_obj_t * list, const char * img_fn, const char * txt, lv_action_t rel_action)
-{
-	lv_style_t * style = lv_obj_get_style(list);
-    lv_list_ext_t * ext = lv_obj_get_ext(list);
-
-	/*Create a list element with the image an the text*/
-	lv_obj_t * liste;
-	liste = lv_btn_create(list, NULL);
-	lv_btn_set_styles(liste, ext->styles_btn[LV_BTN_STATE_REL], ext->styles_btn[LV_BTN_STATE_PR],
-	                         ext->styles_btn[LV_BTN_STATE_TREL], ext->styles_btn[LV_BTN_STATE_TPR],
-	                         ext->styles_btn[LV_BTN_STATE_INA]);
-
-	lv_btn_set_rel_action(liste, rel_action);
-	lv_page_glue_obj(liste, true);
-	lv_cont_set_layout(liste, LV_CONT_LAYOUT_ROW_M);
-	lv_cont_set_fit(liste, false, true);
-
-	if(img_fn != NULL && img_fn[0] != '\0') {
-		lv_obj_t * img = lv_img_create(liste, NULL);
-		lv_img_set_file(img, img_fn);
-		lv_obj_set_style(img, ext->style_img);
-		lv_obj_set_click(img, false);
-	}
-
-	if(txt != NULL) {
-		lv_obj_t * label = lv_label_create(liste, NULL);
-		lv_label_set_text(label, txt);
-		lv_obj_set_style(label, ext->styles_btn[LV_BTN_STATE_REL]);
-		lv_obj_set_click(label, false);
-	}
-
-	/*Make the size adjustment*/
-    cord_t w = lv_obj_get_width(list);
-    lv_style_t *  style_scrl = lv_obj_get_style(lv_page_get_scrl(list));
-    cord_t hpad_tot = style->hpad + style_scrl->hpad;
-    w -= hpad_tot * 2;
-
-    /*Make place for the scrollbar if hpad_tot is too small*/
-    if(ext->sb_out != 0) {
-        if(hpad_tot < ext->page.sb_width) w -= ext->page.sb_width - hpad_tot;
-    }
-    lv_obj_set_width(liste, w);
-
-	return liste;
-}
-
-/**
- * Move the list elements up by one
- * @param list pointer a to list object
- */
-void lv_list_up(lv_obj_t * list)
-{
-	/*Search the first list element which 'y' coordinate is below the parent
-	 * and position the list to show this element on the bottom*/
-	lv_obj_t * h = lv_obj_get_parent(list);
-	lv_obj_t * e;
-	lv_obj_t * e_prev = NULL;
-	e = lv_obj_get_child(list, NULL);
-	while(e != NULL) {
-		if(e->cords.y2 <= h->cords.y2) {
-			if(e_prev != NULL)
-			lv_obj_set_y(list, lv_obj_get_height(h) -
-					             (lv_obj_get_y(e_prev) + lv_obj_get_height(e_prev)));
-			break;
-		}
-		e_prev = e;
-		e = lv_obj_get_child(list, e);
-	}
-}
-
-/**
- * Move the list elements down by one
- * @param list pointer to a list object
- */
-void lv_list_down(lv_obj_t * list)
-{
-	/*Search the first list element which 'y' coordinate is above the parent
-	 * and position the list to show this element on the top*/
-	lv_obj_t * h = lv_obj_get_parent(list);
-	lv_obj_t * e;
-	e = lv_obj_get_child(list, NULL);
-	while(e != NULL) {
-		if(e->cords.y1 < h->cords.y1) {
-			lv_obj_set_y(list, -lv_obj_get_y(e));
-			break;
-		}
-		e = lv_obj_get_child(list, e);
-	}
-}
-
-
-/*=====================
- * Setter functions 
- *====================*/
-
-/**
- * Enable/Disable to scrollbar outside attribute
- * @param list pointer to list object
- * @param out true: reduce the buttons width therefore scroll bar will be out of the buttons,
- *            false: keep button size and place scroll bar on the buttons
- */
-void lv_list_set_sb_out(lv_obj_t * list, bool out)
-{
-    lv_list_ext_t * ext = lv_obj_get_ext(list);
-
-    ext->sb_out = out == false ? 0 : 1;
-}
-
-/**
- * Set styles of the list elements of a list in each state
- * @param list pointer to list object
- * @param rel pointer to a style for releases state
- * @param pr  pointer to a style for pressed state
- * @param trel pointer to a style for toggled releases state
- * @param tpr pointer to a style for toggled pressed state
- * @param ina pointer to a style for inactive state
- */
-void lv_list_set_styles_btn(lv_obj_t * list, lv_style_t * rel, lv_style_t * pr,
-                                               lv_style_t * trel, lv_style_t * tpr,
-                                               lv_style_t * ina)
-{
-    lv_list_ext_t * ext = lv_obj_get_ext(list);
-
-    ext->styles_btn[LV_BTN_STATE_REL] = rel;
-    ext->styles_btn[LV_BTN_STATE_PR] = pr;
-    ext->styles_btn[LV_BTN_STATE_TREL] = trel;
-    ext->styles_btn[LV_BTN_STATE_TPR] = tpr;
-    ext->styles_btn[LV_BTN_STATE_INA] = ina;
-
-    lv_obj_t * scrl = lv_page_get_scrl(list);
-    lv_obj_t * liste = lv_obj_get_child(scrl, NULL);
-    while(liste != NULL)
-    {
-        lv_btn_set_styles(liste, rel, pr, trel, tpr, ina);
-        liste = lv_obj_get_child(scrl, liste);
-    }
-}
-
-
-/**
- * Set the styles of the list element image (typically to set symbol font)
- * @param list pointer to list object
- * @param style pointer to the new style of the button images
- */
-void lv_list_set_style_img(lv_obj_t * list, lv_style_t * style)
-{
-    lv_list_ext_t * ext = lv_obj_get_ext(list);
-
-    ext->style_img = style;
-
-    lv_obj_t * scrl = lv_page_get_scrl(list);
-    lv_obj_t * liste = lv_obj_get_child(scrl, NULL);
-    lv_obj_t * img;
-    while(liste != NULL)
-    {
-        img = lv_obj_get_child(liste, NULL); /*Now img = the label*/
-        img = lv_obj_get_child(liste, img);  /*Now img = the image (if ULL then no image) */
-        if(img != NULL) lv_obj_set_style(img, style);
-
-        liste = lv_obj_get_child(scrl, liste);
-    }
-}
-
-/*=====================
- * Getter functions 
- *====================*/
-
-/**
- * Get the text of a list element
- * @param liste pointer to list element
- * @return pointer to the text
- */
-const char * lv_list_get_element_text(lv_obj_t * liste)
-{
-    /*The last child is the label*/
-    lv_obj_t * label = lv_obj_get_child(liste, NULL);
-    return lv_label_get_text(label);
-}
-
-/**
- * Get the scroll bar outside attribute
- * @param list pointer to list object
- * @param en true: scroll bar outside the buttons, false: scroll bar inside
- */
-bool lv_list_get_sb_out(lv_obj_t * list, bool en)
-{
-    lv_list_ext_t * ext = lv_obj_get_ext(list);
-    return ext->sb_out == 0 ? false : true;
-}
-
-/**
- * Get the style of the list elements in a given state
- * @param list pointer to a list object
- * @param state a state from 'lv_btn_state_t' in which style should be get
- * @return pointer to the style in the given state
- */
-lv_style_t * lv_list_get_style_liste(lv_obj_t * list, lv_btn_state_t state)
-{
-    lv_list_ext_t * ext = lv_obj_get_ext(list);
-
-    if(ext->styles_btn[state] == NULL) return lv_obj_get_style(list);
-
-    return ext->styles_btn[state];
-}
-
-
-/**
- * Get the style of the list elements images
- * @param list pointer to a list object
- * @return pointer to the image style
- */
-lv_style_t * lv_list_get_style_img(lv_obj_t * list, lv_btn_state_t state)
-{
-    lv_list_ext_t * ext = lv_obj_get_ext(list);
-
-    if(ext->style_img == NULL) return lv_list_get_style_liste(list, LV_BTN_STATE_REL);
-
-    return ext->style_img;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-#if 0 /*A new design function is not necessary*/
-/**
- * Handle the drawing related tasks of the lists
- * @param list pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_list_design(lv_obj_t * list, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	/*Return false if the object is not covers the mask_p area*/
-    	return false;
-    }
-
-    /*Draw the object*/
-
-    return true;
-}
-#endif
-
-#endif

lv_objx/lv_list.h

@@ -1,161 +0,0 @@
-/**
- * @file lv_list.h
- * 
- */
-
-#ifndef LV_LIST_H
-#define LV_LIST_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_LIST != 0
-
-/*Testing of dependencies*/
-#if USE_LV_PAGE == 0
-#error "lv_list: lv_page is required. Enable it in lv_conf.h (USE_LV_PAGE  1) "
-#endif
-
-#if USE_LV_BTN == 0
-#error "lv_list: lv_btn is required. Enable it in lv_conf.h (USE_LV_BTN  1) "
-#endif
-
-#if USE_LV_LABEL == 0
-#error "lv_list: lv_label is required. Enable it in lv_conf.h (USE_LV_LABEL  1) "
-#endif
-
-#if USE_LV_IMG == 0
-#error "lv_list: lv_img is required. Enable it in lv_conf.h (USE_LV_IMG  1) "
-#endif
-
-
-#include "../lv_obj/lv_obj.h"
-#include "lv_page.h"
-#include "lv_btn.h"
-#include "lv_label.h"
-#include "lv_img.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-/*Data of list*/
-typedef struct
-{
-    lv_page_ext_t page; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_style_t * styles_btn[LV_BTN_STATE_NUM];    /*Styles of the list element buttons*/
-    lv_style_t * style_img;    /*Style of the list element images on buttons*/
-    uint8_t sb_out   :1;        /*1: Keep space for the scrollbar*/
-}lv_list_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a list objects
- * @param par pointer to an object, it will be the parent of the new list
- * @param copy pointer to a list object, if not NULL then the new object will be copied from it
- * @return pointer to the created list
- */
-lv_obj_t * lv_list_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the list
- * @param list pointer to a list object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_list_signal(lv_obj_t * list, lv_signal_t sign, void * param);
-
-/**
- * Add a list element to the list
- * @param list pointer to list object
- * @param img_fn file name of an image before the text (NULL if unused)
- * @param txt text of the list element (NULL if unused)
- * @param rel_action pointer to release action function (like with lv_btn)
- * @return pointer to the new list element which can be customized (a button)
- */
-lv_obj_t * lv_list_add(lv_obj_t * list, const char * img_fn, const char * txt, lv_action_t rel_action);
-
-/**
- * Move the list elements up by one
- * @param list pointer a to list object
- */
-void lv_list_up(lv_obj_t * list);
-
-/**
- * Move the list elements down by one
- * @param list pointer to a list object
- */
-void lv_list_down(lv_obj_t * list);
-
-/**
- * Enable/Disable to scrollbar outside attribute
- * @param list pointer to list object
- * @param out true: reduce the buttons width therefore scroll bar will be out of the buttons,
- *            false: keep button size and place scroll bar on the buttons
- */
-void lv_list_set_sb_out(lv_obj_t * list, bool out);
-
-/**
- * Set styles of the list elements of a list in each state
- * @param list pointer to list object
- * @param rel pointer to a style for releases state
- * @param pr  pointer to a style for pressed state
- * @param trel pointer to a style for toggled releases state
- * @param tpr pointer to a style for toggled pressed state
- * @param ina pointer to a style for inactive state
- */
-void lv_list_set_styles_btn(lv_obj_t * list, lv_style_t * rel, lv_style_t * pr,
-                            lv_style_t * trel, lv_style_t * tpr,
-                            lv_style_t * ina);
-
-/**
- * Set the styles of the list element image (typically to set symbol font)
- * @param list pointer to list object
- * @param style pointer to the new style of the button images
- */
-void lv_list_set_style_img(lv_obj_t * list, lv_style_t * style);
-
-/**
- * Get the text of a list element
- * @param liste pointer to list element
- * @return pointer to the text
- */
-const char * lv_list_get_element_text(lv_obj_t * liste);
-
-/**
- * Get the scroll bar outside attribute
- * @param list pointer to list object
- * @param en true: scroll bar outside the buttons, false: scroll bar inside
- */
-bool lv_list_get_sb_out(lv_obj_t * list, bool en);
-
-/**
- * Get the style of the list elements in a given state
- * @param list pointer to a list object
- * @param state a state from 'lv_btn_state_t' in which style should be get
- * @return pointer to the style in the given state
- */
-lv_style_t * lv_list_get_style_liste(lv_obj_t * list, lv_btn_state_t state);
-
-/**
- * Get the style of the list elements images
- * @param list pointer to a list object
- * @return pointer to the image style
- */
-lv_style_t * lv_list_get_style_img(lv_obj_t * list, lv_btn_state_t state);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_lmeter.c

@@ -1,236 +0,0 @@
-/**
- * @file lv_lmeter.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_LMETER != 0
-
-#include "lv_lmeter.h"
-#include "misc/math/trigo.h"
-#include "../lv_draw/lv_draw.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_lmeter_design(lv_obj_t * lmeter, const area_t * mask, lv_design_mode_t mode);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a line meter objects
- * @param par pointer to an object, it will be the parent of the new line meter
- * @param copy pointer to a line meter object, if not NULL then the new object will be copied from it
- * @return pointer to the created line meter
- */
-lv_obj_t * lv_lmeter_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor of line meter*/
-    lv_obj_t * new_lmeter = lv_bar_create(par, copy);
-    dm_assert(new_lmeter);
-    
-    /*Allocate the line meter type specific extended data*/
-    lv_lmeter_ext_t * ext = lv_obj_alloc_ext(new_lmeter, sizeof(lv_lmeter_ext_t));
-    dm_assert(ext);
-
-    /*Initialize the allocated 'ext' */
-    ext->scale_num = 31;    /*Odd scale number looks better*/
-    ext->scale_angle = 240; /*(scale_num - 1) * N looks better */
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_f(new_lmeter, lv_lmeter_signal);
-    lv_obj_set_design_f(new_lmeter, lv_lmeter_design);
-
-    /*Init the new line meter line meter*/
-    if(copy == NULL) {
-        lv_obj_set_size(new_lmeter, 1 * LV_DPI, 1 * LV_DPI);
-        lv_obj_set_style(new_lmeter, lv_style_get(LV_STYLE_PRETTY_COLOR, NULL));
-    }
-    /*Copy an existing line meter*/
-    else {
-    	lv_lmeter_ext_t * copy_ext = lv_obj_get_ext(copy);
-    	ext->scale_angle = copy_ext->scale_angle;
-        ext->scale_num = copy_ext->scale_num;
-
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_lmeter);
-    }
-    
-    return new_lmeter;
-}
-
-/**
- * Signal function of the line meter
- * @param lmeter pointer to a line meter object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_bar_signal(lmeter, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	if(sign == LV_SIGNAL_CLEANUP) {
-            /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
-    	}
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the scale settings of a line meter
- * @param lmeter pointer to a line meter object
- * @param angle angle of the scale (0..360)
- * @param num number of scale units
- */
-void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t num)
-{
-    lv_lmeter_ext_t * ext = lv_obj_get_ext(lmeter);
-    ext->scale_angle = angle;
-    ext->scale_num = num;
-
-    lv_obj_inv(lmeter);
-}
-
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the scale number of a line meter
- * @param lmeter pointer to a line meter object
- * @return number of the scale units
- */
-uint8_t lv_lmeter_get_scale_num(lv_obj_t * lmeter)
-{
-    lv_lmeter_ext_t * ext = lv_obj_get_ext(lmeter);
-    return ext->scale_num ;
-}
-
-/**
- * Get the scale angle of a line meter
- * @param lmeter pointer to a line meter object
- * @return angle of the scale
- */
-uint16_t lv_lmeter_get_scale_angle(lv_obj_t * lmeter)
-{
-    lv_lmeter_ext_t * ext = lv_obj_get_ext(lmeter);
-    return ext->scale_angle;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-
-/**
- * Handle the drawing related tasks of the line meters
- * @param lmeter pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_lmeter_design(lv_obj_t * lmeter, const area_t * mask, lv_design_mode_t mode)
-{
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	return false;
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-        lv_lmeter_ext_t * ext = lv_obj_get_ext(lmeter);
-        lv_style_t * style = lv_obj_get_style(lmeter);
-
-        lv_style_t style_tmp;
-        memcpy(&style_tmp, style, sizeof(lv_style_t));
-
-         cord_t r_out = lv_obj_get_width(lmeter) / 2;
-         cord_t r_in =r_out - style->hpad;
-         cord_t x_ofs = lv_obj_get_width(lmeter) / 2 + lmeter->cords.x1;
-         cord_t y_ofs = lv_obj_get_height(lmeter) / 2 + lmeter->cords.y1;
-         int16_t angle_ofs = 90 + (360 - ext->scale_angle) / 2;
-         int16_t min = lv_bar_get_min_value(lmeter);
-         int16_t max = lv_bar_get_max_value(lmeter);
-         int16_t level = (int32_t)((int32_t)(lv_bar_get_value(lmeter) - min) * ext->scale_num) / (max - min);
-         uint8_t i;
-
-         style_tmp.ccolor = style->mcolor;
-
-         for(i = 0; i < ext->scale_num; i++) {
-             /*Calculate the position a scale label*/
-             int16_t angle = (i * ext->scale_angle) / (ext->scale_num - 1) + angle_ofs;
-
-             cord_t y_out = (int32_t)((int32_t)trigo_sin(angle) * r_out) / TRIGO_SIN_MAX;
-             cord_t x_out = (int32_t)((int32_t)trigo_sin(angle + 90) * r_out) / TRIGO_SIN_MAX;
-             cord_t y_in = (int32_t)((int32_t)trigo_sin(angle) * r_in) / TRIGO_SIN_MAX;
-             cord_t x_in = (int32_t)((int32_t)trigo_sin(angle + 90) * r_in) / TRIGO_SIN_MAX;
-
-             point_t p1;
-             point_t p2;
-
-             p2.x = x_in + x_ofs;
-             p2.y = y_in +  y_ofs;
-
-             p1.x = x_out+ x_ofs;
-             p1.y = y_out + y_ofs;
-
-             if(i > level) style_tmp.ccolor = style->ccolor;
-             else {
-                 style_tmp.ccolor=color_mix(style->gcolor, style->mcolor, (255 * i) /  ext->scale_num);
-             }
-
-             lv_draw_line(&p1, &p2, mask, &style_tmp);
-         }
-
-    }
-    /*Post draw when the children are drawn*/
-    else if(mode == LV_DESIGN_DRAW_POST) {
-
-    }
-
-    return true;
-}
-
-
-#endif

lv_objx/lv_lmeter.h

@@ -1,93 +0,0 @@
-/**
- * @file lv_lmeter.h
- * 
- */
-
-#ifndef LV_LMETER_H
-#define LV_LMETER_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#include "misc_conf.h"
-#if USE_LV_LMETER != 0
-
-/*Testing of dependencies*/
-#if USE_LV_BAR == 0
-#error "lv_lmeter: lv_bar is required. Enable it in lv_conf.h (USE_LV_BAR  1) "
-#endif
-
-#if USE_TRIGO == 0
-#error "lv_lmeter: trigo is required. Enable it in misc_conf.h (USE_TRIGO  1) "
-#endif
-
-
-#include "../lv_obj/lv_obj.h"
-#include "lv_bar.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-/*Data of line meter*/
-typedef struct
-{
-    lv_bar_ext_t bar;            /*Ext. of ancestor*/
-    /*New data for this type */
-    uint16_t scale_angle;        /*Angle of the scale in deg. (0..360)*/
-    uint8_t scale_num;           /*Number of scale units */
-}lv_lmeter_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a line meter objects
- * @param par pointer to an object, it will be the parent of the new line meter
- * @param copy pointer to a line meter object, if not NULL then the new object will be copied from it
- * @return pointer to the created line meter
- */
-lv_obj_t * lv_lmeter_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the line meter
- * @param lmeter pointer to a line meter object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_lmeter_signal(lv_obj_t * lmeter, lv_signal_t sign, void * param);
-
-/**
- * Set the scale settings of a line meter
- * @param lmeter pointer to a line meter object
- * @param angle angle of the scale (0..360)
- * @param num number of scale units
- */
-void lv_lmeter_set_scale(lv_obj_t * lmeter, uint16_t angle, uint8_t num);
-
-/**
- * Get the scale number of a line meter
- * @param lmeter pointer to a line meter object
- * @return number of the scale units
- */
-uint8_t lv_lmeter_get_scale_num(lv_obj_t * lmeter);
-
-/**
- * Get the scale angle of a line meter
- * @param lmeter pointer to a line meter object
- * @return angle of the scale
- */
-uint16_t lv_lmeter_get_scale_angle(lv_obj_t * lmeter);
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_mbox.c

@@ -1,409 +0,0 @@
-/**
- * @file lv_mbox.c
- * 
- */
-
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_MBOX != 0
-
-#include "lv_mbox.h"
-#include "misc/gfx/anim.h"
-#include "misc/math/math_base.h"
-
-/*********************
- *      DEFINES
- *********************/
-#define LV_MBOX_CLOSE_ANIM_TIME     200 /*Default close anim. time [ms]*/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-#if 0 /*Unused*/
-static bool lv_mbox_design(lv_obj_t * mbox, const area_t * mask, lv_design_mode_t mode);
-#endif
-static void lv_mbox_realign(lv_obj_t * mbox);
-static void lv_mbox_disable_fit(lv_obj_t  * mbox);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a message box objects
- * @param par pointer to an object, it will be the parent of the new message box
- * @param copy pointer to a message box object, if not NULL then the new object will be copied from it
- * @return pointer to the created message box
- */
-lv_obj_t * lv_mbox_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor message box*/
-	lv_obj_t * new_mbox = lv_cont_create(par, copy);
-    dm_assert(new_mbox);
-    
-    /*Allocate the message box type specific extended data*/
-    lv_mbox_ext_t * ext = lv_obj_alloc_ext(new_mbox, sizeof(lv_mbox_ext_t));
-    dm_assert(ext);
-    ext->txt = NULL;
-    ext->btnh = NULL;
-    ext->style_btn_rel = lv_style_get(LV_STYLE_BTN_REL, NULL);
-    ext->style_btn_pr = lv_style_get(LV_STYLE_BTN_PR, NULL);
-    ext->anim_close_time = LV_MBOX_CLOSE_ANIM_TIME;
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_f(new_mbox, lv_mbox_signal);
-
-    /*Init the new message box message box*/
-    if(copy == NULL) {
-    	lv_cont_set_layout(new_mbox, LV_CONT_LAYOUT_COL_L);
-    	lv_cont_set_fit(new_mbox, true, true);
-
-    	ext->txt = lv_label_create(new_mbox, NULL);
-    	lv_label_set_text(ext->txt, "Text of the message box");
-
-    	lv_obj_set_style(new_mbox, lv_style_get(LV_STYLE_PRETTY, NULL));
-    }
-    /*Copy an existing message box*/
-    else {
-        lv_mbox_ext_t * copy_ext = lv_obj_get_ext(copy);
-
-        ext->txt = lv_label_create(new_mbox, copy_ext->txt);
-
-        /*Copy the buttons and the label on them*/
-        if(copy_ext->btnh != NULL) {
-            lv_obj_t * btn_copy;
-            const char * btn_txt_copy;
-            lv_btn_ext_t * btn_ext_copy;
-            LL_READ_BACK(copy_ext->btnh->child_ll, btn_copy) {
-                btn_txt_copy = lv_label_get_text(lv_obj_get_child(btn_copy, NULL));
-                btn_ext_copy = lv_obj_get_ext(btn_copy);
-                lv_mbox_add_btn(new_mbox, btn_txt_copy, btn_ext_copy->rel_action);
-            }
-        }
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_mbox);
-    }
-    
-    lv_mbox_realign(new_mbox);
-
-    return new_mbox;
-}
-
-/**
- * Signal function of the message box
- * @param mbox pointer to a message box object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    valid = lv_cont_signal(mbox, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-
-    	if(sign == LV_SIGNAL_CORD_CHG) {
-            /*If the size is changed refresh the message box*/
-            if(area_get_width(param) != lv_obj_get_width(mbox) ||
-               area_get_height(param) != lv_obj_get_height(mbox)) {
-                lv_mbox_realign(mbox);
-            }
-        }
-    	else if(sign == LV_SIGNAL_LONG_PRESS) {
-            lv_mbox_start_auto_close(mbox, 0);
-            lv_dispi_wait_release(param);
-            valid = false;
-        }
-    	else if(sign == LV_SIGNAL_STYLE_CHG) {
-            /*Refresh all the buttons*/
-            if(ext->btnh != NULL) {
-                lv_obj_t * btn;
-                btn = lv_obj_get_child(ext->btnh, NULL);
-                while(btn != NULL) {
-                    /*Refresh the next button's style*/
-                    lv_btn_set_styles(btn, ext->style_btn_rel, ext->style_btn_pr, NULL, NULL, NULL);
-
-                    btn = lv_obj_get_child(ext->btnh, btn);
-                }
-            }
-        }
-    }
-    
-    return valid;
-}
-
-/**
- * A release action which can be assigned to a message box button to close it
- * @param btn pointer to the released button
- * @param dispi pointer to the caller display input
- * @return always lv_action_res_t because the button is deleted with the mesage box
- */
-lv_action_res_t lv_mbox_close_action(lv_obj_t * btn, lv_dispi_t * dispi)
-{
-    lv_obj_t * mbox = lv_mbox_get_from_btn(btn);
-
-    lv_obj_del(mbox);
-
-    return LV_ACTION_RES_INV;
-}
-
-/**
- * Add a button to the message box
- * @param mbox pointer to message box object
- * @param btn_txt the text of the button
- * @param rel_action a function which will be called when the button is released
- * @return pointer to the created button (lv_btn)
- */
-lv_obj_t * lv_mbox_add_btn(lv_obj_t * mbox, const char * btn_txt, lv_action_t rel_action)
-{
-    lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-
-    /*Create a button if it is not existed yet*/
-    if(ext->btnh == NULL) {
-        ext->btnh = lv_cont_create(mbox, NULL);
-        lv_obj_set_style(ext->btnh, lv_style_get(LV_STYLE_TRANSP, NULL));
-        lv_obj_set_click(ext->btnh, false);
-        lv_cont_set_fit(ext->btnh, false, true);
-        lv_cont_set_layout(ext->btnh, LV_CONT_LAYOUT_PRETTY);
-    }
-
-    lv_obj_t * btn;
-    btn = lv_btn_create(ext->btnh, NULL);
-    lv_btn_set_rel_action(btn, rel_action);
-    lv_btn_set_styles(btn, ext->style_btn_rel, ext->style_btn_pr, NULL, NULL, NULL);
-    lv_cont_set_fit(btn, true, true);
-
-    lv_obj_t * label;
-    label = lv_label_create(btn, NULL);
-    lv_label_set_text(label, btn_txt);
-
-    lv_mbox_realign(mbox);
-
-    return btn;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set the text of the message box
- * @param mbox pointer to a message box
- * @param txt a '\0' terminated character string which will be the message box text
- */
-void lv_mbox_set_text(lv_obj_t * mbox, const char * txt)
-{
-    lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-
-    lv_label_set_text(ext->txt, txt);
-    lv_mbox_realign(mbox);
-}
-
-/**
- * Set styles of the buttons of a message box in each state
- * @param mbox pointer to a message box object
- * @param rel pointer to a style for releases state
- * @param pr  pointer to a style for pressed state
- * @param trel pointer to a style for toggled releases state
- * @param tpr pointer to a style for toggled pressed state
- * @param ina pointer to a style for inactive state
- */
-void lv_mbox_set_styles_btn(lv_obj_t * mbox, lv_style_t * rel, lv_style_t * pr)
-{
-    lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-
-    ext->style_btn_rel = rel;
-    ext->style_btn_pr = pr;
-    lv_obj_t * btn = lv_obj_get_child(ext->btnh, NULL);
-
-    while(btn != NULL) {
-        lv_btn_set_styles(btn, rel, pr, NULL, NULL, NULL);
-        btn = lv_obj_get_child(mbox, btn);
-    }
-}
-
-/**
- * Set close animation duration
- * @param mbox pointer to a message box object
- * @param time animation length in  milliseconds (0: no animation)
- */
-void lv_mbox_set_anim_close_time(lv_obj_t * mbox, uint16_t time)
-{
-    lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-    ext->anim_close_time = time;
-}
-
-/**
- * Automatically delete the message box after a given time
- * @param mbox pointer to a message box object
- * @param tout a time (in milliseconds) to wait before delete the message box
- */
-void lv_mbox_start_auto_close(lv_obj_t * mbox, uint16_t tout)
-{
-    lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-
-    if(ext->anim_close_time != 0) {
-        /*Add shrinking animations*/
-        lv_obj_anim(mbox, LV_ANIM_GROW_H| ANIM_OUT, ext->anim_close_time, tout, NULL);
-        lv_obj_anim(mbox, LV_ANIM_GROW_V| ANIM_OUT, ext->anim_close_time, tout, lv_obj_del);
-
-        /*When the animations start disable fit to let shrinking work*/
-        lv_obj_anim(mbox, LV_ANIM_NONE, 1, tout, lv_mbox_disable_fit);
-    } else {
-        lv_obj_anim(mbox, LV_ANIM_NONE, ext->anim_close_time, tout, lv_obj_del);
-    }
-}
-
-/**
- * Stop the auto. closing of message box
- * @param mbox pointer to a message box object
- */
-void lv_mbox_stop_auto_close(lv_obj_t * mbox)
-{
-    anim_del(mbox, NULL);
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the text of the message box
- * @param mbox pointer to a message box object
- * @return pointer to the text of the message box
- */
-const char * lv_mbox_get_txt(lv_obj_t * mbox)
-{
-	lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-
-	return lv_label_get_text(ext->txt);
-}
-
-/**
- * Get the message box object from one of its button.
- * It is useful in the button release actions where only the button is known
- * @param btn pointer to a button of a message box
- * @return pointer to the button's message box
- */
-lv_obj_t * lv_mbox_get_from_btn(lv_obj_t * btn)
-{
-	lv_obj_t * btnh = lv_obj_get_parent(btn);
-	lv_obj_t * mbox = lv_obj_get_parent(btnh);
-
-	return mbox;
-}
-
-/**
- * Get the close animation duration
- * @param mbox pointer to a message box object
- * @return animation length in  milliseconds (0: no animation)
- */
-uint16_t lv_mbox_get_anim_close_time(lv_obj_t * mbox )
-{
-    lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-    return ext->anim_close_time;
-}
-/**
- * Get the style of the buttons on a message box
- * @param mbox pointer to a message box object
- * @param state a state from 'lv_btn_state_t' in which style should be get
- * @return pointer to the style in the given state
- */
-lv_style_t * lv_mbox_get_style_btn(lv_obj_t * mbox, lv_btn_state_t state)
-{
-    lv_btn_ext_t * ext = lv_obj_get_ext(mbox);
-
-    if(ext->styles[state] == NULL) return lv_obj_get_style(mbox);
-
-    return ext->styles[state];
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-#if 0 /*Not used*/
-/**
- * Handle the drawing related tasks of the message boxs
- * @param mbox pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_mbox_design(lv_obj_t * mbox, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	/*Return false if the object is not covers the mask_p area*/
-    	return false;
-    }
-
-
-    /*Draw the object*/
-
-    return true;
-}
-#endif
-
-/**
- * Realign the elements of the message box
- * @param mbox pointer to message box object
- */
-static void lv_mbox_realign(lv_obj_t * mbox)
-{
-    lv_mbox_ext_t * ext = lv_obj_get_ext(mbox);
-
-    if(ext->txt == NULL) return;
-
-    /*Set the button holder width to the width of the text and title*/
-    if(ext->btnh != NULL) {
-        cord_t txt_w = lv_obj_get_width(ext->txt);
-        cord_t btn_w = 0;
-        lv_obj_t * btn;
-        btn = lv_obj_get_child(ext->btnh, NULL);
-        while(btn != NULL) {
-            btn_w = MATH_MAX(lv_obj_get_width(btn), btn_w);
-            btn = lv_obj_get_child(ext->btnh, btn);
-        }
-
-        cord_t w = MATH_MAX(txt_w, btn_w);
-        lv_obj_set_width(ext->btnh, w );
-    }
-}
-
-/**
- * Called when the close animations starts to disable the recargle's fit
- * @param mbox ppointer to message box object
- */
-static void lv_mbox_disable_fit(lv_obj_t  * mbox)
-{
-    lv_cont_set_fit(mbox, false, false);
-}
-
-#endif

lv_objx/lv_mbox.h

@@ -1,166 +0,0 @@
-/**
- * @file lv_mbox.h
- * 
- */
-
-#ifndef LV_MBOX_H
-#define LV_MBOX_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_MBOX != 0
-
-/*Testing of dependencies*/
-#if USE_LV_CONT == 0
-#error "lv_mbox: lv_cont is required. Enable it in lv_conf.h (USE_LV_CONT  1) "
-#endif
-
-#if USE_LV_BTN == 0
-#error "lv_mbox: lv_btn is required. Enable it in lv_conf.h (USE_LV_BTN  1) "
-#endif
-
-#if USE_LV_LABEL == 0
-#error "lv_mbox: lv_rlabel is required. Enable it in lv_conf.h (USE_LV_LABEL  1) "
-#endif
-
-
-#include "../lv_obj/lv_obj.h"
-#include <lvgl/lv_objx/lv_cont.h>
-#include "lv_btn.h"
-#include "lv_label.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Data of message box*/
-typedef struct
-{
-    lv_cont_ext_t bg; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * txt;             /*Text of the message box*/
-    lv_obj_t * btnh;            /*Holder of the buttons*/
-    lv_style_t * style_btn_rel; /*Style of the released buttons*/
-    lv_style_t * style_btn_pr;  /*Style of the pressed buttons*/
-    uint16_t anim_close_time;   /*Duration of close animation [ms] (0: no animation)*/
-}lv_mbox_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a message box objects
- * @param par pointer to an object, it will be the parent of the new message box
- * @param copy pointer to a message box object, if not NULL then the new object will be copied from it
- * @return pointer to the created message box
- */
-lv_obj_t * lv_mbox_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the message box
- * @param mbox pointer to a message box object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_mbox_signal(lv_obj_t * mbox, lv_signal_t sign, void * param);
-
-/**
- * A release action which can be assigned to a message box button to close it
- * @param btn pointer to the released button
- * @param dispi pointer to the caller display input
- * @return always lv_action_res_t because the button is deleted with the mesage box
- */
-lv_action_res_t lv_mbox_close_action(lv_obj_t * btn, lv_dispi_t * dispi);
-
-/**
- * Add a button to the message box
- * @param mbox pointer to message box object
- * @param btn_txt the text of the button
- * @param rel_action a function which will be called when the button is released
- * @return pointer to the created button (lv_btn)
- */
-lv_obj_t * lv_mbox_add_btn(lv_obj_t * mbox, const char * btn_txt, lv_action_t rel_action);
-
-/**
- * Set the text of the message box
- * @param mbox pointer to a message box
- * @param txt a '\0' terminated character string which will be the message box text
- */
-void lv_mbox_set_text(lv_obj_t * mbox, const char * txt);
-
-/**
- * Set styles of the buttons of a message box in each state
- * @param mbox pointer to a message box object
- * @param rel pointer to a style for releases state
- * @param pr  pointer to a style for pressed state
- * @param trel pointer to a style for toggled releases state
- * @param tpr pointer to a style for toggled pressed state
- * @param ina pointer to a style for inactive state
- */
-void lv_mbox_set_styles_btn(lv_obj_t * mbox, lv_style_t * rel, lv_style_t * pr);
-
-/**
- * Set close animation duration
- * @param mbox pointer to a message box object
- * @param time animation length in  milliseconds (0: no animation)
- */
-void lv_mbox_set_anim_close_time(lv_obj_t * mbox, uint16_t time);
-
-/**
- * Automatically delete the message box after a given time
- * @param mbox pointer to a message box object
- * @param tout a time (in milliseconds) to wait before delete the message box
- */
-void lv_mbox_start_auto_close(lv_obj_t * mbox, uint16_t tout);
-
-/**
- * Stop the auto. closing of message box
- * @param mbox pointer to a message box object
- */
-void lv_mbox_stop_auto_close(lv_obj_t * mbox);
-
-/**
- * Get the text of the message box
- * @param mbox pointer to a message box object
- * @return pointer to the text of the message box
- */
-const char * lv_mbox_get_txt(lv_obj_t * mbox);
-
-/**
- * Get the message box object from one of its button.
- * It is useful in the button release actions where only the button is known
- * @param btn pointer to a button of a message box
- * @return pointer to the button's message box
- */
-lv_obj_t * lv_mbox_get_from_btn(lv_obj_t * btn);
-
-/**
- * Get the close animation duration
- * @param mbox pointer to a message box object
- * @return animation length in  milliseconds (0: no animation)
- */
-uint16_t lv_mbox_get_anim_close_time(lv_obj_t * mbox );
-
-/**
- * Get the style of the buttons on a message box
- * @param mbox pointer to a message box object
- * @param state a state from 'lv_btn_state_t' in which style should be get
- * @return pointer to the style in the given state
- */
-lv_style_t * lv_mbox_get_style_btn(lv_obj_t * mbox, lv_btn_state_t state);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_objx_templ.c

@@ -1,166 +0,0 @@
-/**
- * @file lv_templ.c
- * 
- */
-
-/*Search an replace: template -> object normal name with lower case (e.g. button, label etc.)
- * 					 templ -> object short name with lower case(e.g. btn, label etc)
- *                   TEMPL -> object short name with upper case (e.g. BTN, LABEL etc.)
- *
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_TEMPL != 0
-
-#include "lv_templ.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static bool lv_templ_design(lv_obj_t * templ, const area_t * mask, lv_design_mode_t mode);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a template objects
- * @param par pointer to an object, it will be the parent of the new template
- * @param copy pointer to a template object, if not NULL then the new object will be copied from it
- * @return pointer to the created template
- */
-lv_obj_t * lv_templ_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor of template*/
-	/*TODO modify it to the ancestor create function */
-    lv_obj_t * new_templ = lv_ANCESTOR_create(par, copy);
-    dm_assert(new_templ);
-    
-    /*Allocate the template type specific extended data*/
-    lv_templ_ext_t * ext = lv_obj_alloc_ext(new_templ, sizeof(lv_templ_ext_t));
-    dm_assert(ext);
-
-    /*Initialize the allocated 'ext' */
-    ext->xyz = 0;
-
-    /*The signal and design functions are not copied so set them here*/
-    lv_obj_set_signal_f(new_templ, lv_templ_signal);
-    lv_obj_set_design_f(new_templ, lv_templ_design);
-
-    /*Init the new template template*/
-    if(copy == NULL) {
-        lv_obj_set_style(new_templ, lv_style_get(LV_STYLE_PRETTY, NULL));
-    }
-    /*Copy an existing template*/
-    else {
-    	lv_templ_ext_t * copy_ext = lv_obj_get_ext(copy);
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_templ);
-    }
-    
-    return new_templ;
-}
-
-/**
- * Signal function of the template
- * @param templ pointer to a template object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_templ_signal(lv_obj_t * templ, lv_signal_t sign, void * param)
-{
-    bool valid;
-
-    /* Include the ancient signal function */
-    /* TODO update it to the ancestor's signal function*/
-    valid = lv_ANCESTOR_signal(templ, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(valid != false) {
-    	if(sign == LV_SIGNAL_CLEANUP) {
-            /*Nothing to cleanup. (No dynamically allocated memory in 'ext')*/
-    	}
-    }
-    
-    return valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/*
- * New object specific "set" function comes here
- */
-
-
-/*=====================
- * Getter functions
- *====================*/
-
-/*
- * New object specific "get" function comes here
- */
-
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-
-/**
- * Handle the drawing related tasks of the templates
- * @param templ pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_templ_design(lv_obj_t * templ, const area_t * mask, lv_design_mode_t mode)
-{
-    /*Return false if the object is not covers the mask_p area*/
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	return false;
-    }
-    /*Draw the object*/
-    else if(mode == LV_DESIGN_DRAW_MAIN) {
-
-    }
-    /*Post draw when the children are drawn*/
-    else if(mode == LV_DESIGN_DRAW_POST) {
-
-    }
-
-    return true;
-}
-
-
-#endif

lv_objx/lv_objx_templ.h

@@ -1,66 +0,0 @@
-/**
- * @file lv_templ.h
- * 
- */
-
-
-/*Search an replace: template -> object normal name with lower case (e.g. button, label etc.)
- * 					 templ -> object short name with lower case(e.g. btn, label etc)
- *                   TEMPL -> object short name with upper case (e.g. BTN, LABEL etc.)
- *
- */
-
-#ifndef LV_TEMPL_H
-#define LV_TEMPL_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_TEMPL != 0
-
-#include "../lv_obj/lv_obj.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-/*Data of template*/
-typedef struct
-{
-    /*Ext. of ancestor*/
-    /*New data for this type */
-}lv_templ_ext_t;
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a template objects
- * @param par pointer to an object, it will be the parent of the new template
- * @param copy pointer to a template object, if not NULL then the new object will be copied from it
- * @return pointer to the created template
- */
-lv_obj_t * lv_templ_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the template
- * @param templ pointer to a template object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- * @return true: the object is still valid (not deleted), false: the object become invalid
- */
-bool lv_templ_signal(lv_obj_t * templ, lv_signal_t sign, void * param);
-
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif

lv_objx/lv_page.c

@@ -1,675 +0,0 @@
-/**
- * @file lv_page.c
- * 
- */
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_PAGE != 0
-
-#include "misc/math/math_base.h"
-#include "../lv_objx/lv_page.h"
-#include "../lv_objx/lv_cont.h"
-#include "../lv_draw/lv_draw.h"
-#include "../lv_obj/lv_refr.h"
-#include "misc/gfx/anim.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/**********************
- *  STATIC PROTOTYPES
- **********************/
-static void lv_page_sb_refresh(lv_obj_t * main);
-static bool lv_page_design(lv_obj_t * page, const area_t * mask, lv_design_mode_t mode);
-static bool lv_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void* param);
-
-/**********************
- *  STATIC VARIABLES
- **********************/
-static lv_design_f_t ancestor_design_f;
-
-/**********************
- *      MACROS
- **********************/
-
-/**********************
- *   GLOBAL FUNCTIONS
- **********************/
-
-/*----------------- 
- * Create function
- *-----------------*/
-
-/**
- * Create a page objects
- * @param par pointer to an object, it will be the parent of the new page
- * @param copy pointer to a page object, if not NULL then the new object will be copied from it
- * @return pointer to the created page
- */
-lv_obj_t * lv_page_create(lv_obj_t * par, lv_obj_t * copy)
-{
-    /*Create the ancestor object*/
-    lv_obj_t * new_page = lv_cont_create(par, copy);
-    dm_assert(new_page);
-
-    /*Allocate the object type specific extended data*/
-    lv_page_ext_t * ext = lv_obj_alloc_ext(new_page, sizeof(lv_page_ext_t));
-    dm_assert(ext);
-    ext->scrl = NULL;
-    ext->pr_action = NULL;
-    ext->rel_action = NULL;
-    ext->sbh_draw = 0;
-    ext->sbv_draw = 0;
-    ext->style_sb = lv_style_get(LV_STYLE_PRETTY, NULL);
-    ext->sb_width = LV_DPI / 8;     /*Will be modified later*/
-    ext->sb_mode = LV_PAGE_SB_MODE_ON;
-
-    if(ancestor_design_f == NULL) ancestor_design_f = lv_obj_get_design_f(new_page);
-
-    /*Init the new page object*/
-    if(copy == NULL) {
-    	lv_style_t * style = lv_style_get(LV_STYLE_PRETTY_COLOR, NULL);
-	    ext->scrl = lv_cont_create(new_page, NULL);
-	    lv_obj_set_signal_f(ext->scrl, lv_scrl_signal);
-		lv_obj_set_drag(ext->scrl, true);
-		lv_obj_set_drag_throw(ext->scrl, true);
-		lv_obj_set_protect(ext->scrl, LV_PROTECT_PARENT);
-		lv_cont_set_fit(ext->scrl, true, true);
-		lv_obj_set_style(ext->scrl, lv_style_get(LV_STYLE_PRETTY, NULL));
-
-		lv_page_set_sb_width(new_page, style->hpad);
-        lv_page_set_sb_mode(new_page, ext->sb_mode);
-        lv_page_set_style_sb(new_page, ext->style_sb);
-
-		/* Add the signal function only if 'scrolling' is created
-		 * because everything has to be ready before any signal is received*/
-	    lv_obj_set_signal_f(new_page, lv_page_signal);
-	    lv_obj_set_design_f(new_page, lv_page_design);
-		lv_obj_set_style(new_page, style);
-    } else {
-    	lv_page_ext_t * copy_ext = lv_obj_get_ext(copy);
-    	ext->scrl = lv_cont_create(new_page, copy_ext->scrl);
-	    lv_obj_set_signal_f(ext->scrl, lv_scrl_signal);
-
-        lv_page_set_pr_action(new_page, copy_ext->pr_action);
-        lv_page_set_rel_action(new_page, copy_ext->rel_action);
-        lv_page_set_sb_mode(new_page, copy_ext->sb_mode);
-        lv_page_set_sb_width(new_page, copy_ext->sb_width);
-        lv_page_set_style_sb(new_page, copy_ext->style_sb);
-
-		/* Add the signal function only if 'scrolling' is created
-		 * because everything has to be ready before any signal is received*/
-	    lv_obj_set_signal_f(new_page, lv_page_signal);
-	    lv_obj_set_design_f(new_page, lv_page_design);
-
-        /*Refresh the style with new signal function*/
-        lv_obj_refr_style(new_page);
-    }
-    
-    lv_page_sb_refresh(new_page);
-                
-    return new_page;
-}
-
-
-/**
- * Signal function of the page
- * @param page pointer to a page object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param)
-{
-    bool obj_valid = true;
-
-    /* Include the ancient signal function */
-    obj_valid = lv_cont_signal(page, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(obj_valid != false) {
-        lv_page_ext_t * ext = lv_obj_get_ext(page);
-        lv_obj_t * child;
-        switch(sign) {
-        	case LV_SIGNAL_CHILD_CHG: /*Move children to the scrollable object*/
-        		child = lv_obj_get_child(page, NULL);
-        		while(child != NULL) {
-        			if(lv_obj_is_protected(child, LV_PROTECT_PARENT) == false) {
-        				lv_obj_t * tmp = child;
-            			child = lv_obj_get_child(page, child); /*Get the next child before move this*/
-        				lv_obj_set_parent(tmp, ext->scrl);
-        			} else {
-            			child = lv_obj_get_child(page, child);
-        			}
-        		}
-        		break;
-                
-            case LV_SIGNAL_STYLE_CHG:
-            	if(ext->sb_mode == LV_PAGE_SB_MODE_ON) {
-            		ext->sbh_draw = 1;
-            		ext->sbv_draw = 1;
-            	} else {
-            		ext->sbh_draw = 0;
-					ext->sbv_draw = 0;
-				}
-
-            	lv_page_sb_refresh(page);
-            	break;
-
-            case LV_SIGNAL_CORD_CHG:
-                /*Refresh the scrollbar and notify the scrl if the size is changed*/
-            	if(ext->scrl != NULL &&
-                   (lv_obj_get_width(page) != area_get_width(param) ||
-                    lv_obj_get_height(page) != area_get_height(param))) {
-            		ext->scrl->signal_f(ext->scrl, LV_SIGNAL_CORD_CHG, &ext->scrl->cords);
-
-            		/*The scrolbars are important olny if they are visible now*/
-            		if(ext->sbh_draw != 0 || ext->sbv_draw != 0)
-            		lv_page_sb_refresh(page);
-
-            	}
-            	break;
-            case LV_SIGNAL_PRESSED:
-                if(ext->pr_action != NULL) {
-                    ext->pr_action(page, param);
-                }
-                break;
-            case LV_SIGNAL_RELEASED:
-                if(lv_dispi_is_dragging(param) == false) {
-                    if(ext->rel_action != NULL) {
-                        ext->rel_action(page, param);
-                    }
-                }
-                break;
-            default:
-                break;
-            
-        }
-    }
-    
-    return obj_valid;
-}
-
-/**
- * Signal function of the scrollable part of a page
- * @param scrl pointer to the scrollable object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-static bool lv_scrl_signal(lv_obj_t * scrl, lv_signal_t sign, void* param)
-{
-    bool obj_valid = true;
-
-    /* Include the ancient signal function */
-    obj_valid = lv_cont_signal(scrl, sign, param);
-
-    /* The object can be deleted so check its validity and then
-     * make the object specific signal handling */
-    if(obj_valid != false) {
-
-        cord_t new_x;
-        cord_t new_y;
-        bool refr_x = false;
-        bool refr_y = false;
-        area_t page_cords;
-        area_t obj_cords;
-        lv_obj_t * page = lv_obj_get_parent(scrl);
-        lv_style_t * page_style = lv_obj_get_style(page);
-        lv_page_ext_t * page_ext = lv_obj_get_ext(page);
-        cord_t hpad = page_style->hpad;
-        cord_t vpad = page_style->vpad;
-
-        switch(sign) {
-            case LV_SIGNAL_CORD_CHG:
-                new_x = lv_obj_get_x(scrl);
-                new_y = lv_obj_get_y(scrl);
-                lv_obj_get_cords(scrl, &obj_cords);
-                lv_obj_get_cords(page, &page_cords);
-
-                /*scrollable width smaller then page width? -> align to left*/
-                if(area_get_width(&obj_cords) + 2 * hpad < area_get_width(&page_cords)) {
-                    if(obj_cords.x1 != page_cords.x1 + hpad) {
-                        new_x = hpad;
-                        refr_x = true;
-                    }
-                } else {
-                	/*The edges of the scrollable can not be in the page (minus hpad) */
-                    if(obj_cords.x2  < page_cords.x2 - hpad) {
-                       new_x =  area_get_width(&page_cords) - area_get_width(&obj_cords) - hpad;   /* Right align */
-                       refr_x = true;
-                    }
-                    if (obj_cords.x1 > page_cords.x1 + hpad) {
-                        new_x = hpad;  /*Left align*/
-                        refr_x = true;
-                    }
-                }
-
-                /*scrollable height smaller then page height? -> align to left*/
-                if(area_get_height(&obj_cords) + 2 * vpad < area_get_height(&page_cords)) {
-                    if(obj_cords.y1 != page_cords.y1 + vpad) {
-                        new_y = vpad;
-                        refr_y = true;
-                    }
-                } else {
-                	/*The edges of the scrollable can not be in the page (minus vpad) */
-                    if(obj_cords.y2 < page_cords.y2 - vpad) {
-                       new_y =  area_get_height(&page_cords) - area_get_height(&obj_cords) - vpad;   /* Bottom align */
-                       refr_y = true;
-                    }
-                    if (obj_cords.y1  > page_cords.y1 + vpad) {
-                        new_y = vpad;  /*Top align*/
-                        refr_y = true;
-                    }
-                }
-                if(refr_x != false || refr_y != false) {
-                    lv_obj_set_pos(scrl, new_x, new_y);
-                }
-
-                lv_page_sb_refresh(page);
-                break;
-
-            case LV_SIGNAL_DRAG_BEGIN:
-            	if(page_ext->sb_mode == LV_PAGE_SB_MODE_DRAG ) {
-            	    cord_t sbh_pad = MATH_MAX(page_ext->sb_width, page_style->hpad);
-            	    cord_t sbv_pad = MATH_MAX(page_ext->sb_width, page_style->vpad);
-					if(area_get_height(&page_ext->sbv) < lv_obj_get_height(scrl) - 2 * sbv_pad) {
-						page_ext->sbv_draw = 1;
-					}
-					if(area_get_width(&page_ext->sbh) < lv_obj_get_width(scrl) - 2 * sbh_pad) {
-						page_ext->sbh_draw = 1;
-					}
-            	}
-                break;
-
-            case LV_SIGNAL_DRAG_END:
-            	if(page_ext->sb_mode == LV_PAGE_SB_MODE_DRAG) {
-				    area_t sb_area_tmp;
-				    if(page_ext->sbh_draw != 0) {
-				        area_cpy(&sb_area_tmp, &page_ext->sbh);
-				        sb_area_tmp.x1 += page->cords.x1;
-				        sb_area_tmp.y1 += page->cords.y1;
-				        sb_area_tmp.x2 += page->cords.x2;
-				        sb_area_tmp.y2 += page->cords.y2;
-				        lv_inv_area(&sb_area_tmp);
-	                    page_ext->sbh_draw = 0;
-				    }
-				    if(page_ext->sbv_draw != 0)  {
-				        area_cpy(&sb_area_tmp, &page_ext->sbv);
-				        sb_area_tmp.x1 += page->cords.x1;
-				        sb_area_tmp.y1 += page->cords.y1;
-				        sb_area_tmp.x2 += page->cords.x2;
-				        sb_area_tmp.y2 += page->cords.y2;
-				        lv_inv_area(&sb_area_tmp);
-	                    page_ext->sbv_draw = 0;
-				    }
-            	}
-                break;
-            case LV_SIGNAL_PRESSED:
-                if(page_ext->pr_action != NULL) {
-                    page_ext->pr_action(page, param);
-                }
-                break;
-            case LV_SIGNAL_RELEASED:
-                if(lv_dispi_is_dragging(param) == false) {
-                    if(page_ext->rel_action != NULL) {
-                        page_ext->rel_action(page, param);
-                    }
-                }
-                break;
-            default:
-                break;
-
-        }
-    }
-
-    return obj_valid;
-}
-
-/*=====================
- * Setter functions
- *====================*/
-
-/**
- * Set a release action for the page
- * @param page pointer to a page object
- * @param rel_action a function to call when the page is released
- */
-void lv_page_set_rel_action(lv_obj_t * page, lv_action_t rel_action)
-{
-	lv_page_ext_t * ext = lv_obj_get_ext(page);
-	ext->rel_action = rel_action;
-}
-
-/**
- * Set a press action for the page
- * @param page pointer to a page object
- * @param pr_action a function to call when the page is pressed
- */
-void lv_page_set_pr_action(lv_obj_t * page, lv_action_t pr_action)
-{
-	lv_page_ext_t * ext = lv_obj_get_ext(page);
-	ext->pr_action = pr_action;
-}
-
-/**
- * Set the scroll bar width on a page
- * @param page pointer to a page object
- * @param sb_width the new scroll bar width in pixels
- */
-void lv_page_set_sb_width(lv_obj_t * page, cord_t sb_width)
-{
-    lv_page_ext_t * ext = lv_obj_get_ext(page);
-    ext->sb_width = sb_width;
-    area_set_height(&ext->sbh, ext->sb_width);
-    area_set_width(&ext->sbv, ext->sb_width);
-    lv_page_sb_refresh(page);
-    lv_obj_inv(page);
-}
-
-/**
- * Set the scroll bar mode on a page
- * @param page pointer to a page object
- * @param sb_mode the new mode from 'lv_page_sb_mode_t' enum
- */
-void lv_page_set_sb_mode(lv_obj_t * page, lv_page_sb_mode_t sb_mode)
-{
-    lv_page_ext_t * ext = lv_obj_get_ext(page);
-    ext->sb_mode = sb_mode;
-    page->signal_f(page, LV_SIGNAL_STYLE_CHG, NULL);
-    lv_obj_inv(page);
-}
-
-/**
- * Set a new style for the scroll bars object on the page
- * @param page pointer to a page object
- * @param style pointer to a style for the scroll bars
- */
-void lv_page_set_style_sb(lv_obj_t * page, lv_style_t * style)
-{
-    lv_page_ext_t * ext = lv_obj_get_ext(page);
-    ext->style_sb = style;
-    lv_obj_inv(page);
-}
-
-/**
- * Glue the object to the page. After it the page can be moved (dragged) with this object too.
- * @param obj pointer to an object on a page
- * @param glue true: enable glue, false: disable glue
- */
-void lv_page_glue_obj(lv_obj_t * obj, bool glue)
-{
-    lv_obj_set_drag_parent(obj, glue);
-    lv_obj_set_drag(obj, glue);
-}
-
-/**
- * Focus on an object. It ensures that the object will be visible on the page.
- * @param page pointer to a page object
- * @param obj pointer to an object to focus (must be on the page)
- * @param anim_time scroll animation time in milliseconds (0: no animation)
- */
-void lv_page_focus(lv_obj_t * page, lv_obj_t * obj, uint16_t anim_time)
-{
-	lv_page_ext_t * ext = lv_obj_get_ext(page);
-	lv_style_t * style = lv_obj_get_style(page);
-	lv_obj_t * scrl = lv_page_get_scrl(page);
-    lv_style_t * style_scrl = lv_obj_get_style(scrl);
-
-	cord_t obj_y = obj->cords.y1 - ext->scrl->cords.y1;
-	cord_t obj_h = lv_obj_get_height(obj);
-	cord_t scrlable_y = lv_obj_get_y(ext->scrl);
-	cord_t page_h = lv_obj_get_height(page);
-
-	cord_t top_err = -(scrlable_y + obj_y);
-	cord_t bot_err = scrlable_y + obj_y + obj_h - page_h;
-
-	/*If obj is higher then the page focus where the "error" is smaller*/
-	/*Out of the page on the top*/
-	if((obj_h <= page_h && top_err > 0) ||
-	   (obj_h > page_h && top_err < bot_err)) {
-		/*Calculate a new position and to let  scrable_rects.vpad space above*/
-		scrlable_y = -(obj_y - style_scrl->vpad - style->vpad);
-		scrlable_y += style_scrl->vpad;
-	}
-	/*Out of the page on the bottom*/
-	else if((obj_h <= page_h && bot_err > 0) ||
-			(obj_h > page_h && top_err >= bot_err)) {
-        /*Calculate a new position and to let  scrable_rects.vpad space below*/
-		scrlable_y = -obj_y;
-		scrlable_y += page_h - obj_h;
-        scrlable_y -= style_scrl->vpad;
-	} else {
-		/*Alraedy in focus*/
-		return;
-	}
-
-    if(anim_time == 0) {
-		lv_obj_set_y(ext->scrl, scrlable_y);
-    }
-    else {
-        anim_t a;
-        a.act_time = 0;
-        a.start = lv_obj_get_y(ext->scrl);
-        a.end = scrlable_y;
-        a.time = anim_time;
-        a.end_cb = NULL;
-        a.playback = 0;
-        a.repeat = 0;
-        a.var = ext->scrl;
-        a.path = anim_get_path(ANIM_PATH_LIN);
-        a.fp = (anim_fp_t) lv_obj_set_y;
-        anim_create(&a);
-    }
-}
-
-/*=====================
- * Getter functions
- *====================*/
-
-/**
- * Get the scrollable object of a page-
- * @param page pointer to page object
- * @return pointer to a container which is the scrollable part of the page
- */
-lv_obj_t * lv_page_get_scrl(lv_obj_t * page)
-{
-	lv_page_ext_t * ext = lv_obj_get_ext(page);
-
-	return ext->scrl;
-}
-/**
- * Get the scroll bar width on a page
- * @param page pointer to a page object
- * @return the scroll bar width in pixels
- */
-cord_t lv_page_get_sb_width(lv_obj_t * page)
-{
-    lv_page_ext_t * ext = lv_obj_get_ext(page);
-    return ext->sb_width;
-}
-
-/**
- * Set the scroll bar mode on a page
- * @param page pointer to a page object
- * @return the mode from 'lv_page_sb_mode_t' enum
- */
-lv_page_sb_mode_t lv_page_get_sb_mode(lv_obj_t * page)
-{
-    lv_page_ext_t * ext = lv_obj_get_ext(page);
-    return ext->sb_mode;
-}
-
-/**
- * Set a new style for the scroll bars object on the page
- * @param page pointer to a page object
- * @return pointer to a style for the scroll bars
- */
-lv_style_t * lv_page_get_style_sb(lv_obj_t * page)
-{
-    lv_page_ext_t * ext = lv_obj_get_ext(page);
-    if(ext->style_sb == NULL) return lv_obj_get_style(page);
-
-    else return ext->style_sb;
-}
-
-/**********************
- *   STATIC FUNCTIONS
- **********************/
-
-/**
- * Handle the drawing related tasks of the pages
- * @param page pointer to an object
- * @param mask the object will be drawn only in this area
- * @param mode LV_DESIGN_COVER_CHK: only check if the object fully covers the 'mask_p' area
- *                                  (return 'true' if yes)
- *             LV_DESIGN_DRAW: draw the object (always return 'true')
- *             LV_DESIGN_DRAW_POST: drawing after every children are drawn
- * @param return true/false, depends on 'mode'
- */
-static bool lv_page_design(lv_obj_t * page, const area_t * mask, lv_design_mode_t mode)
-{
-    if(mode == LV_DESIGN_COVER_CHK) {
-    	return ancestor_design_f(page, mask, mode);
-    } else if(mode == LV_DESIGN_DRAW_MAIN) {
-		ancestor_design_f(page, mask, mode);
-	} else if(mode == LV_DESIGN_DRAW_POST) { /*Draw the scroll bars finally*/
-		ancestor_design_f(page, mask, mode);
-		lv_page_ext_t * ext = lv_obj_get_ext(page);
-
-		/*Draw the scrollbars*/
-		area_t sb_area;
-		if(ext->sbh_draw != 0) {
-		    /*Convert the relative coordinates to absolute*/
-            area_cpy(&sb_area, &ext->sbh);
-		    sb_area.x1 += page->cords.x1;
-            sb_area.y1 += page->cords.y1;
-            sb_area.x2 += page->cords.x1;
-            sb_area.y2 += page->cords.y1;
-			lv_draw_rect(&sb_area, mask, ext->style_sb);
-		}
-
-		if(ext->sbv_draw != 0) {
-            /*Convert the relative coordinates to absolute*/
-            area_cpy(&sb_area, &ext->sbv);
-            sb_area.x1 += page->cords.x1;
-            sb_area.y1 += page->cords.y1;
-            sb_area.x2 += page->cords.x1;
-            sb_area.y2 += page->cords.y1;
-			lv_draw_rect(&sb_area, mask, ext->style_sb);
-		}
-	}
-
-	return true;
-}
-
-/**
- * Refresh the position and size of the scroll bars.
- * @param page pointer to a page object
- */
-static void lv_page_sb_refresh(lv_obj_t * page)
-{
-    /*Always let sb_width padding above,under, left and right to the scrollbars
-     * else:
-     * - horizontal and vertical scrollbars can overlap on the corners
-     * - if the page has radius the scrollbar can be out of the radius  */
-
-    lv_page_ext_t * ext = lv_obj_get_ext(page);
-    lv_style_t * style = lv_obj_get_style(page);
-    lv_obj_t * scrl = ext->scrl;
-    cord_t size_tmp;
-    cord_t scrl_w = lv_obj_get_width(scrl);
-    cord_t scrl_h =  lv_obj_get_height(scrl);
-    cord_t hpad = style->hpad;
-    cord_t vpad = style->vpad;
-    cord_t obj_w = lv_obj_get_width(page);
-    cord_t obj_h = lv_obj_get_height(page);
-    cord_t sbh_pad = MATH_MAX(ext->sb_width, style->hpad);
-    cord_t sbv_pad = MATH_MAX(ext->sb_width, style->vpad);
-
-    if(ext->sb_mode == LV_PAGE_SB_MODE_OFF) return;
-
-    if(ext->sb_mode == LV_PAGE_SB_MODE_ON) {
-        ext->sbh_draw = 1;
-        ext->sbv_draw = 1;
-    }
-
-    /*Invalidate the current (old) scrollbar areas*/
-    area_t sb_area_tmp;
-    if(ext->sbh_draw != 0) {
-        area_cpy(&sb_area_tmp, &ext->sbh);
-        sb_area_tmp.x1 += page->cords.x1;
-        sb_area_tmp.y1 += page->cords.y1;
-        sb_area_tmp.x2 += page->cords.x2;
-        sb_area_tmp.y2 += page->cords.y2;
-        lv_inv_area(&sb_area_tmp);
-    }
-    if(ext->sbv_draw != 0)  {
-        area_cpy(&sb_area_tmp, &ext->sbv);
-        sb_area_tmp.x1 += page->cords.x1;
-        sb_area_tmp.y1 += page->cords.y1;
-        sb_area_tmp.x2 += page->cords.x2;
-        sb_area_tmp.y2 += page->cords.y2;
-        lv_inv_area(&sb_area_tmp);
-    }
-
-    /*Horizontal scrollbar*/
-    if(scrl_w <= obj_w - 2 * hpad) {        /*Full sized scroll bar*/
-        area_set_width(&ext->sbh, obj_w - 2 * sbh_pad);
-        area_set_pos(&ext->sbh, sbh_pad, obj_h - ext->sb_width);
-        if(ext->sb_mode == LV_PAGE_SB_MODE_AUTO)  ext->sbh_draw = 0;
-    } else {
-        size_tmp = (obj_w * (obj_w - (2 * sbh_pad))) / (scrl_w + 2 * hpad);
-        area_set_width(&ext->sbh,  size_tmp);
-
-        area_set_pos(&ext->sbh, sbh_pad +
-                   (-(lv_obj_get_x(scrl) - hpad) * (obj_w - size_tmp -  2 * sbh_pad)) /
-                   (scrl_w + 2 * hpad - obj_w ), obj_h - ext->sb_width);
-
-        if(ext->sb_mode == LV_PAGE_SB_MODE_AUTO)  ext->sbh_draw = 1;
-    }
-    
-    /*Vertical scrollbar*/
-    if(scrl_h <= obj_h - 2 * vpad) {        /*Full sized scroll bar*/
-        area_set_height(&ext->sbv,  obj_h - 2 * sbv_pad);
-        area_set_pos(&ext->sbv, obj_w - ext->sb_width, sbv_pad);
-        if(ext->sb_mode == LV_PAGE_SB_MODE_AUTO)  ext->sbv_draw = 0;
-    } else {
-        size_tmp = (obj_h * (obj_h - (2 * sbv_pad))) / (scrl_h + 2 * vpad);
-        area_set_height(&ext->sbv,  size_tmp);
-
-        area_set_pos(&ext->sbv,  obj_w - ext->sb_width,
-        		    sbv_pad +
-                   (-(lv_obj_get_y(scrl) - vpad) * (obj_h - size_tmp -  2 * sbv_pad)) /
-                                      (scrl_h + 2 * vpad - obj_h ));
-
-        if(ext->sb_mode == LV_PAGE_SB_MODE_AUTO)  ext->sbv_draw = 1;
-    }
-
-    /*Invalidate the new scrollbar areas*/
-    if(ext->sbh_draw != 0) {
-        area_cpy(&sb_area_tmp, &ext->sbh);
-        sb_area_tmp.x1 += page->cords.x1;
-        sb_area_tmp.y1 += page->cords.y1;
-        sb_area_tmp.x2 += page->cords.x2;
-        sb_area_tmp.y2 += page->cords.y2;
-        lv_inv_area(&sb_area_tmp);
-    }
-    if(ext->sbv_draw != 0)  {
-        area_cpy(&sb_area_tmp, &ext->sbv);
-        sb_area_tmp.x1 += page->cords.x1;
-        sb_area_tmp.y1 += page->cords.y1;
-        sb_area_tmp.x2 += page->cords.x2;
-        sb_area_tmp.y2 += page->cords.y2;
-        lv_inv_area(&sb_area_tmp);
-    }
-}
-
-#endif

lv_objx/lv_page.h

@@ -1,163 +0,0 @@
-/**
- * @file lv_page.h
- * 
- */
-
-#ifndef LV_PAGE_H
-#define LV_PAGE_H
-
-/*********************
- *      INCLUDES
- *********************/
-#include "lv_conf.h"
-#if USE_LV_PAGE != 0
-
-/*Testing of dependencies*/
-#if USE_LV_CONT == 0
-#error "lv_page: lv_cont is required. Enable it in lv_conf.h (USE_LV_CONT  1) "
-#endif
-
-#include "../lv_obj/lv_obj.h"
-#include "lvgl/lv_objx/lv_cont.h"
-#include "../lv_obj/lv_dispi.h"
-
-/*********************
- *      DEFINES
- *********************/
-
-/**********************
- *      TYPEDEFS
- **********************/
-
-/*Scrollbar modes: shows when should the scrollbars be visible*/
-typedef enum
-{
-    LV_PAGE_SB_MODE_OFF,    /*Never show scrollbars*/
-    LV_PAGE_SB_MODE_ON,     /*Always show scrollbars*/
-    LV_PAGE_SB_MODE_DRAG,   /*Show scrollbars when page is being dragged*/
-    LV_PAGE_SB_MODE_AUTO,   /*Show scrollbars when the scrollable container is large enough to be scrolled*/
-}lv_page_sb_mode_t;
-
-/*Data of page*/
-typedef struct
-{
-    lv_cont_ext_t bg; /*Ext. of ancestor*/
-    /*New data for this type */
-    lv_obj_t * scrl;            /*The scrollable object on the background*/
-    lv_action_t rel_action;     /*Function to call when the page is released*/
-    lv_action_t pr_action;      /*Function to call when the page is pressed*/
-    lv_style_t * style_sb;      /*Style of scrollbars*/
-    cord_t sb_width;            /*Width of the scrollbars*/
-    lv_page_sb_mode_t sb_mode;  /*Scrollbar visibility from 'lv_page_sb_mode_t'*/
-    area_t sbh;                 /*Horizontal scrollbar area relative to the page. (Handled by the library) */
-    area_t sbv;                 /*Vertical scrollbar area relative to the page (Handled by the library)*/
-    uint8_t sbh_draw :1;        /*1: horizontal scrollbar is visible now (Handled by the library)*/
-    uint8_t sbv_draw :1;        /*1: vertical scrollbar is visible now (Handled by the library)*/
-}lv_page_ext_t;
-
-
-/**********************
- * GLOBAL PROTOTYPES
- **********************/
-
-/**
- * Create a page objects
- * @param par pointer to an object, it will be the parent of the new page
- * @param copy pointer to a page object, if not NULL then the new object will be copied from it
- * @return pointer to the created page
- */
-lv_obj_t * lv_page_create(lv_obj_t * par, lv_obj_t * copy);
-
-/**
- * Signal function of the page
- * @param page pointer to a page object
- * @param sign a signal type from lv_signal_t enum
- * @param param pointer to a signal specific variable
- */
-bool lv_page_signal(lv_obj_t * page, lv_signal_t sign, void * param);
-
-/**
- * Set a release action for the page
- * @param page pointer to a page object
- * @param rel_action a function to call when the page is released
- */
-void lv_page_set_rel_action(lv_obj_t * page, lv_action_t rel_action);
-
-/**
- * Set a press action for the page
- * @param page pointer to a page object
- * @param pr_action a function to call when the page is pressed
- */
-void lv_page_set_pr_action(lv_obj_t * page, lv_action_t pr_action);
-
-/**
- * Set the scroll bar width on a page
- * @param page pointer to a page object
- * @param sb_width the new scroll bar width in pixels
- */
-void lv_page_set_sb_width(lv_obj_t * page, cord_t sb_width);
-
-/**
- * Set the scroll bar mode on a page
- * @param page pointer to a page object
- * @param sb_mode the new mode from 'lv_page_sb_mode_t' enum
- */
-void lv_page_set_sb_mode(lv_obj_t * page, lv_page_sb_mode_t sb_mode);
-
-/**
- * Set a new style for the scroll bars object on the page
- * @param page pointer to a page object
- * @param style pointer to a style for the scroll bars
- */
-void lv_page_set_style_sb(lv_obj_t * page, lv_style_t * style);
-
-/**
- * Glue the object to the page. After it the page can be moved (dragged) with this object too.
- * @param obj pointer to an object on a page
- * @param glue true: enable glue, false: disable glue
- */
-void lv_page_glue_obj(lv_obj_t * obj, bool glue);
-
-/**
- * Focus on an object. It ensures that the object will be visible on the page.
- * @param page pointer to a page object
- * @param obj pointer to an object to focus (must be on the page)
- * @param anim_time scroll animation time in milliseconds (0: no animation)
- */
-void lv_page_focus(lv_obj_t * page, lv_obj_t * obj, uint16_t anim_time);
-
-/**
- * Get the scrollable object of a page-
- * @param page pointer to page object
- * @return pointer to a container which is the scrollable part of the page
- */
-lv_obj_t * lv_page_get_scrl(lv_obj_t * page);
-
-/**
- * Get the scroll bar width on a page
- * @param page pointer to a page object
- * @return the scroll bar width in pixels
- */
-cord_t lv_page_get_sb_width(lv_obj_t * page);
-
-/**
- * Set the scroll bar mode on a page
- * @param page pointer to a page object
- * @return the mode from 'lv_page_sb_mode_t' enum
- */
-lv_page_sb_mode_t lv_page_get_sb_mode(lv_obj_t * page);
-
-/**
- * Set a new style for the scroll bars object on the page
- * @param page pointer to a page object
- * @return pointer to a style for the scroll bars
- */
-lv_style_t * lv_page_get_style_sb(lv_obj_t * page);
-
-/**********************
- *      MACROS
- **********************/
-
-#endif
-
-#endif