Symbols ![]()
loading...
Files ![]()
loading...
i80_controller sample sample
i80_controller sample is a sample project defining the following symbols:Most used functions
Name
Location
Summary
GLOBAL PROTOTYPES Add a style to an object. Examples:
lv_obj_add_style(btn, &style_btn, 0); //Default button style
lv_obj_add_style(btn, &btn_red, LV_STATE_PRESSED); //Overwrite only some colors to red when pressed
Get the value of a style property. The current state of the object will be considered. Inherited properties will be inherited. If a property is not set a default value will be returned.
Set the value of property in a style. This function shouldn't be used directly by the user. Instead use `lv_style_set_()`. E.g. `lv_style_set_bg_color()`
Set local style property on an object's part and state.
Set a new text for a label. Memory will be allocated to store the text by the label.
Event callback. Events are used to notify the user of some action being taken on the object. For details, see ::lv_event_t.
Add an event handler function for an object. Used by the user to react on event which happens with the object. An object can have multiple event handler. They will be called in the same order as they were added.
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
DEFINES TYPEDEFS GLOBAL PROTOTYPES Copies a block of memory from a source address to a destination address.
Get the object originally targeted by the event. It's the same even if the event is bubbled.
Change the alignment of an object and set new coordinates. Equivalent to: lv_obj_set_align(obj, align); lv_obj_set_pos(obj, x_ofs, y_ofs);
The rectangle is a wrapper for fill, border, bg. image and box shadow. Internally fill, border, image and box shadow draw tasks will be created.
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Get the current target of the event. It's the object which event handler being called. If the event is not bubbled it's the same as "normal" target.
Get the width reduced by the left and right padding and the border width.
Get the height reduced by the top and bottom padding and the border width.
GLOBAL PROTOTYPES Initialize an animation variable. E.g.: lv_anim_t a; lv_anim_init(&a); lv_anim_set_...(&a); lv_anim_start(&a);
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Mark an area of an object as invalid. The area will be truncated to the object's area and marked for redraw.
Convert a percentage value to `int32_t`. Percentage values are stored in special range
Used by the widgets internally to call the ancestor widget types's event handler
Sets the width or height (on main axis) to grow the object in order fill the free space
Get the line height of a font. All characters fit into this height
Return the width of the area on the left the object. That is the number of pixels the object can be scrolled down. Normally positive but can be negative when scrolled inside.
Get the user_data passed when the event was registered on the object
Add one or more states to the object. The other state bits will remain unchanged. If specified in the styles, transition animation will be started from the previous state to the current.
TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
STATIC VARIABLES GLOBAL VARIABLES MACROS GLOBAL FUNCTIONS
Set a new formatted text for a label. Memory will be allocated to store the text by the label. Example:
lv_label_set_text_fmt(label1, "%d user", user_num);
Computes the length of the string str up to, but not including the terminating null character.
Return the height of the area above the object. That is the number of pixels the object can be scrolled down. Normally positive but can be negative when scrolled inside.
Get the currently processed input device. Can be used in action functions too.
Remove the node 'node_p' from 'll_p' linked list. It does not free the memory of node.
Get the draw context which should be the first parameter of the draw functions. Namely: `LV_EVENT_DRAW_MAIN/POST`, `LV_EVENT_DRAW_MAIN/POST_BEGIN`, `LV_EVENT_DRAW_MAIN/POST_END`
Initialize a label draw descriptor from an object's styles in its current state
Send a 'LV_EVENT_REFR_EXT_DRAW_SIZE' Call the ancestor's event handler to the object to refresh the value of the extended draw size. The result will be saved in `obj`.
moves the object to the given index in its parent. When used in listboxes, it can be used to sort the listbox items.
Initialize a line draw descriptor from an object's styles in its current state
Handle if the size of the internal ("virtual") content of an object has changed.
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Remove one or more states to the object. The other state bits will remain unchanged. If specified in the styles, transition animation will be started from the previous state to the current.
Get the last point of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
@cond Doxygen_Suppress Apply the added buffers on a line. Used internally by the library's drawing routines.
Set the cell of an object. The object's parent needs to have grid layout, else nothing will happen
Get the area reduced by the paddings and the border width.
Return the width of the area on the right the object. That is the number of pixels the object can be scrolled down. Normally positive but can be negative when scrolled inside.
Set the value of an integer subject. It will notify all the observers as well.
Notify an object and its children about its style is modified.
Set the behavior of the label with text longer than the object size
Remove and free all elements from a linked list. The list remain valid but become empty.
Scroll to a given Y coordinate on an object `y` will be limited internally to allow scrolling only on the content area.
Test whether the and object is positioned by a layout or not
@endcond Free the data from the parameter. It's called inside `lv_draw_sw_mask_remove_id` and `lv_draw_sw_mask_remove_custom` Needs to be called only in special cases when the mask is not added by `lv_draw_mask_add` and not removed by `lv_draw_mask_remove_id` or `lv_draw_mask_remove_custom`
Make the animation to play back to when the forward direction is ready
Insert a character to the current cursor position. To add a wide char, e.g. 'Á' use `lv_text_encoded_conv_wc('Á')`
Get the luminance of a color32: luminance = 0.3 R + 0.59 G + 0.11 B
Return the height of the area below the object. That is the number of pixels the object can be scrolled down. Normally positive but can be negative when scrolled inside.
Calculate the current value of an animation applying linear characteristic
Checks if the reset_query flag has been set. If so, perform necessary global indev cleanup actions
Scroll to a given X coordinate on an object. `x` will be limited internally to allow scrolling only on the content area.
Needs to be called when a draw task is created and configured. It will send an event about the new draw task to the widget and assign it to a draw unit.
Get the luminance of a color: luminance = 0.3 R + 0.59 G + 0.11 B
Get the luminance of a color16: luminance = 0.3 R + 0.59 G + 0.11 B
Get the luminance of a color24: luminance = 0.3 R + 0.59 G + 0.11 B
Destroy a draw buf by freeing the actual buffer if it's marked as LV_IMAGE_FLAGS_ALLOCATED in header. Then free the lv_draw_buf_t struct.
Set a new map. Buttons will be created/deleted according to the map. The button matrix keeps a reference to the map and so the string array must not be deallocated during the life of the matrix.
Move the parent of an object. The relative coordinates will be kept.
Get the currently scrolled object (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
Get where to snap the children when scrolling ends horizontally
Get where to snap the children when scrolling ends vertically
Calculate the stride in bytes based on a width and color format
Get the area of a rectangle if its rotated and scaled
Initialize a transition descriptor. Example:
const static lv_style_prop_t trans_props[] = { LV_STYLE_BG_OPA, LV_STYLE_BG_COLOR, 0 };
static lv_style_transition_dsc_t trans1;
lv_style_transition_dsc_init(&trans1, trans_props, NULL, 300, 0, NULL);
Remove a style from an object. Examples:
lv_obj_remove_style(obj, &style, LV_PART_ANY | LV_STATE_ANY); //Remove a specific style
lv_obj_remove_style(obj, NULL, LV_PART_MAIN | LV_STATE_ANY); //Remove all styles from the main part
lv_obj_remove_style(obj, NULL, LV_PART_ANY | LV_STATE_ANY); //Remove all styles
Set the next point's Y value according to the update mode policy.
Get the required extra size (around the object's part) to draw shadow, outline, value etc.
Remove a local style property from a part of an object with a given state.
Initialize a draw buf with the given buffer and parameters. Clear draw buffer flag to zero.
Set the attributes of a button of the button matrix
Transform a point using the angle and zoom style properties of an object
Register a new style property for custom usage Example:
lv_style_prop_t MY_PROP;
static inline void lv_style_set_my_prop(lv_style_t * style, lv_color_t value) {
lv_style_value_t v = {.color = value}; lv_style_set_prop(style, MY_PROP, v); }
...
MY_PROP = lv_style_register_prop();
...
lv_style_set_my_prop(&style1, lv_palette_main(LV_PALETTE_RED));
Get the draw task which was just added. Can be used in `LV_EVENT_DRAW_TASK_ADDED event`
Get the index of the lastly "activated" button by the user (pressed, released, focused etc) Useful in the `event_cb` to get the text of the button, check if hidden etc.
Add an observer to a subject for an object. When the object is deleted, it will be removed from the subject automatically.
Assign a Text Area to the Keyboard. The pressed characters will be put there.
Scroll to an object until it becomes visible on its parent
Calculate the current value of an animation slowing down the end phase
Get the text of a text area. In password mode it gives the real text (not '*'s).
Duplicate a string by allocating a new one and copying the content.
Set scale total tick count (including minor and major ticks)
Set the new extra draw size. Can be used in `LV_EVENT_REFR_EXT_DRAW_SIZE`
Scroll by a given amount of pixels. `dx` and `dy` will be limited internally to allow scrolling only on the content area.
Get the key passed as parameter to an event. Can be used in `LV_EVENT_KEY`
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Copies the string pointed to by src, including the terminating null character, to the character array pointed to by dst.
DEFINES TYPEDEFS GLOBAL PROTOTYPES Get the extended draw area of an object.
DEFINES TYPEDEFS GLOBAL PROTOTYPES Get the next line of text. Check line length and break chars too.
Enable or disable automatic style refreshing when a new style is added/removed to/from an object or any other style change happens.
Transform an area using the angle and zoom style properties of an object
Set the options in a drop-down list from a string. The options will be copied and saved in the object so the `options` can be destroyed after calling this function
Select next higher digit for edition by multiplying the step by 10
Get the child of an object by the child's index. Consider the children only with a given type.
Note: Eventually, lv_draw_buf_malloc/free will be kept as private. For now, we use `create` to distinguish with malloc. Create an draw buf by allocating struct for `lv_draw_buf_t` and allocating a buffer for it that meets specified requirements.
Get the `opa` style property from all parents and multiply and `>> 8` them.
Get the cache entry of a data. The data should be allocated by the cache instance.
Similar to `lv_anim_set_exec_cb` but `lv_anim_custom_exec_cb_t` receives `lv_anim_t * ` as its first parameter instead of `void *`. This function might be used when LVGL is bound to other languages because it's more consistent to have `lv_anim_t *` as first parameter.
Set a draw buffer for the canvas. A draw buffer either can be allocated by `lv_draw_buf_create()` or defined statically by `LV_DRAW_BUF_DEFINE_STATIC`. When buffer start address and stride has alignment requirement, it's recommended to use `lv_draw_buf_create`.
Initialize a layer to use LVGL's generic draw functions (lv_draw_rect/label/...) on the canvas. Needs to be usd in pair with `lv_canvas_finish_layer`.
Wait until all the drawings are finished on layer. Needs to be usd in pair with `lv_canvas_init_layer`.
Get the pivot (rotation center) of the image. If pivot is set with LV_PCT, convert it to px before return.
Set the options in a drop-down list from a static string (global, static or dynamically allocated). Only the pointer of the option string will be saved.
Scroll to a given coordinate on an object. `x` and `y` will be limited internally to allow scrolling only on the content area.
Initialize an arc draw descriptor from an object's styles in its current state
Set where to snap the children when scrolling ends horizontally
Set where to snap the children when scrolling ends vertically
Calculate the current value of an animation with overshoot at the end
Set the text of a check box. `txt` will be copied and may be deallocated after this function returns.
Select next lower digit for edition by dividing the step by 10
Get the width occupied by the "parts" of the widget. E.g. the width of all columns of a table.
GLOBAL PROTOTYPES Get information about an image. Try the created image decoder one by one. Once one is able to get info that info will be used.
Return the sys. layer. The system layer is the same on all screen and it is above the normal screen and the top layer.
Temporarily enable and disable the invalidation of the display.
Try to get a label draw descriptor from a draw task.
Invalidate image cache. Use NULL to invalidate all images.
DEFINES TYPEDEFS GLOBAL PROTOTYPES Low level function to scroll by given x and y coordinates. `LV_EVENT_SCROLL` is sent.
Delete a the left character from the current cursor position
Get the input device passed as parameter to indev related events.
Get the time used to play the animation timeline.
Get the movement vector of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
Checks if the content is scrolled "in" and adjusts it to a normal position.
Set an arrow or other symbol to display when on drop-down list's button. Typically a down caret or arrow.
Calculate the time of an animation based on its speed, start and end values.
Deallocate a cache entry. And the data of the cache entry will be freed.
Store the speed as a special value which can be used as time in animations. It will be converted to time internally based on the start and end values
Get the whether a control value is enabled or disabled for button of a button matrix
Add title to the message box. It also creates a header for the title.
Get a pointer to menu page that is currently displayed in sidebar
Scroll to an object until it becomes visible on its parent. Do the same on the parent's parent, and so on. Therefore the object will be scrolled into view even it has nested scrollable parents
Calculate the current value of an animation applying step characteristic. (Set end value on the end of the animation)
Get the X and Y coordinates where the scrolling will end for this object if a scrolling animation is in progress. If no scrolling animation, give the current `x` or `y` scroll position.
Check the current scroll direction of an input device (for LV_INDEV_TYPE_POINTER and LV_INDEV_TYPE_BUTTON)
Used as `get_glyph_dsc` callback in lvgl's native font format if the font is uncompressed.
Wait for draw finish in case of asynchronous task execution. If `LV_USE_OS == 0` it just return.
Get the height occupied by the "parts" of the widget. E.g. the height of all rows of a table.
Tell whether an area of an object is visible (even partially) now or not
Get the an area where to object can be clicked. It's the object's normal area plus the extended click area.
Get the current scroll mode (when to hide the scrollbars)
Set a static text. It will not be saved by the span so the 'text' variable has to be 'alive' while the span exist.
Delete all children of an object. Also remove the objects from their group and remove all animations (if any). Send `LV_EVENT_DELETED` to deleted objects.
Open an image. Try the created image decoders one by one. Once one is able to open the image that decoder is saved in `dsc`
When a draw unit finished a draw task it needs to request dispatching to let LVGL assign a new draw task to it
Return the top layer. The top layer is the same on all screens and it is above the normal screen layer.
Return the bottom layer. The bottom layer is the same on all screen and it is under the normal screen layer. It's visible only if the screen is transparent.
Transform an array of points using the angle and zoom style properties of an object
Copies up to dst_size-1 (non-null) characters from src to dst. A null terminator is always added.
Align the address of a buffer. The buffer needs to be large enough for the real data after alignment
Get the signed rotary encoder diff. passed as parameter to an event. Can be used in `LV_EVENT_ROTARY`
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Set the rotation angle of the image. The image will be rotated around the set pivot set by `lv_image_set_pivot()` Note that indexed and alpha only images can't be transformed.
Set the rotation center of the image. The image will be rotated around this point. x, y can be set with value of LV_PCT, lv_image_get_pivot will return the true pixel coordinate of pivot in this case.
Clear the attributes of all buttons of a button matrix
Add a button to the footer of to the message box. It also creates a footer.
Add a close button to the message box. It also creates a header.
Clean up the gradient item after it was get with `lv_grad_get_from_cache`.
Calculate the current value of an animation applying an "S" characteristic (cosine)
Get an area the should be invalidated when the arcs angle changed between start_angle and end_ange
Set a new text for a span. Memory will be allocated to store the text by the span.
Get the current index of the x-axis start point in the data array
Set the next point's X and Y value according to the update mode policy.
Get the index of the currently pressed point. It's the same for every series.
Set an array of points. The line object will connect these points.
Set the height to show the given number of rows (options)
Get the actually set y coordinate of object, i.e. the offset from the set alignment
Set a static text. It will not be saved by the label so the 'text' variable has to be 'alive' while the label exists.
GLOBAL PROTOTYPES Initialize the draw buffer with the default handlers.
Keep using the existing memory, reshape the draw buffer to the given width and height. Return NULL if data_size is smaller than the required size.
Lock LVGL's general mutex. LVGL is not thread safe, so a mutex is used to avoid executing multiple LVGL functions at the same time from different threads. It shall be called when calling LVGL functions from threads different than lv_timer_handler's thread. It doesn't need to be called in LVGL events because they are called from lv_timer_handler(). It is called internally in lv_timer_handler().
The pair of `lv_lock()` and `lv_lock_isr()`. It unlocks LVGL general mutex. It is called internally in lv_timer_handler().
Initialize an image draw descriptor from an object's styles in its current state
DEFINES TYPEDEFS GLOBAL PROTOTYPES Get the size of a cache entry.
Release a cache entry. The `lv_cache_entry_t::ref_cnt` will be decremented. If the `lv_cache_entry_t::ref_cnt` is zero, it will issue an error. If the entry passed to this function is the last reference to the data and the entry is marked as invalid, the cache's policy will be used to evict the entry.
Make the animation to play back to when the forward direction is ready
Add an observer to a subject. When the subject changes `observer_cb` will be called.
Clear the attributes of a button of the button matrix
Add a text to the content area of message box. Multiple texts will be created below each other.
Point the needle to the corresponding value through the line
DEFINES TYPEDEFS GLOBAL PROTOTYPES Initialize LVGL library. Should be called before any other LVGL related function.
Clamp a width between min and max width. If the min/max width is in percentage value use the ref_width
Clamp a height between min and max height. If the min/max height is in percentage value use the ref_height
Get a pointer to an `lv_point_t` variable in which the self size should be saved (width in `point->x` and height `point->y`). Can be used in `LV_EVENT_GET_SELF_SIZE`
Drop all dynamically allocated memory and reset the memory pools' state
Manually refresh the state of the animations. Useful to make the animations running in a blocking process where `lv_timer_handler` can't run for a while. Shouldn't be used directly because it is called in `lv_refr_now()`.
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES GLOBAL PROTOTYPES MACROS GLOBAL FUNCTIONS
Get the text content width when all span of spangroup on a line.
Default keyboard event to add characters to the Text area and change the map. If a custom `event_cb` is added to the keyboard this function can be called from it to handle the button clicks
Get a pointer to menu page that is currently displayed in main
Set a destination group for a keypad input device (for LV_INDEV_TYPE_KEYPAD)
Set the start angle of an arc background. 0 deg: right, 90 bottom, etc.
Set the start angle of an arc background. 0 deg: right, 90 bottom etc.
Enable/Disable the positioning of the cursor by clicking the text on the text area.
Get the replacement characters to show in password mode
Set the height reduced by the top and bottom padding and the border width.
TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
remove the least recently used item @todo we can optimise this by finding the n lru items, where n = required_space / average_length
Set a default group. New object are added to this group if it's enabled in their class with `add_to_def_group = true`
Calculate the current value of an animation slowing down the start phase
Set the playback direction of the animation timeline.
Set spinbox digit format (digit count and decimal format)
Set the number of horizontal and vertical division lines
Remove the provided input device. Make sure not to use the provided input device afterwards anymore.
Set an individual point's x and y value of a chart's series directly based on its index Can be used only with `LV_CHART_TYPE_SCATTER`.
Set the value of a cell. Memory will be allocated to store the text by the table.
Set a base theme for a theme. The styles from the base them will be added before the styles of the current theme. Arbitrary long chain of themes can be created by setting base themes.
Set an apply callback for a theme. The apply callback is used to add styles to different objects
Rotate an object to the current position of the arc (knob)
Set text of the drop-down list's button. If set to `NULL` the selected option's text will be displayed on the button. If set to a specific text then that text will be shown regardless of the selected option.
Clear all options in a drop-down list. Works with both static and dynamic options.
Set whether the selected option in the list should be highlighted or not
Set a list of characters. Only these characters will be accepted by the text area
Set a buffer for the canvas. Use lv_canvas_set_draw_buf() instead if you need to set a buffer with alignment requirement.
Get the actually set x coordinate of object, i.e. the offset from the set alignment
Check the children of `obj` and scroll `obj` to fulfill the scroll_snap settings
Swap the positions of two objects. When used in listboxes, it can be used to sort the listbox items.
Used internally to try dispatching draw tasks of a specific layer
Wait for a new dispatch request. It's blocking if `LV_USE_OS == 0` else it yields
Set a default display. The new screens will be created on it by default.
Get the physical horizontal resolution of a display
Get the physical vertical resolution of a display
Helper function for asynchronously deleting objects. Useful for cases where you can't delete an object directly in an `LV_EVENT_DELETE` handler (i.e. parent).
Get the index of a child. Consider the children only with a given type.
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
@endcond Calculate the y value of cubic-bezier(x1, y1, x2, y2) function as specified x.
Used internally by lv_mem_monitor() to gather LVGL heap state information.
As of now, draw buf share same definition as `lv_image_dsc_t`. And is interchangeable with `lv_image_dsc_t`.
Set the palette color of an indexed image. Valid only for `LV_COLOR_FORMAT_I1/2/4/8`
Duplicate a draw buf with same image size, stride and color format. Copy the image data too.
Premultiply draw buffer color with alpha channel. If it's already premultiplied, return directly. Only color formats with alpha channel will be processed.
Gets a pointer to the currently active object in the currently processed input device.
Get the current target of the event. It's the object which event handler being called. If the event is not bubbled it's the same as "original" target.
Acquire a cache entry with the given key. If entry not in cache, it will return `NULL` (not found). If the entry is found, it's priority will be changed by the cache's policy. And the `lv_cache_entry_t::ref_cnt` will be incremented.
Give a name for a cache object. Only the pointer of the string is saved.
Add a new cache entry with the given key and data. If the cache is full, the cache's policy will be used to evict an entry.
Reserve a certain amount of memory/count in the cache. This function is useful when you want to reserve a certain amount of memory/count in advance, for example, when you know that you will need it later. When the current cache size is max than the reserved size, the function will evict entries until the reserved size is reached.
Drop a cache entry with the given key. If the entry is not in the cache, nothing will happen to it. If the entry is found, it will be removed from the cache and its data will be freed when the last reference to it is released.
Drop all cache entries. All entries will be removed from the cache and their data will be freed when the last reference to them is released.
Set the maximum size of the cache. If the current cache size is greater than the new maximum size, the cache's policy will be used to evict entries until the new maximum size is reached. If set to 0, the cache will be disabled.
Return true if the cache is enabled. Disabled cache means that when the max_size of the cache is 0. In this case, all cache operations will be no-op.
Set a function call when the animation really starts (considering `delay`)
Draw an image with SW render. It handles image decoding, tiling, transformations, and recoloring.
Initialize a line mask from a point and an angle.
Add an observer to a subject and also save a target.
Set an object state if an integer subject's value is not equal to a reference value, clear the flag otherwise
Update the layer type of a widget bayed on its current styles. The result will be stored in `obj->spec_attr->layer_type`
GLOBAL PROTOTYPES Find a scrollable object based on the current scroll vector in the indev. In handles scroll propagation to the parent if needed, and scroll directions too.
Handle throwing after scrolling. Called by LVGL during input device processing
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Set the button control map (hidden, disabled etc.) for a button matrix. The control map array will be copied and so may be deallocated after this function returns.
Set attributes of all buttons of a button matrix
Set a non-const array of points. Identical to `lv_line_set_points` except the array may be retrieved by `lv_line_get_points_mutable`.
Add a button to the header of to the message box. It also creates a header.
Find an indev preferably with POINTER type (because it's the most generic) that uses the given group. In other words, find an indev, that is related to the given group. In the worst case simply return the latest indev
Scale the given number of pixels (a distance or size) relative to a 160 DPI display considering the DPI of the default display. It ensures that e.g. `lv_dpx(100)` will have the same physical size regardless to the DPI of the display.
Set the zoom factor of the image. Note that indexed and alpha only images can't be transformed.
Get the old area of the object before its size was changed. Can be used in `LV_EVENT_SIZE_CHANGED`
Get the animation descriptor of a scrolling. Can be used in `LV_EVENT_SCROLL_BEGIN`
Get a pointer to an `lv_hit_test_info_t` variable in which the hit test result should be saved. Can be used in `LV_EVENT_HIT_TEST`
Get a pointer to an area which should be examined whether the object fully covers it or not. Can be used in `LV_EVENT_HIT_TEST`
Set the result of cover checking. Can be used in `LV_EVENT_COVER_CHECK`
Stop the event from bubbling. This is only valid when called in the middle of an event processing chain.
Stop processing this event. This is only valid when called in the middle of an event processing chain.
Register a new, custom event ID. It can be used the same way as e.g. `LV_EVENT_CLICKED` to send custom events Example:
uint32_t LV_EVENT_MINE = 0;
...
e = lv_event_register_id();
...
lv_obj_send_event(obj, LV_EVENT_MINE, &some_data);
Set a function for a group which will be called when a new object is focused
Set a function for a group which will be called when a focus edge is reached
Set whether the next or previous item in a group is focused if the currently focused obj is deleted.
Set whether focus next/prev will allow wrapping from first->last or last->first object.
Get whether focus next/prev will allow wrapping from first->last or last->first object.
Check if any object has a given class (type). It checks the ancestor classes too.
Set a cursor for a pointer input device (for LV_INPUT_TYPE_POINTER and LV_INPUT_TYPE_BUTTON)
Tests the memory allocation system by allocating and freeing a block of memory.
Get whether the animation timeline is played in reverse.
Read the next filename form a directory. The name of the directories will begin with '/'
Set direction of digit step when clicking an encoder button while in editing mode
Get the spinbox numeral value (user has to convert to float according to its digit format)
Get the spinbox step value (user has to convert to float according to its digit format)
Create an "empty" timer. It needs to be initialized with at least `lv_timer_set_cb` and `lv_timer_set_period`
Reset a lv_timer. It will be called the previously set period milliseconds later.
Get the number of custom properties that have been registered thus far.
Set the index of the x-axis start point in the data array. This point will be considers the first (left) point and the other points will be drawn after it.
Set the coordinate of the cursor with respect to the paddings
Get the coordinate of the cursor with respect to the paddings
Set an individual point's y value of a chart's series directly based on its index
Set an external array for the y data points to use for the chart NOTE: It is the users responsibility to make sure the `point_cnt` matches the external array size.
Set an external array for the x data points to use for the chart NOTE: It is the users responsibility to make sure the `point_cnt` matches the external array size.
Assign a Text Area to the Keyboard. The pressed characters will be put there.
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.
Set the text of a check box. `txt` must not be deallocated during the life of this checkbox.
GLOBAL PROTOTYPES Initialize a file system driver with default values. It is used to ensure all fields have known values and not memory junk. After it you can set the fields.
Test if a drive is ready or not. If the `ready` function was not initialized `true` will be returned.
Set the an array of points for LV_INDEV_TYPE_BUTTON. These points will be assigned to the buttons to press a specific point on the screen
Get the last pressed key of an input device (for LV_INDEV_TYPE_KEYPAD)
Get a pointer to the indev read timer to modify its parameters with `lv_timer_...` functions.
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS Redraw the invalidated areas now. Normally the redrawing is periodically executed in `lv_timer_handler` but a long blocking process can prevent the call of `lv_timer_handler`. In this case if the GUI is updated in the process (e.g. progress bar) this function can be called when the screen should be updated.
Set a change rate to limit the speed how fast the arc should reach the pressed point.
Add an options to a drop-down list from a string. Only works for non-static options.
Get the list of a drop-down to allow styling or other modifications
Get the symbol on the drop-down list. Typically a down caret or arrow.
Get whether the selected option in the list should be highlighted or not
Set the replacement characters to show in password mode
In `LV_EVENT_INSERT` the text which planned to be inserted can be replaced by another text. It can be used to add automatic formatting to the text area.
Set how long show the password before changing it to '*'
@deprecated Use the normal text_align style property instead Set the label's alignment. It sets where the label is aligned (in one line mode it can be smaller than the text area) and how the lines of the area align in case of multiline text area
Get whether the cursor click positioning is enabled or not.
Set how long show the password before changing it to '*'
Set the palette color of a canvas for index format. Valid only for `LV_COLOR_FORMAT_I1/2/4/8`
Get the button matrix object of the calendar. It shows the dates and day names.
Set the width reduced by the left and right padding and the border width.
Tell whether an object is being scrolled or not at this moment
Make the refreshing from an object. Draw all its children and the youngers too.
Set line properties Checks if the line has a custom section configuration or not and sets the properties accordingly.
Set the buffers for a display, similarly to `lv_display_set_draw_buffers`, but accept the raw buffer pointers. For DIRECT/FULL rending modes, the buffer size must be at least `hor_res * ver_res * lv_color_format_get_size(lv_display_get_color_format(disp))`
Set the flush callback which will be called to copy the rendered image to the display.
GLOBAL PROTOTYPES Init the group module @remarks Internal function, do not call directly.
Deinit the group module @remarks Internal function, do not call directly.
Set a callback to get information about the image
Set a callback to a decoded line of an image
Set a callback to close a decoding session. E.g. close files and free other resources.
Check the decoded image, make any modification if decoder `args` requires.
Decode `full_area` pixels incrementally by calling in a loop. Set `decoded_area` to `LV_COORD_MIN` on first call.
Allocate a new draw unit with the given size and appends it to the list of draw units
Set the buffers for a display, accept a draw buffer pointer. Normally use `lv_display_set_buffers` is enough for most cases. Use this function when an existing lv_draw_buf_t is available.
Return with a pointer to the previous screen. Only used during screen transitions.
Set the theme of a display. If there are no user created widgets yet the screens' theme will be updated
A function to be easily used in animation ready callback to delete an object when the animation is ready
Push back element. Adds a new element to the end of the array. If the array capacity is not enough for the new element, the array will be resized automatically.
Copies the string pointed to by src, including the terminating null character, to the end of the string pointed to by dst.
Calculate the stride in bytes based on a width and color format
Note: Eventually, lv_draw_buf_malloc/free will be kept as private. For now, we use `create` to distinguish with malloc. Create an draw buf by allocating struct for `lv_draw_buf_t` and allocating a buffer for it that meets specified requirements.
Align the address of a buffer with custom draw buffer handlers. The buffer needs to be large enough for the real data after alignment
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
PROTOTYPES Compute the color in the given gradient and fraction Gradient are specified in a virtual [0-255] range, so this function scales the virtual range to the given range
Should be used during rendering the characters to get the position and other parameters of the characters
Try to get a border draw descriptor from a draw task.
Try to get a box shadow draw descriptor from a draw task.
Add or remove one or more states to the object. The other state bits will remain unchanged.
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
GLOBAL VARIABLES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Invalidate image header cache. Use NULL to invalidate all image headers. It's also automatically called when an image is invalidated.
Return true if the image header cache is enabled.
Legacy `lv_anim_set_time` API will be removed soon, use `lv_anim_set_duration` instead.
A custom cubic bezier animation path, need to specify cubic-parameters in a->parameter.bezier3
Set a whether the animation's should be applied immediately or only when the delay expired.
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
DEFINES TYPEDEFS STATIC PROTOTYPES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Set an object state if an integer subject's value is equal to a reference value, clear the flag otherwise
Set an integer subject to 1 when an object is checked and set it 0 when unchecked.
GLOBAL PROTOTYPES Called by LVGL the rendering of a screen is ready to clean up the temporal (cache) data of the masks
DeInitialize built-in system monitor, such as performance and memory monitor.
Nested events can be called and one of them might belong to an object that is being deleted. Mark this object's `event_temp_data` deleted to know that its `lv_obj_send_event` should return `LV_RESULT_INVALID`
Get resulting sub areas after removing the common parts of two areas from the first area
Deinitialize the object related style manager module. Called by LVGL in `lv_deinit()`
Used internally to compare the appearance of an object in 2 states
Can be used by draw units for TILED images to handle the decoding and prepare everything for the actual image rendering
GLOBAL PROTOTYPES Can be used by draw units to handle the decoding and prepare everything for the actual image rendering
STATIC VARIABLES MACROS GLOBAL FUNCTIONS Initialize the image decoder module
return a new formatted text. Memory will be allocated to store the text.
GLOBAL FUNCTIONS Fill an area with a color. Supports normal fill, fill with opacity, fill with mask, and fill with mask and opacity. dest_buf and color have native color depth. (RGB565, RGB888, XRGB8888) The background (dest_buf) cannot have alpha channel
Get the overall offset from the chart's side to the center of the first point. In case of a bar chart it will be the center of the first column group
Frees the memory allocated by the `lv_binfont_create()` function
Set an offset for the source of an image. so the image will be displayed from the new origin.
Set a single button's relative width. This method will cause the matrix be regenerated and is a relatively expensive operation. It is recommended that initial width be specified using `lv_buttonmatrix_set_ctrl_map` and this method only be used for dynamic changes.
Make the button matrix like a selector widget (only one button may be checked at a time). `LV_BUTTONMATRIX_CTRL_CHECKABLE` must be enabled on the buttons to be selected using `lv_buttonmatrix_set_ctrl()` or `lv_buttonmatrix_set_button_ctrl_all()`.
Check the mutability of the stored point array pointer.
Get a pointer to the mutable array of points or NULL if it is not mutable
Point the needle to the corresponding value through the image, image must point to the right. E.g. -O------>
Delete the right character from the current cursor position
STATIC VARIABLES MACROS GLOBAL FUNCTIONS Initialize the lvgl binary image decoder module
Check if the style property has a specified behavioral flag. Do not pass multiple flags to this function as backwards-compatibility is not guaranteed for that.
Refresh the position of the roller. It uses the id stored in: roller->ddlist.selected_option_id
Get a pointer to the screen refresher timer to modify its parameters with `lv_timer_...` functions.
Swap the upper and lower byte of an RGB565 buffer. Might be required if a 8bit parallel port or an SPI port send the bytes in the wrong order. The bytes will be swapped in place.
Set the value of a pointer subject. It will notify all the observers as well.
Remove all the observers from a subject and free all allocated memories in it
DEFINES TYPEDEFS GLOBAL PROTOTYPES Create a new system monitor label
Remove the transition from object's part's property. - Remove the transition from `lv_obj_style_trans_ll` and free it - Delete pending transitions
Test if char is break char or not (a text can broken here or not)
Set the position of list when it is closed to show the selected item
Set the rotation of this display. LVGL will swap the horizontal and vertical resolutions internally.
Test if char is break char or not (a text can broken here or not)
STATIC PROTOTYPES Transform a point with 1/256 precision (the output coordinates are upscaled by 256)
Show system performance monitor: CPU usage and FPS count
Tell how many draw task are waiting to be drawn on the area of `t_check`. It can be used to determine if a GPU shall combine many draw tasks into one or not. If a lot of tasks are waiting for the current ones it makes sense to draw them one-by-one to not block the dependent tasks' rendering
Make a path object for the memory-mapped file compatible with the file system interface
Get the next image decoder in the linked list of image decoders
Sets the resolution of a display. `LV_EVENT_RESOLUTION_CHANGED` event will be sent. Here the native resolution of the device should be set. If the display will be rotated later with `lv_display_set_rotation` LVGL will swap the hor. and ver. resolution automatically.
It's not mandatory to use the whole display for LVGL, however in some cases physical resolution is important. For example the touchpad still sees whole resolution and the values needs to be converted to the active LVGL display area.
If physical resolution is not the same as the normal resolution the offset of the active display area can be set here.
Set the DPI (dot per inch) of the display. dpi = sqrt(hor_res^2 + ver_res^2) / diagonal"
Get the horizontal offset from the full / physical display
Set a callback to be used while LVGL is waiting flushing to be finished. It can do any complex logic to wait, including semaphores, mutexes, polling flags, etc. If not set the `disp->flushing` flag is used which can be cleared with `lv_display_flush_ready()`
Get elapsed time since last user activity on a display (e.g. click)
Rotate an area in-place according to the display's rotation
Scale the given number of pixels (a distance or size) relative to a 160 DPI display considering the DPI of the given display. It ensures that e.g. `lv_dpx(100)` will have the same physical size regardless to the DPI of the display.
Return a sibling of an object. Consider the siblings only with a given type.
Return the capacity of the array, i.e. how many elements can be stored.
Remove from the array either a single element or a range of elements ([start, end)).
@endcond Alternative (fast, approximate) implementation for getting the square root of an integer.
Copies up to dest_size characters from the string pointed to by src to the character array pointed to by dst and fills the remaining length with null bytes.
Copies up to src_len characters from the string pointed to by src to the end of the string pointed to by dst. A terminating null character is appended to dst even if no null character was encountered in src after src_len characters were copied.
Get the struct which holds the callbacks for draw buf management. Custom callback can be set on the returned value
@deprecated Use lv_draw_buffer_create/destroy instead. Free the data pointer and dsc struct of an image.
Duplicate a draw buf with same image size, stride and color format. Copy the image data too.
Try to get an image draw descriptor from a draw task.
Set the input device's event model: event-driven mode or timer mode.
Set a callback function to read input device data to the indev
Set scroll throw slow-down to the indev. Greater value means faster slow-down
Get the callback function to read input device data to the indev
Touch and key related events are sent to the input device first and to the widget after that. If this functions called in an indev event, the event won't be sent to the widget.
Get the object originally targeted by the event. It's the same even if the event is bubbled.
Utility to set an object reference to NULL when it gets deleted. The reference should be in a location that will not become invalid during the object's lifetime, i.e. static or allocated.
Try to get a triangle draw descriptor from a draw task.
Resize image cache. If set to 0, the cache will be disabled.
Get the node size of a cache entry. Which is the same size with lv_cache_entry_get_size()'s node_size parameter.
Resize image header cache. If set to 0, the cache is disabled.
Acquire a cache entry with the given key. If the entry is not in the cache, it will create a new entry with the given key. If the entry is found, it's priority will be changed by the cache's policy. And the `lv_cache_entry_t::ref_cnt` will be incremented. If you want to use this API to simplify the code, you should provide a `lv_cache_ops_t::create_cb` that creates a new entry with the given key. This API is a combination of lv_cache_acquire() and lv_cache_add(). The effect is the same as calling lv_cache_acquire() and lv_cache_add() separately. And the internal impact on cache is also consistent with these two APIs.
Evict one entry from the cache. The eviction policy will be used to select the entry to evict.
Just a wrapper around LV_FONT_DEFAULT because it might be more convenient to use a function in some cases
Delay for the given milliseconds. By default it's a blocking delay, but with `lv_delay_set_cb()` a custom delay function can be set too
Set whether a lv_timer will be deleted automatically when it is called `repeat_count` times.
Set a function to use the current value of the variable and make start and end value relative to the returned current value.
Legacy `lv_anim_set_playback_time` API will be removed soon, use `lv_anim_set_playback_duration` instead.
Delete an animation by getting the animated variable from `a`. Only animations with `exec_cb` will be deleted. This function exists because it's logical that all anim. functions receives an `lv_anim_t` as their first parameter. It's not practical in C but might make the API more consequent and makes easier to generate bindings.
Get the animation of a variable and its `exec_cb`. This function exists because it's logical that all anim. functions receives an `lv_anim_t` as their first parameter. It's not practical in C but might make the API more consequent and makes easier to generate bindings.
Store the speed as a special value which can be used as time in animations. It will be converted to time internally based on the start and end values
Invert a draw buffer in the I1 color format. Conventionally, a bit is set to 1 during blending if the luminance is greater than 127. Depending on the display controller used, you might want to have different behavior. The inversion will be performed in place.
Set the value of a color subject. It will notify all the observers as well.
Copy a string to a subject. It will notify all the observers as well.
Remove the observers of an object from a subject or all subjects
Get the target object of the observer. It's the same as `lv_observer_get_target` and added only for semantic reasons
Set an object flag if an integer subject's value is equal to a reference value, clear the flag otherwise
Set an object flag if an integer subject's value is not equal to a reference value, clear the flag otherwise
Replaces a style of an object, preserving the order of the style stack (local styles and transitions are ignored). Examples:
lv_obj_replace_style(obj, &yellow_style, &blue_style, LV_PART_ANY | LV_STATE_ANY); //Replace a specific style
lv_obj_replace_style(obj, &yellow_style, &blue_style, LV_PART_MAIN | LV_STATE_PRESSED); //Replace a specific style assigned to the main part when it is pressed
Check if an object has a specified style property for a given style selector.
DEFINES TYPEDEFS GLOBAL PROTOTYPES Set the position of an area (width and height will be kept)
DEFINES TYPEDEFS GLOBAL PROTOTYPES Initialize the theme
Try to get a rectangle mask draw descriptor from a draw task.
Sets a custom calendar year list
Get the image of the canvas as a pointer to an `lv_image_dsc_t` variable.
Return the pointer for the buffer. It's recommended to use this function instead of the buffer form the return value of lv_canvas_get_image() as is can be aligned
Get the index of the lastly "activated" button by the user (pressed, released, focused etc) Useful in the `event_cb` to get the text of the button, check if hidden etc.
Use this function instead of `lv_obj_add/remove_state` to set a state manually
Set the horizontal zoom factor of the image. Note that indexed and alpha only images can't be transformed.
Set the vertical zoom factor of the image. Note that indexed and alpha only images can't be transformed.
Enable/disable anti-aliasing for the transformations (rotate, zoom) or not. The quality is better with anti-aliasing looks better but slower.
Set an offset for the source of an image so the image will be displayed from the new origin.
Get whether the transformations (rotate, zoom) are anti-aliased or not
Tell whether "one check" mode is enabled or not.
Set menu page title with a static text. It will not be saved by the label so the 'text' variable has to be 'alive' while the page exists.
Get scale total tick count (including minor and major ticks)
Get a the character from the current cursor position
Make the animation timeline repeat itself.
Set a delay before repeating the animation timeline.
Get repeat count of the animation timeline.
Get repeat delay of the animation timeline.
STATIC PROTOTYPES GLOBAL VARIABLES STATIC VARIABLES MACROS GLOBAL FUNCTIONS
Basic example to create a "Hello world" label
Create a button with a label and react on click event.
Create a slider and write its value on a label.
Arrange items in rows with wrap and place the items to get even space around them.
Demonstrate the effect of column and row gap style properties
RTL base direction changes order of the items. Also demonstrate how horizontal scrolling works with RTL.
A slider sends a message on value change and a label display's that value
Simple PIN login screen to start an engine. The only interface between the UI and the application is a single "subject".
Show how to handle a complete firmware update process with observers. Normally it's hard to implement a firmware update process because in some cases - the App needs to was for the UI (wait for a button press) - the UI needs to wait for the App (connecting or downloading) With observers these complex mechanisms can be implemented a simple and clean way.
INCLUDES DEFINES TYPEDEFS GLOBAL PROTOTYPES
Create a style transition on a button to act like a gum when clicked
Add custom drawer to the button matrix to customize buttons one by one
Add a faded area effect to the line chart and make some division lines ticker
A round scale with multiple needles, resembling a clock
Customizing scale major tick label color with `LV_EVENT_DRAW_TASK_ADDED` event
A default slider with a label displaying the current value
Show the current value when the slider is pressed by extending the drawer
Automatically format text like a clock. E.g. "12:34" Add the ':' automatically.
Create a 2x2 tile view and allow scrolling only in an "L" shape. Demonstrate scroll chaining with a long list that scrolls the tile view when it can't be scrolled further.
Create a menu from a drop-down list and show some drop-down list features and styling
Show transformations (zoom and rotation) using a pivot point.
Show line wrap, re-color, line align and text scrolling.
Show customizing the circular scrolling animation of a label with `LV_LABEL_LONG_SCROLL_CIRCULAR` long mode.
For given width, height, color format, and stride, calculate the size needed for a new draw buffer.
Process the released state of LV_INDEV_TYPE_POINTER input devices
Process a new point from LV_INDEV_TYPE_BUTTON input device
If `src` is not defined for the current state try to get a state which is related to the current but has `src`. E.g. if the PRESSED src is not set but the RELEASED does, use the RELEASED.
Free the dot_tmp_ptr field if it was previously allocated. Always clears the field
MACROS For compatibility if LV_USE_BIDI = 0 Get the real text alignment from the a text alignment, base direction and a text.
Set the state (fully overwrite) of an object. If specified in the styles, transition animations will be started from the previous state to the current.
Refresh the style of all children of an object. (Called recursively)
Recursively refresh the style of the children. Go deeper until a not NULL style is found because the NULL styles are inherited from the parent
Get the transition style of an object for a given part and for a given state. If the transition style for the part-state pair doesn't exist allocate and return it.
Test if character can be treated as marker, and don't need to be rendered. Note, this is not a full list. Add your findings to the list.
Code Comparator. Compares the value of both input arguments.
Place the grid track according to align methods. It keeps the track sizes but sets their position. It can process both columns or rows according to the passed parameters.
Remove animations which are animating the same var with the same exec_cb and they are already running or they have early_apply
STATIC FUNCTIONS Extract the drive letter and the real path from LVGL's "abstracted file system" path string
cubic-bezier Reference: https://github.com/gre/bezier-easing https://opensource.apple.com/source/WebCore/WebCore-955.66/platform/graphics/UnitBezier.h Copyright (c) 2014 Gaëtan Renaudeau 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: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Check if angle is within arc background bounds In order to avoid unexpected value update of the arc value when the user clicks outside of the arc background we need to check if the angle (of the clicked point) is within the bounds of the background. A tolerance (extra room) also should be taken into consideration. E.g. Arc with start angle of 0° and end angle of 90°, the background is only visible in that range, from 90° to 360° the background is invisible. Click in 150° should not update the arc value, click within the arc angle range should. IMPORTANT NOTE: angle is always relative to bg_angle_start, e.g. if bg_angle_start is 30 and we click a bit to the left, angle is 10, not the expected 40.
Enforces a single button being toggled on the button matrix. It simply clears the toggle flag on other buttons.
Get points for ticks In order to draw ticks we need two points, this interface returns both points for all scale modes.
Dummy function to animate char hiding in pwd mode. Does nothing, but a function is required in car hiding anim. (pwd_char_hider callback do the real job)
Tell the group of a property. If the a property from a group is set in a style the (1 has_group is set. It allows early skipping the style if the property is not exists in the style at all.
STATIC FUNCTIONS Get the local style of an object for a given part and for a given state. If the local style for the part-state pair doesn't exist allocate and return it.
STATIC FUNCTIONS Check if there are older draw task overlapping the area of `t_check`
Move the object to the foreground. It will look like if it was created as the last child of its parent. It also means it can cover any of the siblings.
STATIC FUNCTIONS Process a new point from LV_INDEV_TYPE_POINTER input device
Process new points from an input device. indev->state.pressed has to be set
Called when an animation is completed to do the necessary things e.g. repeat, play back, delete etc.
STATIC FUNCTIONS Helper function to easily create color filters
pop an existing item off the free queue, or create a new one
Convert a wide character, e.g. 'Á' little endian to be UTF-8 compatible
Convert a character index (in an UTF-8 text) to byte index. E.g. in "AÁRT" index of 'R' is 2th char but start at byte 3 because 'Á' is 2 bytes long
Convert a byte index (in an UTF-8 text) to character index. E.g. in "AÁRT" index of 'R' is 2th char but start at byte 3 because 'Á' is 2 bytes long
Get the number of characters (and NOT bytes) in a string. Decode it with UTF-8 if enabled. E.g.: "ÁBC" is 3 characters (but 4 bytes)
Create the required number of buttons and control bytes according to a map
Check if any of the buttons in the first row has the LV_BUTTONMATRIX_CTRL_POPOVER control flag set.
Called when a drop down list is released to open it or set new option
Store `len` characters from `data`. Allocates space if necessary.
Set arc properties Checks if the arc has a custom section configuration or not and sets the properties accordingly.
Set indicator label properties Checks if the indicator has a custom section configuration or not and sets the properties accordingly.
Sets the text of the tick label descriptor when using custom labels Sets the text pointer when valid custom label is available, otherwise set it to NULL.
Stores tick width compensation information for main line sections
Stores the width of the initial and last tick of the main line This width is used to compensate the main line drawing taking into consideration the widths of both ticks
Resets the switch's animation state to "no animation in progress".
Starts an animation for the switch knob. if the anim_time style property is greater than 0
Test a unicode character if it is accepted or not. Checks max length and accepted char list.
Call when an animation is ready to convert all characters to '*'
Emulate connection and FW downloading by timers
INCLUDES DEFINES TYPEDEFS GLOBAL PROTOTYPES
Move the object to the background. It will look like if it was created as the first child of its parent. It also means any of the siblings can cover the object.
Checks if the stop_processing_query flag has been set. If so, do not send any events to the object
Get the next word of text. A word is delimited by break characters. If the word cannot fit in the max_width space, obey LV_TXT_LINE_BREAK_LONG_* rules. If the next word cannot fit anything, return 0. If the first character is a break character, returns the next index. Example calls from lv_text_get_next_line() assuming sufficient max_width and txt = "Test text\n" 0123456789 Calls would be as follows: 1. Return i=4, pointing at breakchar ' ', for the string "Test" 2. Return i=5, since i=4 was a breakchar. 3. Return i=9, pointing at breakchar '\n' 4. Parenting lv_text_get_next_line() would detect subsequent '\0' TODO: Returned word_w_ptr may overestimate the returned word's width when max_width is reached. In current usage, this has no impact.
Other commonly used symbols
Name
Location
Summary
Typedefs from various lvgl modules. They are defined here to avoid circular dependencies.
DEFINES TYPEDEFS Describe the common methods of every object. Similar to a C++ class.
Draw the next glyph after this width. 8.4 format (real_value * 16 is stored).
DEFINES TYPEDEFS Groups can be used to logically hold objects so that they can be individually focused. They are NOT for laying out objects on a screen (try layouts for that).
DEFINES TYPEDEFS The observer object: a descriptor returned when subscribing LVGL widgets to subjects
Struct to describe a constant image resource. It's similar to lv_draw_buf_t, but the data is constant.
Describe an image decoding session. Stores data about the decoding
Index of the active button (being pressed/released etc) or LV_BUTTONMATRIX_BUTTON_NONE
Special events The object's value has changed (i.e. slider moved)
NEVER USE IT DRAW UNITS. USED INTERNALLY DURING DRAW TASK CREATION. The current clip area with absolute coordinates, always the same or smaller than `buf_area` Can be set before new draw tasks are added to indicate the clip area of the draw tasks. Therefore `lv_draw_add_task()` always saves it in the new draw task to know the clip area when the draw task was added. During drawing the draw units also sees the saved clip_area and should use it during drawing. During drawing the layer's clip area shouldn't be used as it might be already changed for other draw tasks.
DEFINES TYPEDEFS Represents a date on the calendar object (platform-agnostic).
class_p is the final class while obj->class_p is the class currently being [de]constructed.
class_p is the class in which event is being processed. Widget type specific event function
Indicator, e.g. for slider, bar, switch, or the tick box of the checkbox
Map the glyphs to Unicode characters. Array of `lv_font_cmap_fmt_txt_t` variables
Same as Android's DIP. (Different name is chosen to avoid mistype between LV_DPI and LV_DIP) 1 dip is 1 px on a 160 DPI screen 1 dip is 2 px on a 320 DPI screen https://stackoverflow.com/questions/2025282/what-is-the-difference-between-px-dip-dp-and-sp
Place holder label. only visible if text is an empty string
Used as the event parameter of ::LV_EVENT_COVER_CHECK to check if an area is covered by the object or not. In the event use `const lv_area_t * area = lv_event_get_cover_area(e)` to get the area to check and `lv_event_set_cover_res(e, res)` to set the result.
Get the required extra draw area around the object (e.g. for shadow). The event parameter is `int32_t *` to store the size.
The area with absolute coordinates to draw on `layer->buf` will be clipped to `layer->clip_area`
Info about the opened image: color format, size, etc. MUST be set in `open` function
DEFINES TYPEDEFS Used as the event parameter of ::LV_EVENT_HIT_TEST to check if an `point` can click the object or not. `res` should be set like this: - If already set to `false` another event wants that point non clickable. If you want to respect it leave it as `false` or set `true` to overwrite it. - If already set `true` and `point` shouldn't be clickable set to `false` - If already set to `true` you agree that `point` can click the object leave it as `true`
Map codepoints to a `glyph_dsc`s Several formats are supported to optimize memory usage See https://github.com/lvgl/lv_font_conv/blob/master/doc/font_spec.md
Pointer to a draw buffer where the image's data (pixels) are stored in a decoded, plain format. MUST be set in `open` or `get_area_cb`function
Invert the mask. The default is: Keep the left part. It is used to select left/right/top/bottom
a pointer to obj that on click triggers back btn event handler, can be same as 'main_header'
The gradient direction. Any of LV_GRAD_DIR_NONE, LV_GRAD_DIR_VER, LV_GRAD_DIR_HOR, LV_GRAD_TYPE_LINEAR, LV_GRAD_TYPE_RADIAL, LV_GRAD_TYPE_CONICAL
External (hardware button) which is assigned to a specific point of the screen
A key is sent to the object. Get the key with `lv_indev_get_key(lv_indev_active());`
More complex but more optimal class based kern value storage
The object is still being pressed but slid cursor/finger off of the object
If the image data is malloced and can be processed in place. In image decoder post processing, this flag means we modify it in-place.
X / (1024*Y) steepness (X is 0..1023 range). What is the change of X in 1024 Y?
Do not scroll the object when the parent scrolls and ignore layout
Function to execute to animate, same purpose as exec_cb but different parameters
Drawing events Check if the object fully covers an area. The event parameter is `lv_cover_check_info_t *`.
Cache class. There are two built-in classes: - lv_cache_class_lru_rb_count for LRU-based cache with count-based eviction policy. - lv_cache_class_lru_rb_size for LRU-based cache with size-based eviction policy.
Cache class struct for building custom cache classes Examples: - lv_cache_class_lru_rb_count for LRU-based cache with count-based eviction policy. - lv_cache_class_lru_rb_size for LRU-based cache with size-based eviction policy.
Generic prototype of "animator" functions. First parameter is the variable to animate. Second parameter is the value to set. Compatible with `lv_xxx_set_yyy(obj, value)` functions The `x` in `_xcb_t` means it's not a fully generic prototype because it doesn't receive `lv_anim_t *` as its first argument
a pointer to obj that on click triggers back btn event handler, can be same as 'sidebar_header'
7 * 6: A week has 7 days, and the calendar displays 6 weeks in total. 20: Including the number of dates, line breaks, names for each day, and reserving several spaces for addresses.
Called after `long_press_time` in every `long_press_repeat_time` ms. Not called if scrolled.
A timer which periodically checks the dirty areas and refreshes them
Store kerning values. Can be `lv_font_fmt_txt_kern_pair_t * or `lv_font_kern_classes_fmt_txt_t *` depending on `kern_classes`
The differences can be shown with a simple redraw
Type of the source: file or variable. Can be set in `open` function if required
1: Send LV_EVENT_VALUE_CHANGE on CLICK, 0: Send LV_EVENT_VALUE_CHANGE on PRESS
Pointer to a font where the glyph was actually found after handling fallbacks
Image size mode when image size and object size is different. See lv_image_align_t
Used to indicate the entire original, non-clipped area where the image is to be drawn. This is important for: 1. Layer rendering, where it might happen that only a smaller area of the layer is rendered. 2. Tiled images, where the target draw area is larger than the image to be tiled.
Scrolling begins. The event parameter is a pointer to the animation of the scroll. Can be modified
A point relative to screen to check if it can click the object or not
if(type == LV_FONT_FMT_TXT_CMAP_FORMAT0_...) it's `uint8_t *` if(type == LV_FONT_FMT_TXT_CMAP_SPARSE_...) it's `uint16_t *`
Apply different style on these days (pointer to user-defined array)
< 1: malloc buffer and copy `text` there. 0: `text` is const and it's pointer will be valid during rendering.
Y / (1024*X) steepness (Y is 0..1023 range). What is the change of Y in 1024 X?
The real draw area. E.g. for shadow, outline, or transformed images it's different from `area`
DEFINES TYPEDEFS Image decoder args. It determines how to decoder an image, e.g. whether to premultiply the alpha or not. It should be passed to lv_img_decoder_open() function. If NULL is provided, default args are used. Default args: all field are zero or false.
The image source. A file path like "S:my_img.png" or pointer to an `lv_image_dsc_t` variable
The object was pressed for a short period of time, then released it. Not called if scrolled.
Do not bother with perpendicular line ending if it's not visible for any reason
Object has been pressed for at least `long_press_time`. Not called if scrolled.
Automatically scroll object to make it visible when focused
Same as `lv_anim_exec_xcb_t` but receives `lv_anim_t *` as the first parameter. It's more consistent but less convenient. Might be used by binding generator functions.
Cache entry slot struct To add new fields to the cache entry, add them to a new struct and add it to the first field of the cache data struct. And this one is a size slot for the cache entry.
A function to call when an edge is reached, no more focus targets are available in this direction (to allow edge feedback like a sound or a scroll bounce)
Convert a letter index (in the encoded text) to byte index. E.g. in UTF-8 "AÁRT" index of 'R' is 2 but start at byte 3 because 'Á' is 2 bytes long
Get the number of characters (and NOT bytes) in a string. E.g. in UTF-8 "ÁBC" is 3 characters (but 4 bytes)
Number of Unicode characters related to this range. Last Unicode character = range_start + range_length - 1
Time to show characters in password mode before change them to '*'
A common type to handle all the various observable types in the same way
Drag throw slow-down in [%]. Greater value means faster slow-down
Horizontal offset from the full / physical display. Set to 0 for fullscreen mode.
Vertical offset from the full / physical display. Set to 0 for fullscreen mode.
Map the glyph_ids to classes: index -> glyph_id -> class_id
Map the glyph_ids to classes: index -> glyph_id -> class_id
DEFINES Magic number for lvgl image, 9 means lvgl version 9 It must be neither a valid ASCII character nor larger than 0x80. See `lv_image_src_get_type`.
A gradient stop definition. This matches a color and a position in a virtual 0-255 scale.
An encoder or wheel was rotated. Get the rotation count with `lv_event_get_rotary_diff(e);`
Helper which stores yx_steep for flat lines and xy_steep for steep (non flat) lines
1: Focus next/prev can wrap at end of list. 0: Focus next/prev stops at end of list.
DEFINES TYPEDEFS Store some info to speed up drawing of very large texts It takes a lot of time to get the first visible character because all the previous characters needs to be checked to calculate the positions. This structure stores an earlier (e.g. at -1000 px) coordinate and the index of that line. Therefore the calculations can start from here.
Define a static draw buffer with the given width, height, and color format. Stride alignment is set to LV_DRAW_BUF_STRIDE_ALIGN. For platform that needs special buffer alignment, call LV_DRAW_BUF_INIT_STATIC.
Convert a byte index (in an encoded text) to character index. E.g. in UTF-8 "AÁRT" index of 'R' is 2 but start at byte 3 because 'Á' is 2 bytes long
Ensure that all assigned draw buffers can be managed by image cache.
If scroll snap is enabled on the parent it can snap to this object
DEFINES TYPEDEFS Special, rarely used attributes. They are allocated automatically if any elements is set.
Horizontal resolution of the full / physical display. Set to -1 for fullscreen mode.
Vertical resolution of the full / physical display. Set to -1 for fullscreen mode.
a shared draw buf for get_bitmap, do not use it directly, use glyph_data instead
The children position has changed due to a layout recalculation
the direction the digit will step on encoder button press when editing
storage format of the bitmap from `lv_font_fmt_txt_bitmap_format_t`
Select a character encoding for strings. Your IDE or editor should have the same character encoding - LV_TXT_ENC_UTF8 - LV_TXT_ENC_ASCII
The current cursor position (0: before 1st letter; 1: before 2nd letter ...)
The image is allocated from heap, thus should be freed after use.
To prevent overflow, insert breaks between any two characters. Otherwise breaks are inserted at word boundaries, as configured via LV_TXT_BREAK_CHARS or according to LV_TXT_LINE_BREAK_LONG_LEN, LV_TXT_LINE_BREAK_LONG_PRE_MIN_LEN, and LV_TXT_LINE_BREAK_LONG_POST_MIN_LEN.
At least this difference should be between two points to evaluate as gesture
1: flushing is in progress. (It can't be a bit field because when it's cleared from IRQ Read-Modify-Write issue might occur)
1: It was the last chunk to flush. (It can't be a bit field because when it's cleared from IRQ Read-Modify-Write issue might occur)
A gesture is detected. Get the gesture with `lv_indev_get_gesture_dir(lv_indev_active());`
Callback to call when the animation really stars (considering `delay`)
Callback used when the animation values are relative to get the current value
DEFINES TYPEDEFS GLOBAL PROTOTYPES MACROS Gives 1 if the x.y.z version is supported in the current version Usage: - Require v6 #if LV_VERSION_CHECK(6,0,0) new_func_in_v6(); #endif - Require at least v5.3 #if LV_VERSION_CHECK(5,3,0) new_feature_from_v5_3(); #endif - Require v5.3.2 bugfixes #if LV_VERSION_CHECK(5,3,2) bugfix_in_v5_3_2(); #endif
Use the buffer(s) to render the screen is smaller parts. This way the buffers can be smaller then the display to save RAM. At least 1/10 screen size buffer(s) are recommended.
The buffer(s) has to be screen sized and LVGL will render into the correct location of the buffer. This way the buffer always contain the whole image. Only the changed ares will be updated. With 2 buffers the buffers' content are kept in sync automatically and in flush_cb only address change is required.
For RGB map of the image data, mark if it's pre-multiplied with alpha. For indexed image, this bit indicated palette data is pre-multiplied with alpha.
The image data is compressed, so decoder needs to decode image firstly. If this flag is set, the whole image will be decompressed upon decode, and `get_area_cb` won't be necessary.
Passed as a parameter to `lv_draw_label_iterate_characters` to draw the characters one by one
Distance between the top of the underline and base line (< 0 means below the base line)
Set to which extent `preferred_draw_unit_id` is good at this task. 80: means 20% better (faster) than software rendering 100: the default value 110: means 10% worse (slower) than software rendering
Called to try to assign a draw task to itself. `lv_draw_get_next_available_task` can be used to get an independent draw task. A draw task should be assign only if the draw unit can draw it too
Show scroll bars when the content is large enough to be scrolled
1: Focus prev if focused on deletion. 0: Focus next if focused on deletion.
Rotary diff count will be multiplied by this value and divided by 256
Array points assigned to the button ()screen will be pressed here by the buttons
MANDATORY: Write the internal buffer (draw_buf) to the display. 'lv_display_flush_ready()' has to be called when finished
Used to wait while flushing is ready. It can do any complex logic to wait, including semaphores, mutexes, polling flags, etc. If not set `flushing` flag is used which can be cleared with `lv_display_flush_ready()`
Keep the object width, wrap lines longer than object width and expand the object height
A screen unload started, fired immediately when scr_load is called
A screen load started, fired when the screen change delay is expired
Consider the transformation properties of the parents too
Execute the inverse of the transformation (-angle and 1/zoom)
The condition is not met and a victim is needed to be evicted
Allow performing more accurate hit (click) test. E.g. consider rounded corners.
Linear gradient defined by start and end points. Can be at any angle.
The draw unit is idle, new dispatching might be requested to try again
When set, decoded image won't be put to cache, and decoder open will also ignore cache.
Decoded indexed image as is. Convert to ARGB8888 if false.
Give the `y` coordinate of the first letter at `line start` index. Relative to the label's coordinates
The 'y1' coordinate of the label when the hint was saved. Used to invalidate the hint if the label has moved too much.
Depends on `format` field, it could be image source or draw buf of bitmap or vector data.
the example show the use of cubic-bezier3 in animation. the control point P1,P2 of cubic-bezier3 can be adjusted by slider. and the chart shows the cubic-bezier3 in real time. you can click run button see animation in current point of cubic-bezier3.
Pointer to the allocated memory containing the character replaced by dots
Check the base class. Must have 0 value to let zero initialized class inherit
Check the base class. Must have 0 value to let zero initialized class inherit
A text is inserted to the object. The event data is `char *` being inserted.
If set to true, the read callback is invoked again, unless the device is in event-driven mode
Used when stepping up/down to a shorter line. (Used by the library)
Always redraw the whole screen even if only one pixel has been changed. With 2 buffers in flush_cb only and address change is required.
The condition is not met and the reserve size is too large
Where to align the snappable children horizontally, see `lv_scroll_snap_t`
Max-width is already equal to the longest line. (Used to skip some calculation)
The clip area of the layer is saved here when the draw task is created. As the clip area of the layer can be changed as new draw tasks are added its current value needs to be saved. Therefore during drawing the layer's clip area shouldn't be used as it might be already changed for other draw tasks.
Stride alignment for draw buffers. It may vary between different color formats and hardware. Refine it to suit your needs.
1: Automatically delete the previous screen when the screen load animation is ready Custom user data
Whether image should be premultiplied or not after decoding
Convert a wide character, e.g. 'Á' little endian to be compatible with the encoded format.
Header is positioned at the top and can be scrolled out of view
Automatically free user data when the observer is removed
The condition is met and no entries need to be evicted
The cache instance allocation function, used by the cache class to allocate memory for cache instances.
The cache instance initialization function, used by the cache class to initialize the cache instance.
The cache instance destruction function, used by the cache class to destroy the cache instance.
The cache remove function, used by the cache class to remove a cache entry from the cache but doesn't free the memory.. This function only cares about how to remove the entry, it doesn't care about is it a victim or not.
The cache drop function, used by the cache class to remove a cache entry from the cache and free the memory.
The cache drop all function, used by the cache class to remove all cache entries from the cache and free the memory.
GENERATED FILE, DO NOT EDIT IT! @file lv_conf_internal.h Make sure all the defines of lv_conf.h have a default value
* @file lv_conf_kconfig.h * Configs that need special handling when LVGL is used with Kconfig
@file lv_ll.h Handle linked lists. The nodes are dynamically allocated by the 'lv_mem' module.
@file lvgl.h This file exists only to be compatible with Arduino's library structure
Behaviour outside the defined range. LV_GRAD_EXTEND_NONE, LV_GRAD_EXTEND_PAD, LV_GRAD_EXTEND_REPEAT, LV_GRAD_EXTEND_REFLECT
Called to signal the unit to complete all tasks in order to return their ready status. This callback can be implemented in case of asynchronous task processing. Below is an example to show the difference between synchronous and asynchronous: Synchronous: LVGL thread DRAW thread HW task1 --> submit --> Receive task1 wait_for_finish() state = READY <-- Complete task1 task2 --> submit --> Receive task2 wait_for_finish() task2->state = READY <-- Complete task2 task3 --> submit --> Receive task3 wait_for_finish() state = READY <-- Complete task3 task4 --> submit --> Receive task4 wait_for_finish() state = READY <-- Complete task4 NO MORE TASKS Asynchronous: LVGL thread DRAW thread HW is IDLE task1 --> queue task1 submit --> Receive task1 task2 --> queue task2 is BUSY (with task1) task3 --> queue task3 still BUSY (with task1) task4 --> queue task4 becomes IDLE state = READY <-- Complete task1 submit --> Receive task2, task3, task4 NO MORE TASKS wait_for_finish_cb() wait_for_finish() <-- Complete task2, task3, task4 state = READY <-- state = READY <-- state = READY <--
@file lv_tick.h Provide access to the system tick with 1 millisecond resolution
@file lv_array.h Array. The elements are dynamically allocated by the 'lv_mem' module.
How much time did it take to open the image. [ms] If not set `lv_image_cache` will measure and set the time to open
A text to display instead of the image when the image can't be opened. Can be set in `open` function or set NULL.
@file lv_draw_pxp.h Copyright 2022-2024 NXP SPDX-License-Identifier: MIT
@file lv_pxp_cfg.h Copyright 2020-2023 NXP SPDX-License-Identifier: MIT
@file lv_pxp_osa.h Copyright 2020, 2022-2023 NXP SPDX-License-Identifier: MIT
@file lv_pxp_utils.h Copyright 2023-2024 NXP SPDX-License-Identifier: MIT
@file lv_draw_vglite.h Copyright 2023-2024 NXP SPDX-License-Identifier: MIT
@file lv_vglite_buf.h Copyright 2023 NXP SPDX-License-Identifier: MIT
@file lv_vglite_matrix.h Copyright 2023 NXP SPDX-License-Identifier: MIT
@file lv_vglite_path.h Copyright 2023 NXP SPDX-License-Identifier: MIT
@file lv_vglite_utils.h Copyright 2022-2024 NXP SPDX-License-Identifier: MIT
@file lv_draw_sw_blend_to_argb8888.h
@file lv_wayland.h - Public functions of the LVGL Wayland client Based on the original file from the repository. Porting to LVGL 9.1 2024 EDGEMTech Ltd. See LICENCE.txt for details Author(s): EDGEMTech Ltd, Erik Tagirov (erik.tagirov@edgemtech.ch)
@file lv_ili9341.h This driver is just a wrapper around the generic MIPI compatible LCD controller driver
@file lv_lcd_generic_mipi.h Generic driver for controllers adhering to the MIPI DBI/DCS specification Works with: ST7735 ST7789 ST7796 ILI9341 ILI9488 (NOTE: in SPI mode ILI9488 only supports RGB666 mode, which is currently not supported) any probably many more
@file lv_st7735.h This driver is just a wrapper around the generic MIPI compatible LCD controller driver
@file lv_st7789.h This driver is just a wrapper around the generic MIPI compatible LCD controller driver
@file lv_st7796.h This driver is just a wrapper around the generic MIPI compatible LCD controller driver
GENERATED FILE, DO NOT EDIT IT! @file lv_style_properties.h
Dependencies
i80_controller sample depends on the following libraries: