Spelling and other language fixes to documentation (#2293)

docs/porting/display.md

@@ -4,14 +4,14 @@
 ```
 # Display interface
 
-To register a display for LVGL an `lv_disp_draw_buf_t` and an `lv_disp_drv_t` variables have to be initialized.
-- `lv_disp_draw_buf_t` contains internal graphic buffer(s), called draw buffer(s).
+To register a display for LVGL a `lv_disp_draw_buf_t` and a `lv_disp_drv_t` variable have to be initialized.
+- `lv_disp_draw_buf_t` contains internal graphic buffer(s) called draw buffer(s).
 - `lv_disp_drv_t` contains callback functions to interact with the display and manipulate drawing related things.
 
 ## Draw buffer
 
 Draw buffer(s) are simple array(s) that LVGL uses to render the content of the screen. 
-Once rendering is ready the content of the draw buffer is send to display using the `flush_cb` set in the display driver (see below).
+Once rendering is ready the content of the draw buffer is sent to the display using the `flush_cb` function set in the display driver (see below).
 
 A draw draw buffer can be initialized via a `lv_disp_draw_buf_t` variable like this:
 ```c
@@ -28,8 +28,8 @@ lv_disp_draw_buf_init(&disp_buf, buf_1, buf_2, MY_DISP_HOR_RES*10);
 
 Note that `lv_disp_draw_buf_t` needs to be static, global or dynamically allocated and not a local variable destroyed if goes out of the scope. 
 
-As you can see the draw buffer can be smaller than the screen. In this case, the larger areas will be redrawn in smaller parts that fit into the draw buffer(s). 
-If only a small area changes (e.g. a button is  pressed) then only that area will be refreshed.
+As you can see the draw buffer can be smaller than the screen. In this case, the larger areas will be redrawn in smaller parts that fit into the draw buffer(s).
+If only a small area changes (e.g. a button is pressed) then only that area will be refreshed.
 
 A larger buffer results in better performance but above 1/10 screen sized buffer(s) there is no significant performance improvement. 
 Therefore it's recommended to choose the size of the draw buffer(s) to at least 1/10 screen sized.
@@ -41,31 +41,31 @@ If **two buffers**  are used LVGL can draw into one buffer while the content of
 DMA or other hardware should be used to transfer the data to the display to let the MCU draw meanwhile.
 This way, the rendering and refreshing of the display become parallel. 
 
-In the display driver (`lv_disp_drv_t`) the `full_refresh` bit can be enabled to force LVGL always redraw the whole screen. It works in both *one buffer* and *two buffers* modes.
+In the display driver (`lv_disp_drv_t`) the `full_refresh` bit can be enabled to force LVGL to always redraw the whole screen. This works in both *one buffer* and *two buffers* modes.
 
-If `full_refresh` is enabled and 2 screen sized draw buffers are provided, LVGL work as "traditional" double buffering. 
-It means in `flush_cb` only the address of the frame buffer needs to be changed to provided pointer (`color_p` parameter).
+If `full_refresh` is enabled and 2 screen sized draw buffers are provided, LVGL's display handling works like "traditional" double buffering. 
+This means in `flush_cb` only the address of the frame buffer needs to be changed to the provided pointer (`color_p` parameter).
 This configuration should be used if the MCU has LCD controller periphery and not with an external display controller (e.g. ILI9341 or SSD1963). 
 
 You can measure the performance of different draw buffer configurations using the [benchmark example](https://github.com/lvgl/lv_demos/tree/master/src/lv_demo_benchmark).
 
 ## Display driver
 
-Once the buffer initialization is ready a `lv_disp_drv_t` display drivers need to be
+Once the buffer initialization is ready a `lv_disp_drv_t` display driver needs to be
 1. initialized with `lv_disp_drv_init(&disp_drv)`
-2. its fields needs to be set
-3. registered in LVGL with `lv_disp_drv_register(&disp_drv)`
+2. its fields need to be set
+3. it needs to be registered in LVGL with `lv_disp_drv_register(&disp_drv)`
 
 Note that `lv_disp_drv_t` also needs to be static, global or dynamically allocated and not a local variable destroyed if goes out of the scope. 
 
 ### Mandatory fields
-In the most simple case only the following fields of `lv_disp_drv_t` needs to be set:
+In the most simple case only the following fields of `lv_disp_drv_t` need to be set:
 - `draw_buf` pointer to an initialized `lv_disp_draw_buf_t` variable.
 - `hor_res` horizontal resolution of the display in pixels. 
 - `ver_res` vertical resolution of the display in pixels.
 - `flush_cb` a callback function to copy a buffer's content to a specific area of the display. 
 `lv_disp_flush_ready(&disp_drv)` needs to be called when flushing is ready. 
-LVGL might render the screen in multiple chunks and therefore call `flush_cb` multiple times. To see which is the last chunk of rendering use `lv_disp_flush_is_last(&disp_drv)`.
+LVGL might render the screen in multiple chunks and therefore call `flush_cb` multiple times. To see if the current one is the last chunk of rendering use `lv_disp_flush_is_last(&disp_drv)`.
 
 ### Optional fields 
 There are some optional data fields:
@@ -85,7 +85,7 @@ This way the buffers used in `lv_disp_draw_buf_t` can be smaller to hold only th
 
 LVGL has built-in support to several GPUs (see `lv_conf.h`) but if something else is required these functions can be used to make LVGL use a GPU:
 - `gpu_fill_cb` fill an area in the memory with a color.
-- `gpu_wait_cb` if any GPU function return, while the GPU is still working, LVGL will use this function when required the be sure GPU rendering is ready.
+- `gpu_wait_cb` if any GPU function returns while the GPU is still working, LVGL will use this function when required to make sure GPU rendering is ready.
 
 ### Examples
 All together it looks like this:

docs/porting/indev.md

@@ -28,7 +28,7 @@ lv_indev_t * my_indev = lv_indev_drv_register(&indev_drv);
 Visit [Input devices](/overview/indev) to learn more about input devices in general.
 
 ###  Touchpad, mouse or any pointer
-Input devices that can click points of the screen belong to this category.
+Input devices that can click points on the screen belong to this category.
 
 ```c
 indev_drv.type = LV_INDEV_TYPE_POINTER;
@@ -56,7 +56,7 @@ Full keyboards with all the letters or simple keypads with a few navigation butt
 
 To use a keyboard/keypad:
 - Register a `read_cb` function with `LV_INDEV_TYPE_KEYPAD` type.
-- An object group has to be created: `lv_group_t * g = lv_group_create()`  and objects have to be added to it with `lv_group_add_obj(g, obj)`
+- An object group has to be created: `lv_group_t * g = lv_group_create()` and objects have to be added to it with `lv_group_add_obj(g, obj)`
 - The created group has to be assigned to an input device: `lv_indev_set_group(my_indev, g)` (`my_indev` is the return value of `lv_indev_drv_register`)
 - Use `LV_KEY_...` to navigate among the objects in the group. See `lv_core/lv_group.h` for the available keys.
 
@@ -176,23 +176,23 @@ The default value of the following parameters can changed in `lv_indev_drv_t`:
 - `scroll_throw`  Scroll throw (momentum) slow-down in [%]. Greater value means faster slow-down.
 - `long_press_time` Press time to send `LV_EVENT_LONG_PRESSED` (in milliseconds)
 - `long_press_rep_time` Interval of sending `LV_EVENT_LONG_PRESSED_REPEAT` (in milliseconds)
-- `read_timer` pointer to the `lv_rimer` which reads the input device. Its parameters can be changed by `lv_timer_...()` functions. `LV_INDEV_DEF_READ_PERIOD` in `lv_conf.h` sets the default read period.
+- `read_timer` pointer to the `lv_timer` which reads the input device. Its parameters can be changed by `lv_timer_...()` functions. `LV_INDEV_DEF_READ_PERIOD` in `lv_conf.h` sets the default read period.
 
 ### Feedback
 
 Besides `read_cb` a `feedback_cb` callback can be also specified in `lv_indev_drv_t`.
-`feedback_cb` is called when any type of event is sent by the input devices. (independently from its type). It allows making feedback for the user e.g. to play a sound on `LV_EVENT_CLICKED`.
+`feedback_cb` is called when any type of event is sent by the input devices (independently from its type). This allows generating feedback for the user, e.g. to play a sound on `LV_EVENT_CLICKED`.
 
 
 ### Associating with a display
-Every Input device is associated with a display. By default, a new input device is added to the lastly created or the explicitly selected (using `lv_disp_set_default()`) display.
+Every input device is associated with a display. By default, a new input device is added to the lastly created or the explicitly selected (using `lv_disp_set_default()`) display.
 The associated display is stored and can be changed in `disp` field of the driver.
 
 ### Buffered reading
 By default LVGL calls `read_cb` periodically. This way there is a chance that some user gestures are missed. 
 
 To solve this you can write an event driven driver for your input device that buffers measured data. In `read_cb` you can set the buffered data instead of reading the input device. 
-You can set the `data->continue_reding` flag to tell that LVGL there is more data to read and it should call the `read_cb` again.
+You can set the `data->continue_reading` flag to tell that LVGL there is more data to read and it should call the `read_cb` again.
 
 ## Further reading
 

docs/porting/log.md

@@ -11,7 +11,7 @@ To enable logging, set `LV_USE_LOG  1` in `lv_conf.h` and set `LV_LOG_LEVEL` to
 - `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_ERROR` Only critical issues, where the system may fail
 - `LV_LOG_LEVEL_USER` Only user messages
 - `LV_LOG_LEVEL_NONE`  Do not log anything
 

docs/porting/os.md

@@ -13,9 +13,9 @@ However, in the following conditions it's valid to call LVGL related functions:
 
 ## Tasks and threads
 If you need to use real tasks or threads, you need a mutex which should be invoked before the call of `lv_timer_handler` and released after it.
-Also, you have to use the same mutex in other tasks and threads around every LVGL (`lv_...`) related function calls and codes.
+Also, you have to use the same mutex in other tasks and threads around every LVGL (`lv_...`) related function call and code.
 This way you can use LVGL in a real multitasking environment. Just make use of a mutex to avoid the concurrent calling of LVGL functions.
 
 ## Interrupts
-Try to avoid calling LVGL functions from the interrupts (except `lv_tick_inc()` and `lv_disp_flush_ready()`). But, if you need to do this you have to disable the interrupt which uses LVGL functions while `lv_timer_handler` is running.
+Try to avoid calling LVGL functions from interrupt handlers (except `lv_tick_inc()` and `lv_disp_flush_ready()`). But if you need to do this you have to disable the interrupt which uses LVGL functions while `lv_timer_handler` is running.
 It's a better approach to set a flag or some value and periodically check it in an `lv_timer`.

docs/porting/project.md

@@ -7,22 +7,22 @@
 
 ## Get the library
 
-LVGL Graphics Library is available on GitHub: [https://github.com/lvgl/lvgl](https://github.com/lvgl/lvgl).
+LVGL is available on GitHub: [https://github.com/lvgl/lvgl](https://github.com/lvgl/lvgl).
 
 You can clone it or download the latest version of the library from GitHub.
 
-The graphics library is the **lvgl** directory which should be copied into your project.
+The graphics library itself is the **lvgl** directory which should be copied into your project.
 
 ## Configuration file
 
-There is a configuration header file for LVGL called **lv_conf.h**. In this you can set the library's basic behaviour, disable unused modules and features, adjusts the size of memory buffers in compile-time, etc.
+There is a configuration header file for LVGL called **lv_conf.h**. In this you can set the library's basic behavior, disable unused modules and features, adjust the size of memory buffers in compile-time, etc.
 
 Copy **lvgl/lv_conf_template.h** next to the *lvgl* directory and rename it to *lv_conf.h*. Open the file and change the `#if 0` at the beginning to `#if 1` to enable its content.
 
-*lv_conf.h* can be copied other places as well but then you should add `LV_CONF_INCLUDE_SIMPLE` define to your compiler options (e.g. `-DLV_CONF_INCLUDE_SIMPLE` for gcc compiler) and set the include path manually. 
+*lv_conf.h* can be copied to another place as well but then you should add `LV_CONF_INCLUDE_SIMPLE` define to your compiler options (e.g. `-DLV_CONF_INCLUDE_SIMPLE` for gcc compiler) and set the include path manually. 
 In this case LVGL will attempt to include `lv_conf.h` simply with `#include "lv_conf.h"`.
 
-In the config file comments explain the meaning of the options. Be sure to set at least `LV_COLOR_DEPTH` according to your display's colro depth.
+In the config file comments explain the meaning of the options. Be sure to set at least `LV_COLOR_DEPTH` according to your display's color depth.
 
 ## Initialization
 
@@ -31,5 +31,5 @@ To use the graphics library you have to initialize it and the other components t
 1. Call `lv_init()`.
 2. Initialize your drivers.
 3. Register the display and input devices drivers in LVGL.  Lear more about [Display](/porting/display) and [Input device](/porting/indev) registration.
-4. Call `lv_tick_inc(x)` in every `x` milliseconds in an interrupt to tell the elapsed time. [Learn more](/porting/tick).
-5. Call `lv_timer_handler()` periodically in every few milliseconds to handle LVGL related tasks. [Learn more](/porting/task-handler).
+4. Call `lv_tick_inc(x)` every `x` milliseconds in an interrupt to tell the elapsed time. [Learn more](/porting/tick).
+5. Call `lv_timer_handler()` every few milliseconds to handle LVGL related tasks. [Learn more](/porting/task-handler).

docs/porting/sleep.md

@@ -21,11 +21,11 @@ while(1) {
 }
 ```
 
-You should also add below lines to your input device read function if a wake-up (press, touch or click etc.) happens:
+You should also add the below lines to your input device read function to signal a wake-up (press, touch or click etc.) happened:
 ```c
 lv_tick_inc(LV_DISP_DEF_REFR_PERIOD);  /*Force task execution on wake-up*/
 timer_start();                         /*Restart the timer where lv_tick_inc() is called*/
 lv_task_handler();                     /*Call `lv_task_handler()` manually to process the wake-up event*/
 ```
 
-In addition to `lv_disp_get_inactive_time()` you can check `lv_anim_count_running()` to see if every animations are finished.
+In addition to `lv_disp_get_inactive_time()` you can check `lv_anim_count_running()` to see if all animations have finished.

docs/porting/task-handler.md

@@ -4,9 +4,9 @@
 ```
 # Task Handler
 
-To handle the tasks of LVGL you need to call `lv_timer_handler()` periodically in one of the followings:
+To handle the tasks of LVGL you need to call `lv_timer_handler()` periodically in one of the following:
 - *while(1)* of *main()* function 
-- timer interrupt periodically (low priority then `lv_tick_inc()`)
+- timer interrupt periodically (lower priority than `lv_tick_inc()`)
 - an OS task periodically
 
 The timing is not critical but it should be about 5 milliseconds to keep the system responsive.

docs/porting/tick.md

@@ -4,15 +4,15 @@
 ```
 # Tick interface
 
-The LVGL needs a system tick to know the elapsed time for animation and other tasks.
+LVGL needs a system tick to know elapsed time for animations and other tasks.
 
-You need to call the `lv_tick_inc(tick_period)` function periodically and tell the call period in milliseconds. For example, `lv_tick_inc(1)` for calling in every millisecond.
+You need to call the `lv_tick_inc(tick_period)` function periodically and provide the call period in milliseconds. For example, `lv_tick_inc(1)` when calling every millisecond.
 
-`lv_tick_inc` should be called in a higher priority routine than `lv_task_handler()` (e.g. in an interrupt) to precisely know the elapsed milliseconds even if the execution of `lv_task_handler` takes longer time.
+`lv_tick_inc` should be called in a higher priority routine than `lv_task_handler()` (e.g. in an interrupt) to precisely know the elapsed milliseconds even if the execution of `lv_task_handler` takes more time.
 
 With FreeRTOS `lv_tick_inc` can be called in `vApplicationTickHook`.
 
-On Linux based operating system (e.g. on Raspberry Pi) `lv_tick_inc` can be called in a thread as below:
+On Linux based operating system (e.g. on Raspberry Pi) `lv_tick_inc` can be called in a thread like below:
 ```c
 void * tick_thread (void *args)
 {