/* * Created on: 02-Apr-2020 */ /** * @file lame_ui.h * @author Avra Mitra * @brief One and only header file for LameUI library. * @version 2.0 * @date 2023-10-26 * * @copyright Copyright (c) 2020-2023 * */ #ifndef INC_LAME_UI_H_ #define INC_LAME_UI_H_ #include #include #include #include /*-------------------------------------------- * User Config *-------------------------------------------- */ /** * @defgroup LUI_USER_CONFIG User Configuration * @brief User may change configuration using these macros. All these macros * can be found in `lame_ui.h` file. * @{ */ #define LUI_MAX_OBJECTS 200 ///< Set number of maximum objects that can be created // #define LUI_USE_DARK_THEME 0 ///< Comment out OR set value to 0 for using light theme /** * @defgroup LUI_USE_OBJECT Widgets to use * @brief Defines which widgets to use. Only if the relevant macro is defined, * that widget will be compiled. Comment out the object that you don't want to * use. This helps to save Flash. * * @note Some widgets, that are not in this list, are always compiled and can * not be disabled. * * Also see: @ref LUI_OBJ * @{ */ #define LUI_USE_LINECHART ///< Compile Linechart widget #define LUI_USE_SWITCH ///< Compile Switch widget #define LUI_USE_CHECKBOX ///< Compile Checkbox widget #define LUI_USE_SLIDER ///< Compile Slider widget #define LUI_USE_LIST ///< Compile List widget #define LUI_USE_PANEL ///< Compile Panel widget #define LUI_USE_TEXTBOX ///< Compile Textbox widget #define LUI_USE_BUTTONGRID ///< Compile Buttongrid widget #if defined(LUI_USE_BUTTONGRID) #define LUI_USE_KEYBOARD ///< Compile Keyboard widget. (Note: To use keyboard, buttongrid must be used) #endif /**@} */ /**@} */ /*-------------------------------------------- * End Config *-------------------------------------------- */ /*---------------------------------------------------- * ------- !!! Don't edit anything below !!! --------- *---------------------------------------------------- */ /*-------------------------------------------- * Macro Definitions *-------------------------------------------- */ #define LUI_INPUT_TYPE_TOUCH 1 // #define LUI_INPUT_TYPE_ENCODER 2 /** * @defgroup LUI_STATE LameUI input states * @brief All input states of LameUI * * Also see: @ref LUI_EVENT * @{ */ #define LUI_STATE_IDLE 0 ///< Idle state. Object is not under the pointing device #define LUI_STATE_SELECTED 1 ///< Object is under the pointing device #define LUI_STATE_PRESSED 2 ///< Object is under the pointing device and the pointing device button is pressed #define LUI_STATE_ENTERED 3 ///< Object is in entered state. Example: Text box is clicked /**@} */ /** * @defgroup LUI_EVENT LameUI input events * @brief All input events of LameUI. Events depend on previous and current state * * Also see: @ref LUI_STATE * @{ */ #define LUI_EVENT_NONE 0 ///< No event occurred #define LUI_EVENT_SELECTED 1 ///< Object is selected (under the pointing device) #define LUI_EVENT_SELECTION_LOST 2 ///< Selection of object is lost (no more under the pointing device) #define LUI_EVENT_PRESSED 3 ///< Object is pressed (object under pointing device and pointing device button is low) #define LUI_EVENT_RELEASED 4 ///< Object is released (object under pointing device but pointing device button is released) #define LUI_EVENT_ENTERED 5 ///< Object is entered to edit/input mode. Example: Clicking on a text box #define LUI_EVENT_EXITED 6 ///< Opposite of above. Example: Exiting edit mode of a text box #define LUI_EVENT_VALUE_CHANGED 7 ///< Value of a object is changed. Example: a slider is dragged #define LUI_EVENT_CHECK_CHANGED 7 ///< Check status of an object is changed. Example: checkbox is checked/unchecked /**@} */ /** * @defgroup LUI_OBJ LameUI object types * @brief All types of objects (widgets) in LameUI * @{ */ #define LUI_OBJ_NONE 0 ///< No type #define LUI_OBJ_LABEL 1 ///< Label widget. See: \ref lui_label #define LUI_OBJ_BUTTON 2 ///< Button widget. See: \ref lui_button #define LUI_OBJ_SWITCH 3 ///< Switch widget. See: \ref lui_switch #define LUI_OBJ_LINECHART 4 ///< Line Chart widget. See: \ref lui_linechart #define LUI_OBJ_PANEL 5 ///< Panel widget. See: \ref lui_panel #define LUI_OBJ_SCENE 6 ///< Scene widget. See: \ref lui_scene #define LUI_OBJ_GENERIC 7 ///< Generic widget (user defined widget) #define LUI_OBJ_LIST 8 ///< List widget. See: \ref lui_list #define LUI_OBJ_CHECKBOX 9 ///< Checkbox widget. See: \ref lui_checkbox #define LUI_OBJ_SLIDER 10 ///< Slider widget. See: \ref lui_slider #define LUI_OBJ_BTNGRID 11 ///< Buttongrid widget. See: \ref lui_btngrid #define LUI_OBJ_TEXTBOX 12 ///< Textbox widget. See: \ref lui_textbox /**@} */ #define LUI_LAYER_POPUP 255 #define LUI_LAYER_SYSTEM 254 /** * @defgroup LUI_KEYBOARD_MODE Keyboard modes * @brief Keyboard modes of LameUI * @{ */ #define LUI_KEYBOARD_MODE_TXT_LOWER 1 ///< lowercase text mode #define LUI_KEYBOARD_MODE_TXT_UPPER 2 ///< UPPERCASE TEXT MODE #define LUI_KEYBOARD_MODE_TXT_SPCL 3 ///< $pec!a1 charac+er m0d3; /**@} */ /** * @defgroup LUI_ICONS Default built-in icons * @brief These are default icons used by LameUI. Not to be modified by user. * * Icons can be used with strings like this: * `char* str = LUI_ICON_ARROW_FORWARD "My Home" LUI_ICON_HOME`. * Range of default icon index is 0x01 (1) to 0x1D (29). This MUST not be changed by user. * User may add custom icons when creating font. * Range of user defined icons is 0x80 (128) to 0xFF (255). * * Note: Range 0x20 (32) to 0x7F (127) must be kept free for ASCII characters. * * @{ */ #define LUI_ICON_HOME "\x01" #define LUI_ICON_RELOAD "\x02" #define LUI_ICON_CARET_BACK "\x03" #define LUI_ICON_LOCATION "\x04" #define LUI_ICON_BATTERY_FULL "\x05" #define LUI_ICON_CHECKMARK "\x06" #define LUI_ICON_RETURN_DOWN_BACK "\x07" #define LUI_ICON_ARROW_DOWN "\x08" #define LUI_ICON_BACKSPACE "\x09" #define LUI_ICON_PAUSE "\x0A" #define LUI_ICON_REMOVE "\x0B" #define LUI_ICON_POWER "\x0C" #define LUI_ICON_CARET_UP "\x0D" #define LUI_ICON_VOLUME_MEDIUM "\x0E" #define LUI_ICON_ARROW_BACK "\x0F" #define LUI_ICON_CLOSE "\x10" #define LUI_ICON_BLUETOOTH "\x11" #define LUI_ICON_CARET_FORWARD "\x12" #define LUI_ICON_VOLUME_OFF "\x13" #define LUI_ICON_ARROW_FORWARD "\x14" #define LUI_ICON_BATTERY_CHARGING "\x15" #define LUI_ICON_ARROW_UP "\x16" #define LUI_ICON_WIFI "\x17" #define LUI_ICON_SEARCH "\x18" #define LUI_ICON_WARNING "\x19" #define LUI_ICON_SETTINGS "\x1A" #define LUI_ICON_ADD "\x1B" #define LUI_ICON_BATTERY_DEAED "\x1C" #define LUI_ICON_CARET_DOWN "\x1D" /**@} */ /** * @defgroup LUI_BTNGRID_MASKS Buttongrid button property masks * @brief Property byte masks of a buttongrid. Masks set different properties of * a button in a buttongrid. * @{ */ #define LUI_BTNGRID_MASK_BTN_DISABLED 0x40 ///< Button disabled mask #define LUI_BTNGRID_MASK_BTN_HIDDEN 0x20 ///< Button hidden mask #define LUI_BTNGRID_MASK_BTN_CHECKABLE 0x10 ///< Button checkable mask #define LUI_BTNGRID_MASK_BTN_CHECKED 0x80 ///< Button checked mask #define LUI_BTNGRID_MASK_BTN_WIDTH_UNIT 0x0F ///< Button width mask /**@} */ /** * @defgroup LUI_ALIGNMENT Content alignment flags * @brief Content alignment flags * @{ */ #define LUI_ALIGN_LEFT 0 ///< Align content to left #define LUI_ALIGN_CENTER 1 ///< Align content to center #define LUI_ALIGN_RIGHT 2 ///< Align content to right /**@} */ /** * @defgroup LUI_LAYOUT Widget layout flags * @brief Widget layout flags to use with panels and scenes only. * @{ */ #define LUI_LAYOUT_NONE 0 ///< No layout #define LUI_LAYOUT_HORIZONTAL 1 ///< Horizontal layout #define LUI_LAYOUT_VERTICAL 2 ///< Vertical layout /**@} */ /** * @defgroup LUI_SLIDER_KNOB_TYPE Slider widget knob type flag * @brief Knob type flag for slider widget. It defines how the knob of a slider * is rendered. * @{ */ #define LUI_SLIDER_KNOB_TYPE_NONE 0 ///< No knob will be rendered #define LUI_SLIDER_KNOB_TYPE_DEFAULT 1 ///< Default knob (a rectangle) will be rendered #define LUI_SLIDER_KNOB_TYPE_TEXT 2 ///< Text (value and/or custom text) will be rendered /**@} */ /** * @defgroup LUI_LINECHART_DRAW_MODE Linechart widget draw mode * @brief Draw mode flag for linechart widget. It defines how the line is drawn. * These flags can be ORed. * @{ */ #define LUI_LINECHART_DRAW_MODE_LINE (1 << 0) ///< Draw the lines by connection points #define LUI_LINECHART_DRAW_MODE_POINT (1 << 1) ///< Draw the chart points/markers /**@} */ /** * @defgroup LUI_DEFAULT_FONT LameUI default font * @brief This is default font of LameUI. User can access default font using this macro. * @{ */ #define LUI_DEFAULT_FONT FONT_lui_default /**@} */ /*-------------------------------------------- * End Macro Definitions *-------------------------------------------- */ /*-------------------------------------------- * Typedefs and Structs *-------------------------------------------- */ #pragma pack(push, 1) /** * @defgroup PublicTypedefs Custom public datatypes. * @brief Custom public datatypes */ typedef struct { uint8_t* mem_block; uint32_t block_max_sz; uint32_t mem_allocated; } _lui_mem_block_t; /** * @ingroup PublicTypedefs * @brief bitmap datatype. Used to render images. Generated using LameUI font tools * * Bitmap must be generated with LameUI tools (see docs). Supported * bits-per-pixel (bpp) are 1, 8, and 16. * @{ */ typedef struct _lui_bitmap_s { const uint8_t* const payload; ///< Bitmap payload const uint16_t size_x; ///< Bitmap size in x axis const uint16_t size_y; ///< Bitmap size in y axis const uint8_t bpp; ///< Bits-per-pixels (1, 8, 16) } lui_bitmap_t; /**@} */ /* Color palette for 1-bpp mono bitmap image. */ /** * @ingroup PublicTypedefs * @brief Color palette for 1-bpp mono bitmap image. * * This color palette has NO effect on 8-bpp grayscale and 16-vpp rgb565 bitmaps. * @{ */ typedef struct _lui_bitmap_mono_pal_s { uint16_t fore_color; ///< foreground color of 1-bpp bitmap uint16_t back_color; ///< background color of 1-bpp bitmap uint8_t is_backgrnd; ///< 0: Don't draw any background color, 1: Draw background color } lui_bitmap_mono_pal_t; /**@} */ /* This is a font glyph description - for now it does not support kerning */ /* See: https://freetype.org/freetype2/docs/glyphs/glyphs-3.html */ typedef struct { const uint16_t payload_index; const char character; // ASCII code const uint8_t width; // glyph bbox width const uint8_t x_adv; // glyph advance x const uint8_t x_off; // glyph left bearing x } _lui_glyph_t; /** * @ingroup PublicTypedefs * @brief font datatype. Generated using LameUI font tools. * * Users must NOT read/write members directly. All actions are done using * getter and setter functions * @{ */ typedef struct _lui_font_s { const lui_bitmap_t* const bitmap; const uint8_t glyph_count; const _lui_glyph_t* glyphs; // pointer to array of glyph_t elements } lui_font_t; /**@} */ extern const lui_font_t LUI_DEFAULT_FONT; /* !! For internal private use only. This was an old design * choice and should be replaced with `lui_area_t` in future. */ typedef struct _lui_area_priv_s { uint16_t x1; uint16_t y1; uint16_t x2; uint16_t y2; } _lui_area_priv_t; /** * @ingroup PublicTypedefs * @brief Area datatype. * * lui_area_t is used to define area or size of an item. * @{ */ typedef struct _lui_area_s { uint16_t x; ///< Start position in X axis uint16_t y; ///< Start position in Y axis uint16_t w; ///< Width of item uint16_t h; ///< Height of item } lui_area_t; /**@} */ struct _lui_layout_s { uint8_t type; uint8_t pad_x; uint8_t pad_y; uint16_t dim; // uint8_t align; }; struct _lui_common_style_s { uint16_t bg_color; uint16_t border_color; uint16_t width; uint16_t height; uint8_t border_width; }; struct _lui_label_style_s { uint16_t text_color; uint8_t is_transparent_bg; }; struct _lui_button_style_s { uint16_t label_color; uint16_t label_pressed_color; uint16_t pressed_color; uint16_t selection_color; uint8_t is_transparent_bg; }; #if defined(LUI_USE_SWITCH) struct _lui_switch_style_s { uint16_t knob_on_color; uint16_t knob_off_color; uint16_t selection_color; }; #endif #if defined(LUI_USE_CHECKBOX) struct _lui_checkbox_style_s { uint16_t tick_color; uint16_t bg_checked_color; uint16_t selection_color; }; #endif #if defined(LUI_USE_SLIDER) struct _lui_slider_style_s { uint16_t knob_color; uint16_t bg_filled_color; uint16_t selection_color; uint8_t knob_width; }; #endif #if defined(LUI_USE_LINECHART) struct _lui_linechart_style_s { uint16_t line_color; uint16_t grid_color; uint16_t point_color; uint8_t grid_visible; uint8_t line_width; uint8_t point_width; uint8_t draw_mode; }; #endif #if defined(LUI_USE_LIST) struct _lui_list_style_s { uint16_t item_label_color; uint8_t item_has_border; uint16_t item_border_color; }; #endif #if defined(LUI_USE_BUTTONGRID) struct _lui_btngrid_style_s { uint8_t btn_margin_hor; uint8_t btn_margin_vert; uint16_t btn_label_color; uint16_t btn_pressed_color; uint16_t btn_bg_color; }; #endif #if defined(LUI_USE_TEXTBOX) struct _lui_textbox_style_s { uint16_t text_color; uint16_t bg_filled_color; }; #endif /** * @ingroup PublicTypedefs * @brief Generic object datatype. Accessed only through getter and setter functions. * * lui_obj_t contains all the common data of objects along with address of * the extended data as per the type of the object * @{ */ typedef struct _lui_obj_s { uint16_t x; ///< Horizontal position (px) uint16_t y; ///< Vertical position (px) uint8_t layer; ///< Rendering layer (0 - 128) struct _lui_common_style_s common_style; ///< Common style properties of objects uint8_t state; ///< Input state uint8_t event; ///< Input event int32_t value; ///< User defined value void (*obj_event_cb)(struct _lui_obj_s* obj); ///< Input event callback function uint8_t needs_refresh; ///< Object refresh flag uint8_t visible; ///< Object visibility flag uint8_t enabled; ///< Object input enable flag uint8_t obj_type; ///< Object type struct _lui_obj_s* parent; ///< Parent of object uint8_t children_count; ///< Object's children count struct _lui_obj_s* first_child; ///< First child of object struct _lui_obj_s* next_sibling; ///< Next sibling of object void *obj_main_data; ///< Main (extended) data of the object } lui_obj_t; /**@} */ #if defined(LUI_USE_LINECHART) typedef struct _lui_linechart_s { struct { uint8_t hor_count; uint8_t vert_count; // uint16_t color; // uint8_t is_grid; } grid; struct _lui_linechart_style_s style; struct { double* source; uint16_t points; uint8_t auto_scale; double y_max_value; double y_min_value; } data; // uint16_t color; const lui_font_t* font; } lui_chart_t; #endif typedef struct _lui_label_s { char* text; const lui_font_t* font; struct _lui_label_style_s style; } lui_label_t; typedef struct _lui_button_s { struct { const lui_font_t* font; const char* text; const char* text_pressed; uint8_t text_align; } label; struct _lui_button_style_s style; const lui_bitmap_t* img_idle; const lui_bitmap_t* img_pressed; /* Only when images are mono (1-bpp) */ lui_bitmap_mono_pal_t img_idle_pal; lui_bitmap_mono_pal_t img_press_pal; uint8_t is_checkable; } lui_button_t; #if defined(LUI_USE_SWITCH) typedef struct _lui_switch_s { struct _lui_switch_style_s style; } lui_switch_t; #endif #if defined(LUI_USE_CHECKBOX) typedef struct _lui_checkbox_s { struct _lui_label_s label; struct _lui_checkbox_style_s style; } lui_checkbox_t; #endif #if defined(LUI_USE_SLIDER) typedef struct _lui_slider_s { struct _lui_slider_style_s style; int16_t range_min; int16_t range_max; uint8_t knob_type; // knob's center's distance relative to slider's start position. Measured along x axis for horizontal slider (and y for vertical). uint16_t knob_center_rel_d; const char* custom_text; uint8_t show_value; const lui_font_t* font; uint8_t is_progress_bar; } lui_slider_t; #endif #if defined(LUI_USE_LIST) struct _lui_list_item { const char* text; _lui_area_priv_t area; }; typedef struct _lui_list_s { struct _lui_list_item** items; struct _lui_list_style_s style; const lui_font_t* font; int16_t selected_item_index; uint8_t page_count; uint8_t current_page_index; uint8_t items_per_page; uint8_t page_first_item_index; uint8_t item_min_height; uint8_t text_align; uint8_t max_items; uint8_t items_cnt; uint8_t is_dropdown; uint8_t is_expanded; } lui_list_t; #endif #if defined(LUI_USE_KEYBOARD) typedef struct _lui_keyboard_s { lui_obj_t* target_txtbox; uint8_t keyboard_mode; } lui_keyboard_t; #endif #if defined(LUI_USE_BUTTONGRID) typedef struct _lui_btngrid_s { const char* *texts; uint8_t* btn_properties; _lui_area_priv_t* btn_area; uint8_t btn_cnt; uint8_t row_cnt; const lui_font_t* font; int16_t active_btn_index; uint8_t needs_full_render; struct _lui_btngrid_style_s style; #if defined(LUI_USE_KEYBOARD) struct _lui_keyboard_s *kb_data; #endif } lui_btngrid_t; #endif #if defined(LUI_USE_TEXTBOX) typedef struct _lui_textbox_s { char* text_buffer; const lui_font_t* font; uint16_t max_len; uint16_t caret_index; uint16_t used_chars; uint8_t needs_full_render; struct _lui_textbox_style_s style; } lui_textbox_t; #endif #if defined(LUI_USE_PANEL) typedef struct _lui_panel_s { struct _lui_layout_s layout; const lui_bitmap_t* bg_image; /* Color palette for only when image is 1-bpp mono bitmap */ lui_bitmap_mono_pal_t img_pal; } lui_panel_t; #endif typedef struct _lui_scene_s { struct _lui_layout_s layout; const lui_bitmap_t* bg_image; /* Color palette for only when image is 1-bpp mono bitmap */ lui_bitmap_mono_pal_t img_pal; const lui_font_t* font; } lui_scene_t; /** * @ingroup PublicTypedefs * @brief Touch Input data * * touch input device data. * * @{ */ typedef struct _lui_touch_input_data_s { uint8_t is_pressed; ///< 0: NOT pressed, 1: Pressed int16_t x; ///< X position of press/touch. -1 if not Pressed/touched int16_t y; ///< Y position of press/touch. -1 if not Pressed/touched } lui_touch_input_data_t; /**@} */ /** * @ingroup PublicTypedefs * @brief display driver object. * * @{ */ typedef struct _lui_disp_drv_s { void (*draw_pixels_buff_cb)(uint16_t* disp_buff, lui_area_t* area); ///< draw pixels buffer callback function. uint16_t* disp_buff; ///< display buffer. It is an array of uint16_t type. uint16_t disp_buff_sz_px; ///< size of display buffer in pixel count (NOT in bytes) uint16_t display_hor_res; ///< display horizontal resolution (along x axis) uint16_t display_vert_res; ///< display vertical resolution (along y axis) } lui_dispdrv_t; /**@} */ /** * @ingroup PublicTypedefs * @brief touch input device object * * The callback function to read input should be implemented by user. * * @{ */ typedef struct _lui_touch_input_dev_s { void (*read_touch_input_cb)(lui_touch_input_data_t* input); ///< callback function to read input data. // lui_touch_input_data_t touch_data; } lui_touch_input_dev_t; /**@} */ typedef struct _lui_main_s { // lui_obj_t* scenes[LUI_MAX_SCENES]; const lui_font_t* default_font; lui_obj_t* active_scene; lui_obj_t* active_obj; lui_dispdrv_t* disp_drv; lui_touch_input_dev_t* touch_input_dev; lui_touch_input_data_t last_touch_data; uint8_t input_state_pressed; uint8_t input_event_clicked; uint8_t total_scenes; uint8_t total_created_objects; // increases as new objs are created. It never decreases } _lui_main_t; #pragma pack(pop) /*-------------------------------------------- * End Typedefs/Structs *-------------------------------------------- */ /*-------------------------------------------- * Function Prototypes *-------------------------------------------- */ /*------------------------------------------------------------------------------- * Init and Update functions *------------------------------------------------------------------------------- */ /** * @defgroup lui_core Initialization and UI Update API * @brief These functions are used to initialize the core and to update it. * - lui_init() is only called once at the very beginning. * - lui_update() is called periodically in an infinite loop. * @{ */ /** * @brief Initialize the LameUI core. Here user provides LameUI some RAM to * create widgets. If and when RAM is not sufficient, widget creation will fail. * * NOTE: This memory does NOT include display buffer memory. Display buffer is * set seperately using `lui_dispdrv_set_disp_buff()`. * * If init fails due to memory allocation problem, returns -1, else returns 0. * * @param mem_block an array of uint8_t. this will be used as work area * @param size size of the alloted memory * @return 0: Success, -1: Failure */ int8_t lui_init(uint8_t mem_block[], uint32_t size); /** * @brief This function updates the UI by reading input and rendering widgets * that need rendering. * * User must call this function periodically (e.g. every 20ms) in a loop so * no input event is missed. Also, LameUI renders only when widgets need * rendering. So, draw calls are not wasted. * */ void lui_update(); /** * @brief Sets default font of LameUI. * * Objects that are created after calling this, will inherit the new default font. * But objects created earlier won't update their font automatically. * * @param font font * @return int8_t 0: Success, -1: Fail */ int8_t lui_set_default_font(const lui_font_t* font); /**@}*/ /*------------------------------------------------------------------------------- * LUI_OBJECT (generic) related functions *------------------------------------------------------------------------------- */ /** * @defgroup lui_object Generic object related API. Works with all widgets. * @brief These functions are applicable for all types of objects. * Only for a few particular types of objects, one or more of these functions have no effect. * @{ */ /** * @brief Add a child object to a parent object, thus grouping them together * * @code * // Creating a scene which will be a parent object * lui_obj_t* parent_scene = lui_scene_create(); * lui_scene_set_active(parent_scene); * * // Creating a label which will be a child of the parent scene * lui_obj_t* child_label = lui_label_create(); * lui_label_set_text(child_label, "I am child of a scene"); * lui_object_add_to_parent(child_label, parent_scene); // Add child to parent * @endcode * * @param obj child object * @param parent_obj parent object */ void lui_object_add_to_parent(lui_obj_t* obj, lui_obj_t* parent_obj); /** * @brief Remove an object from its current parent * * @param obj Child object */ void lui_object_remove_from_parent(lui_obj_t* obj); /** * @brief Get a particular child by index from a parent * * @param obj_parent parent object * @param child_index index of child * @return lui_obj_t* pointer to child object. Returns NULL if not found */ lui_obj_t* lui_object_get_child(lui_obj_t* obj_parent, uint16_t child_index); /** * @brief Set drawing area of an object * * @param obj target object * @param width width * @param height height */ void lui_object_set_area(lui_obj_t* obj, uint16_t width, uint16_t height); /** * @brief Set width of an object * * @param obj target object * @param width width */ void lui_object_set_width(lui_obj_t* obj, uint16_t width); /** * @brief Set height of an object * * @param obj target object * @param height height */ void lui_object_set_height(lui_obj_t* obj, uint16_t height); /** * @brief Get object's position relative to its parent * * @param obj target object * @param pos pos array of 2 items to return position ({x, y}) */ void lui_object_get_position_rel(lui_obj_t* obj, uint16_t pos[2]); /** * @brief Get object's absolute position on the screen * * @param obj target object * @param pos pos array of 2 items to return position ({x, y}) */ void lui_object_get_position_abs(lui_obj_t* obj, uint16_t pos[2]); /** * @brief Set position of an object. This is the relative position of the * object to its parent. * * @param obj target object * @param x x position (relative) * @param y y position (relative) */ void lui_object_set_position(lui_obj_t* obj, uint16_t x, uint16_t y); /** * @brief Set only x position of an object * * @param obj target object * @param x x position */ void lui_object_set_x_pos(lui_obj_t* obj, uint16_t x); /** * @brief Set only y position of an object * * @param obj target object * @param y y position */ void lui_object_set_y_pos(lui_obj_t* obj, uint16_t y); /** * @brief Set border color of an object * * @param obj target object * @param border_color border color */ void lui_object_set_border_color(lui_obj_t* obj, uint16_t border_color); /** * @brief Deprecated!! Use `lui_object_set_border_width()` instead * Set border's visibility of an object * * @param obj target object * @param is_visible 1: visible; 0: invisible */ void lui_object_set_border_visibility(lui_obj_t* obj, uint8_t is_visible) __attribute__ ((deprecated)); /** * @brief Set border's width or thickness. Set width to 0 to remove border * * @param obj target object * @param width width/thickness value. 0 means invisible */ void lui_object_set_border_width(lui_obj_t* obj, uint8_t width); /** * @brief Set background color of an object * * @param obj target object * @param bg_color background color */ void lui_object_set_bg_color(lui_obj_t* obj, uint16_t bg_color); /** * @brief Set event call back function for input handling * * This function is called when an event occurs against this object * * Example: * @code * lui_obj_t* my_button; * void button_callback(lui_obj_t* btn_obj) * { * // Do something * } * my_button = lui_button_create(); * lui_object_set_callback(my_button, button_callback); * @endcode * * @param obj target object * @param obj_event_cb function pointer of the callback function */ void lui_object_set_callback(lui_obj_t* obj, void (*obj_event_cb)(lui_obj_t* )); /** * @brief Get the input state of an object * * @param obj target object * @return int8_t state ID */ int8_t lui_object_get_state(lui_obj_t* obj); /** * @brief Get input event of an object * * @param obj target object * @return int8_t event ID */ int8_t lui_object_get_event(lui_obj_t* obj); /** * @brief Set visibility of an object * * @param obj target object * @param is_visible 1: visible; 0: hidden */ void lui_object_set_visibility(lui_obj_t* obj, uint8_t is_visible); /** * @brief Set rendering layer index of an object * * Objects in higher layer will be rendered over the objects in lower layer. * If 2 or more objects are in same layer, they're rendered based on the sequence * they're added to parent. * * @param obj target object * @param layer_index layer index (0 - 128) */ void lui_object_set_layer(lui_obj_t* obj, uint8_t layer_index); /** * @brief Get rendering layer index of an object * * @param obj target object * @return int16_t layer index. Returns -1 if object is NULL */ int16_t lui_object_get_layer(lui_obj_t* obj); /** * @brief Get the type of the object * * @param obj object * @return int16_t type of object. -1 if object is NULL */ int16_t lui_object_get_type(lui_obj_t* obj); /** * @brief Enable or disble input handling of an object. If disabled, * object won't cause input event callback * * @param obj target object * @param is_enabled 1: input enabled; 0: input disabled * @return uint8_t 1: success; 0: failed */ uint8_t lui_object_set_enable_input(lui_obj_t* obj, uint8_t is_enabled); /* Private functions (User must not call them) */ /** * @private * @brief Create a generic object with default values * * @return lui_obj_t* created object */ lui_obj_t* _lui_object_create(void); /** * @private * @brief Set needs_refresh flag for an object. This flag determines if onject will be redrawn * * When setting this flag for an object, flags of children and/or parent might also be set, * depending on the requirement. * * @param obj target object */ void _lui_object_set_need_refresh(lui_obj_t* obj); /** * @private * @brief Render an object along with all its children (if any) * * @param obj target object */ void _lui_object_render_parent_with_children(lui_obj_t* obj); /** * @private * @brief Render a single object (and NOT its children) * * @param obj target object */ void _lui_object_render(lui_obj_t* obj); /** * @private * @brief Compares two objects' layers and returns (layer1 - layer2) * * @param p1 pointer to object 1 * @param p2 pointer to object 2 * @return int (layer1 - layer2) */ int _lui_obj_layer_cmprtr(const void *p1, const void *p2); /* Private functions end */ /**@}*/ /*------------------------------------------------------------------------------- * END *------------------------------------------------------------------------------- */ /*------------------------------------------------------------------------------- * LUI_LABEL related functions *------------------------------------------------------------------------------- */ /** * @defgroup lui_label Label widget API * @brief API for label widgets * * @section label_example Example * @image html docs/widgets_images/label.png "Dark Theme" * @image html docs/widgets_images/label_2.png "Light Theme" * @code * const char* text = "Hi Universe"; * lui_obj_t* my_label = lui_label_create(); * lui_label_set_text(my_label, "Hello World"); * lui_label_set_text_color(my_label, lui_rgb(255, 20, 80)); // Setting text color * lui_object_set_bg_color(my_label, lui_rgb(10, 10, 10)); // Setting background color * * lui_obj_t* my_label2 = lui_label_create_and_add(parent_panel); // Creating and adding to a parent * lui_label_set_text(my_label2, text); * lui_label_set_font(my_label2, &FONT_montserrat_32); * lui_object_set_position(my_label2, 0, 30); * @endcode * @{ */ /** * @brief Create a label with initial values * * @return lui_obj_t* Created label object */ lui_obj_t* lui_label_create(void); /** * @brief Create a label with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created label object */ lui_obj_t* lui_label_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw a label widget * * @param obj_lbl label object */ void lui_label_draw(lui_obj_t* obj_lbl); /** * @brief Set font of a label. * * @param obj_lbl label object * @param font font object. If NULL is passed, default font will be used */ void lui_label_set_font(lui_obj_t* obj_lbl, const lui_font_t* font); /** * @brief Set text of a label * * @param obj_lbl label object * @param text char array of text */ void lui_label_set_text(lui_obj_t* obj_lbl, const char* text); /** * @brief Set forecolor of a label. * @note this only changes text color and NOT background color * * @param obj_lbl label object * @param text_color 16-bit color */ void lui_label_set_text_color(lui_obj_t* obj_lbl, uint16_t text_color); /** * @brief Set whether the label background is transparent or not. * When background is set to transparent, parent's background color * or bitmap is used as background to simulate transparency. * * @param obj label object * @param is_transparent 0: NOT transparent, 1: Transparent */ void lui_label_set_bg_transparent(lui_obj_t* obj, uint8_t is_transparent); /**@}*/ /*------------------------------------------------------------------------------- * END *------------------------------------------------------------------------------- */ /*------------------------------------------------------------------------------- * LUI_LINECHART related functions *------------------------------------------------------------------------------- */ #if defined(LUI_USE_LINECHART) /** * @defgroup lui_linechart Line Chart widget API * @brief API for linechart widget * * @section linechart_example Example * @image html docs/widgets_images/linechart.png "Dark Theme" * @image html docs/widgets_images/linechart_2.png "Light Theme" * @code * double fib_data[40] = {0,0, 1,1, 2,1, 3,2, 4,3, 5,5, 6,8, 7,13, 8,21, 9,34}; * lui_obj_t* my_chart = lui_linechart_create(); * lui_linechart_set_data_source(my_chart, fib_data, 10); * lui_linechart_set_grid_count(my_chart, 4, 2); * lui_linechart_set_line_color(my_chart, lui_rgb(255, 0, 0)); * // Setting line chart's area is important! * lui_object_set_area(my_chart, 120, 80); * @endcode * @{ */ /** * @brief Create a linechart with initial values * * @return lui_obj_t* Created linechart object */ lui_obj_t* lui_linechart_create(void); /** * @brief Create a linechart with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created linechart object */ lui_obj_t* lui_linechart_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw a linechart * * @param obj_linechart linechart object */ void lui_linechart_draw(lui_obj_t* obj_linechart); /** * @brief Set number of horizontal and vertical grid lines in a linechart * * @param obj_linechart linechart object * @param hor_lines number of horizontal grid lines * @param vert_lines number of vertical grid lines */ void lui_linechart_set_grid_count(lui_obj_t* obj_linechart, uint16_t hor_lines, uint16_t vert_lines); /** * @brief Set color of grid lines * * @param obj_linechart linechart object * @param color 16-bit color */ void lui_linechart_set_grid_color(lui_obj_t* obj_linechart, uint16_t color); /** * @brief Set visibility of grid lines * * @param obj_linechart linechart object * @param state 0: hidden, 1: visible (default) */ void lui_linechart_set_grid_visible(lui_obj_t* obj_linechart, uint8_t state); /** * @brief Set color of plot line * * @param obj_linechart linechart object * @param line_color 16-bit color */ void lui_linechart_set_line_color(lui_obj_t* obj_linechart, uint16_t line_color); /** * @brief Set width of plot line * * @param obj_linechart linechart object * @param line_width width of line */ void lui_linechart_set_line_width(lui_obj_t* obj_linechart, uint8_t line_width); /** * @brief Set color of points/markers of the plot * * @param obj_linechart linechart object * @param point_color 16-bit color */ void lui_linechart_set_point_color(lui_obj_t* obj_linechart, uint16_t point_color); /** * @brief Set width of points/markers of plot * * @param obj_linechart linechart object * @param point_width width of points/markers */ void lui_linechart_set_point_width(lui_obj_t* obj_linechart, uint8_t point_width); /** * @brief Set draw mode of line chart's plot line * Sets whether to draw line segments, or only the points/markers, or both. * * flags: * LUI_LINECHART_DRAW_MODE_LINE -> draw line segments by connecting points * LUI_LINECHART_DRAW_MODE_POINT -> draw points/markers * * Flags can be ORed to enable both of them. * * @param obj_linechart linechart object * @param mode_flag ORed drawmode flags. */ void lui_linechart_set_draw_mode(lui_obj_t* obj_linechart, uint8_t mode_flag); /** * @brief Set whether to apply automatic scaling on the data source or not. * If auto scale is enabled, graph will always be in the boundary of drawing area. * If auto scale is disabled, user must provide manual range * @param obj_linechart linechart object * @param auto_scale 1: enabled (default), 0: disabled */ void lui_linechart_set_data_auto_scale(lui_obj_t* obj_linechart, uint8_t auto_scale); /** * @brief Set data range of line chart when auto scaling is disabled * * @param obj_linechart linechart object * @param y_min minimum value of y axis data * @param y_max maximum value of y axis data */ void lui_linechart_set_data_range(lui_obj_t* obj_linechart, double y_min, double y_max); /** * @brief Set data source of the line chart * * Data source contains both x and y data. Odd index: X, Even index: 1. That * means, data source array looks like: {x0, y0, x1, y1, ..., xn, yn} * * @param obj_linechart linechart object * @param source array of data points (in x,y format) * @param points number of data points */ void lui_linechart_set_data_source(lui_obj_t* obj_linechart, double* source, uint16_t points); /**@}*/ #endif /*------------------------------------------------------------------------------- * END *------------------------------------------------------------------------------- */ /** * @defgroup lui_button Button widget API * * @brief API for button widget * * Buttons have 3 important visual properties: * 1. Background color (bg color) * 2. Bitmap image * 3. Text * * Each of them can be configured for both pressed state and idle state. * * Rendering order is: 1.bg color -> 2.bitmap -> 3.text. * * If button is set as transparent bg, then bg color is not rendered, rather parent's * bg color or bitmap ius rendered as the step 1. * * @section button_example1 Example * @image html docs/widgets_images/button.png "Dark Theme" * @image html docs/widgets_images/button_2.png "Light Theme" * @code * void button_callback(lui_obj_t* btn_obj) * { * static uint8_t light_state = 0; * // Only turn on/off light when button is pressed. For any other event, return. * if (lui_object_get_event(btn_obj) != LUI_EVENT_PRESSED) * return; * light_state = !light_state; * if (light_state) * { * lui_button_set_label_text(my_button, "Turn OFF Light"); * // turn_on_light(); * } * else * { * lui_button_set_label_text(my_button, "Turn ON Light"); * // turn_off_light(); * } * * // Do more stuffs... * } * lui_obj_t* my_button = lui_button_create(); * lui_button_set_label_text(my_button, "Turn ON Light"); * // Optionally set button area and position * lui_object_set_area(my_button, 140, 60); * lui_object_set_position(my_button, 20, 10); * // set button call back function * lui_object_set_callback(my_button, button_callback); * @endcode * * @section button_example2 Example of checkable button * This code creates a button and sets it as checkable. Also, this button changes its * text and color when pressed. * @code * lui_obj_t* check_btn = lui_button_create(); * * // Set is as checkable * lui_button_set_checkable(check_btn, 1); * // This label text is for both idle and pressed state * lui_button_set_label_text(check_btn, "Turn ON Light"); * // Green text fo idle (normal) state * lui_button_set_label_color(check_btn, lui_rgb(0, 255, 0)); * // This label text is for pressed state * lui_button_set_label_text_pressed(check_btn, "Turn OFF Light"); * // Red text when pressed state * lui_button_set_label_color(check_btn, lui_rgb(255, 0, 0)); * * // Optionally set button area and position * lui_object_set_area(check_btn, 140, 60); * lui_object_set_position(check_btn, 20, 10); * @endcode * * @section button_example3 Example of setting background image * Example of setting a background bitmap image for button * @code * #include "warning_symbol.h" // include the image bitmap * lui_obj_t* img_btn = lui_button_create(); * // Set area and position of button. * lui_object_set_area(img_btn, 140, 60); * lui_object_set_position(img_btn, 20, 10); * // Now set the bitmap image as background. * // WE are only setting bitmap for button idle state. No extra bitmap is set for pressed state (NULL passed) * lui_button_set_bitmap_images(img_btn, &BITMAP_warning_symbol, NULL); * // NOTE: if we need to set a different bitmap for pressed state too, do this: * // lui_button_set_bitmap_images(img_btn, &BITMAP_idle, &BITMAP_pressed); * @endcode * * @section button_example4 Example of setting 1-bpp mono background image * Example of setting a 1-bpp background bitmap image for button. When we set 1-bpp images, * we should call another function `lui_button_set_bitmap_images_mono_palette()` to set * rendering colors of bitmaps too. * * The following code creates a square shaped button and sets it as checkable. Then * sets play symbol bitmap for idle state and pause symbol bitmap for pressed state. * These bitmaps are 1-bpp. * * Play button's color set to red(ish) and pause button;s color set to green(ish). * background color for both bitmaps are ignored due to `is_bg` flag is set to 0. * * @code * #include "play_symbol.h" // 1-bpp mono bitmap * #include "pause_symbol.h" // 1-bpp mono bitmap * lui_obj_t* img_btn = lui_button_create(); * // Make it checkable since it's a play/pause button * lui_button_set_checkable(img_btn, 1); * // Set area * lui_object_set_area(img_btn, 80, 80); * // Now set 1-bpp mono bitmap images for idle and pressed states * lui_button_set_bitmap_images(img_btn, &BITMAP_play_symbol, &BITMAP_pause_symbol); * // Prepare rendering color palettes of both 'idle' and 'pressed' state images * lui_bitmap_mono_pal_t idle_palette = { * .fore_color = lui_rgb(255, 10, 10), * .back_color = 0, * .is_backgrnd = 0 // don't want to draw background (sets transparent background) * }; * lui_bitmap_mono_pal_t pressed_palette = { * .fore_color = lui_rgb(5, 250, 10), * .back_color = 0, * .is_backgrnd = 0 // don't want to draw background (sets transparent background) * }; * // Now set those palettes * lui_button_set_bitmap_images_mono_palette(img_btn, &idle_palette, &pressed_palette); * @endcode * * @{ */ /** * @brief Create a button with initial values * * @return lui_obj_t* created button object */ lui_obj_t* lui_button_create(void); /** * @brief Create a button with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created button object */ lui_obj_t* lui_button_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw a button object * * @param obj_btn button object */ void lui_button_draw(lui_obj_t* obj_btn); /** * @brief Set the text of the button's label. * * Same text is set for idle (normal) state and pressed state. * * @param obj_btn button object * @param text char array of text */ void lui_button_set_label_text(lui_obj_t* obj_btn, const char* text); /** * @brief Set text of button's label only for the pressed state * * @param obj_btn button object * @param pressed_text text for pressed state */ void lui_button_set_label_text_pressed(lui_obj_t* obj_btn, const char* pressed_text); /** * @brief Set different label texts for idle and pressed states. * * Calling this function is same as first calling `lui_button_set_label_text()` * and then `lui_button_set_label_text_pressed()`. * * @param obj_btn button object * @param idle_text label text when button is idle * @param pressed_text label text when button is pressed */ void lui_button_set_label_texts(lui_obj_t* obj_btn, const char* idle_text, const char* pressed_text); /** * @brief Set alignment of the label text. See: @ref LUI_ALIGNMENT * * @param obj_btn button object * @param alignment Alignment flags. Allowed values: `LUI_ALIGN_LEFT`, `LUI_ALIGN_CENTER`, `LUI_ALIGN_RIGHT` */ void lui_button_set_label_align(lui_obj_t* obj_btn, uint8_t alignment); /** * @brief Set text color of button's label. * * Same color is set for idle (normal) state and pressed state. * * @param obj_btn button object * @param color 16-bit text color */ void lui_button_set_label_color(lui_obj_t* obj_btn, uint16_t color); /** * @brief Set text color of button's label only for the pressed state * * @param obj_btn button object * @param pressed_color 16-bit text color */ void lui_button_set_label_color_pressed(lui_obj_t* obj_btn, uint16_t pressed_color); /** * @brief Set different label text-colors for idle and pressed states. * * Calling this function is same as first calling `lui_button_set_label_color()` * and then `lui_button_set_label_color_pressed()`. * * @param obj_btn button object * @param idle_color text color for idle state * @param pressed_color text color for pressed state */ void lui_button_set_label_colors(lui_obj_t* obj_btn, uint16_t idle_color, uint16_t pressed_color); /** * @brief Set font of button's label * * @param obj_btn button object * @param font font object. If NULL is passed, default font will be used */ void lui_button_set_label_font(lui_obj_t* obj_btn, const lui_font_t* font); /** * @brief Set background bitmap image for idle (normal) and pressed states of button. * * Images are rendered after rendering bg color. If button is set as transparent, then * button's bg color is not rendered nut images are rendered. * * NOTE: Only if the image is 1-bpp monochrome, call `lui_button_set_bitmap_images_mono_palette()` * too to set colors of the bitmap. Else, default color will be used to render 1-bpp bitmaps. * * @param obj_btn button object * @param bitmap bitmap image object when button is idle (normal situation). Can be NULL */ void lui_button_set_bitmap_images(lui_obj_t* obj_btn, const lui_bitmap_t* idle_bitmap, const lui_bitmap_t* pressed_bitmap); /** * @brief Set color palette for 1-bpp mono bitmap images. Has no effect if images are not 1-bpp. * * When idle and/or pressed bitmap image is/are 1-bpp mono, this function sets rendering * colors. Has no effect for 8-bpp grayscale and 16-bpp rgb565 bitmaps. * * Set `idle_palette->is_backgrnd` and/or `press_palette->is_backgrnd` to 0 for only drawing the foreground and no background. * This enables transparent background. `idle_palette->back_color` and/or `press_palette->back_color` is/are ignored in this case. * * @param obj_btn button object * @param idle_palette color palette for button idle state image * @param press_palette color palette for button pressed state image */ void lui_button_set_bitmap_images_mono_palette( lui_obj_t* obj_btn, lui_bitmap_mono_pal_t* idle_palette, lui_bitmap_mono_pal_t* press_palette); /** * @brief Set check value of button. Works only if button is set as checkable * * @param obj_btn button object * @param value 0: Not checked, 1: Checked */ void lui_button_set_value(lui_obj_t* obj_btn, uint8_t value); /** * @brief Set button as checked. Only works for checkable button * * @param obj_btn button object */ void lui_button_set_checked(lui_obj_t* obj_btn); /** * @brief Set button as unchecked. Only works for checkable button * * @param obj_btn button object */ void lui_button_set_unchecked(lui_obj_t* obj_btn); /** * @brief Set a button as checkable or not. Checkable buttons can be toggled. * * @param obj_btn button object * @param is_checkable 0: NOT checkable, 1: Checkable */ void lui_button_set_checkable(lui_obj_t* obj_btn, uint8_t is_checkable); /** * @brief Get checkable property of a button * * @param obj_btn button object * @return uint8_t Returns 0 or 1. 0: NOT checkable, 1: Checkable */ uint8_t lui_button_get_checkable(lui_obj_t* obj_btn); /** * @brief Get the check value (status) of a checkable button. * * A checkable button fires LUI_EVENET_VALUE CHANGED event on click. Call this * function to get the current check value of a checkable button. * * If a button is not set to checkable using lui_button_set_checkable(), it will * return 0 always. * * @param obj_btn button object * @return uint8_t Returns 0 or 1. 0: Unchecked, 1: Checked */ uint8_t lui_button_get_check_value(lui_obj_t* obj_btn); /** * @brief Set other colors of button object * * @param obj_btn button object * @param pressed_color 16-bit color of button when it's pressed * @param selection_color 16-bit color of button when it's selected (hovering) */ void lui_button_set_extra_colors(lui_obj_t* obj_btn, uint16_t pressed_color, uint16_t selection_color); /** * @brief Set background of the button as transparent. * * When background is transparent, button's own bg color is not drawn. * Rather, the color or bitmap of the parent item is drawn as background to * simulate transparency. * * @param obj_btn button object * @param is_transparent 0: Transparent background, 1: NOT transparent background */ void lui_button_set_bg_transparent(lui_obj_t* obj_btn, uint8_t is_transparent); /**@}*/ #if defined(LUI_USE_SWITCH) /** * @defgroup lui_switch Switch widget API * * @brief API for switch widget * * @section switch_example Example * @image html docs/widgets_images/switch.png "Dark Theme" * @image html docs/widgets_images/switch_2.png "Light Theme" * @code * void switch_callback(lui_obj_t* switch_obj) * { * if (lui_object_get_event(switch_obj) != LUI_EVENT_VALUE_CHANGED) * return; * int8_t value = lui_switch_get_value(switch_obj); * if (value == 0) * { * // Switch is turned off. Do something now. * } * else if (value == 1) * { * // Switch is turned on. Do something now. * } * } * lui_obj_t* my_switch = lui_switch_create(); * // Let's keep the switch ON by default * lui_switch_set_on(my_switch); * lui_object_set_position(my_switch, 10, 10); * // Set a callback function to do stuffs when switch is toggled * lui_object_set_callback(my_switch, switch_callback) * * lui_obj_t* my_switch2 = lui_switch_create(); * lui_object_set_position(my_switch2, 140, 10); * @endcode * @{ */ /** * @brief Create a switch with initial values * * @return lui_obj_t* created switch object */ lui_obj_t* lui_switch_create(void); /** * @brief Create a switch with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created switch object */ lui_obj_t* lui_switch_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw a switch object * * @param obj_swtch switch object */ void lui_switch_draw(lui_obj_t* obj_swtch); /** * @brief Set extra colors of switch object * * @param obj_swtch switch object * @param knob_off_color 16-bit color of knob when switch is off * @param knob_on_color 16-bit color of knob when switch is on * @param selection_color 16-bit color when switch is selected */ void lui_switch_set_extra_colors(lui_obj_t* obj_swtch, uint16_t knob_off_color, uint16_t knob_on_color, uint16_t selection_color); /** * @brief Get value of a switch * * @param obj_swtch switch object * @return int8_t value of switch. 0: Off, 1: On, -1: Error. */ int8_t lui_switch_get_value(lui_obj_t* obj_swtch); /** * @brief Set value of switch * * @param obj_swtch switch object * @param value 1: switch on, 0: switch off */ void lui_switch_set_value(lui_obj_t* obj_swtch, uint8_t value); /** * @brief Set switch to ON (value: 1) * * @param obj_swtch switch object */ void lui_switch_set_on(lui_obj_t* obj_swtch); /** * @brief Set switch to OFF (value: 0) * * @param obj_swtch switch object */ void lui_switch_set_off(lui_obj_t* obj_swtch); /**@}*/ #endif #if defined(LUI_USE_CHECKBOX) /** * @defgroup lui_checkbox Checkbox widget API * * @brief API for checkbox widget * * @section checkbox_example Example * @image html docs/widgets_images/checkbox.png "Dark Theme" * @image html docs/widgets_images/checkbox_2.png "Light Theme" * @code * lui_obj_t* chkbox_cricket = lui_checkbox_create(); * lui_checkbox_set_label_text(chkbox_cricket, "Cricket"); * lui_object_set_position(chkbox_cricket, 0, 0); * lui_checkbox_set_value(chkbox_cricket, 1); // This checkbox is selected * * lui_obj_t* chkbox_hockey = lui_checkbox_create(); * lui_checkbox_set_label_text(chkbox_hockey, "Hockey"); * lui_object_set_position(chkbox_hockey, 0, 25); * * lui_obj_t* chkbox_football = lui_checkbox_create(); * lui_checkbox_set_label_text(chkbox_football, "Football"); * lui_object_set_position(chkbox_football, 0, 50); * @endcode * @{ */ /** * @brief Create a checkbox object with initial values * * @return lui_obj_t* */ lui_obj_t* lui_checkbox_create(void); /** * @brief Create a checkbox with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created checkbox object */ lui_obj_t* lui_checkbox_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw a checkbox object * * @param obj_checkbox checkbox object */ void lui_checkbox_draw(lui_obj_t* obj_checkbox); /** * @brief Set label text of a checkbox * * @param obj_checkbox checkbox object * @param text text */ void lui_checkbox_set_label_text(lui_obj_t* obj_checkbox, const char* text); /** * @brief Set label font of a checkbox * * @param obj_checkbox checkbox object * @param font font */ void lui_checkbox_set_label_font(lui_obj_t* obj_checkbox, const lui_font_t* font); /** * @brief Set label text color of a checkbox * * @param obj_checkbox checkbox object * @param color 16-bit color */ void lui_checkbox_set_label_color(lui_obj_t* obj_checkbox, uint16_t color); /** * @brief Set extra colors of checkbox * * @param obj_checkbox checkbox object * @param bg_checked_color 16-bit background color of checkbox when in checked status * @param tick_color 16-bit color of the check mark (tick) * @param selection_color 16-bit color of checkbox when it is selected (hovered) */ void lui_checkbox_set_extra_colors(lui_obj_t* obj_checkbox, uint16_t bg_checked_color, uint16_t tick_color, uint16_t selection_color); /** * @brief Get value of checkbox * * @param obj_checkbox checkbox object * @return int8_t Value of checkbox. 0: Unchecked, 1: Checked, -1: Error */ int8_t lui_checkbox_get_value(lui_obj_t* obj_checkbox); /** * @brief Set checkbox value * * @param obj_checkbox checkbox object * @param value 0: Unchecked, 1: Checked */ void lui_checkbox_set_value(lui_obj_t* obj_checkbox, uint8_t value); /** * @brief Set checkbox status to Checked (value: 1) * * @param obj_checkbox checkbox object */ void lui_checkbox_set_checked(lui_obj_t* obj_checkbox); /** * @brief Set checkbox status to Unchecked (value: 0) * * @param obj_checkbox checkbox object */ void lui_checkbox_set_unchecked(lui_obj_t* obj_checkbox); /**@}*/ #endif #if defined(LUI_USE_SLIDER) /** * @defgroup lui_slider Slider widget API * * @brief API for slider widget * * Sliders can have 3 types of knob: None, Default, Text. * - `LUI_SLIDER_KNOB_TYPE_NONE`: No knob is rendered. * - `LUI_SLIDER_KNOB_TYPE_DEFAULT`: A rectangular knob. * - `LUI_SLIDER_KNOB_TYPE_TEXT`: Text will be rendered in place of knob. This * text can be value of progress bar, custom text, or both. * * Sliders can also act as progress bars. Set the progress bar mode using * `lui_slider_set_progress_bar()` function. When slider is set as a progress * bar, knob type automatically becomes Text(`LUI_SLIDER_KNOB_TYPE_TEXT`). * * Whether to show slider/progress bar value, can be set using `lui_slider_set_show_value()` * function. Custom text can be shown using `lui_slider_set_text()`. * * @section slider_example1 Example Slider * Example of sliders with different knob configuration * @image html docs/widgets_images/slider.png "Dark Theme" * @image html docs/widgets_images/slider_2.png "Light Theme" * @code * void slider_event_handler_cb(lui_obj_t* obj) * { * if (lui_object_get_event(obj) == LUI_EVENT_VALUE_CHANGED) * { * int16_t val = lui_slider_get_value(obj); * // Do something with this value.. * } * } * * // Create a slider object with default knob * slider_led_brightness = lui_slider_create(); * // Setting slider's area is important * lui_object_set_area(slider_led_brightness, 160, 20); * lui_object_set_position(slider_led_brightness, 0, 5); * // Set range of slider 0-255 * lui_slider_set_range(slider_led_brightness, 0, 255); * // Set default value of slider * lui_slider_set_value(slider_led_brightness, 50); * // Set callback function * lui_object_set_callback(slider_led_brightness, slider_event_handler_cb); * * // Create a slider with text knob * slider_2 = lui_slider_create(); * lui_object_set_area(slider_2, 160, 20); * lui_object_set_position(slider_2, 0, 50); * lui_slider_set_range(slider_2, 0, 100); * lui_slider_set_value(slider_2, 69); * // Set knob type as text * lui_slider_set_knob_type(slider_2, LUI_SLIDER_KNOB_TYPE_TEXT); * // We'll show slider's value on the knob, and also some custom text * lui_slider_set_show_value(slider_2, 1); * lui_slider_set_text(slider_2, " %"); * @endcode * * @section slider_example2 Example Progress Bar * Example of slider as progress bar * @image html docs/widgets_images/progress_bar.png "Dark Theme" * @image html docs/widgets_images/progress_bar_2.png "Light Theme" * @code * // Create a slider * progress_bar = lui_slider_create(); * lui_object_set_area(progress_bar, 160, 40); * lui_object_set_position(progress_bar, 10, 20); * lui_slider_set_range(progress_bar, 0, 100); * lui_slider_set_value(progress_bar, 85); * // Set as progress bar * lui_slider_set_progress_bar(progress_bar, 1); * // We'll also show some custom text inside progress bar * lui_slider_set_text(progress_bar, " %"); * * // What if we only want to show custom text and no value? * // lui_slider_set_show_value(progress_bar, 0); * @endcode * * @{ */ /** * @brief Create a slider object with initial values * * @return lui_obj_t* created slider object */ lui_obj_t* lui_slider_create(void); /** * @brief Create a slider with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created slider object */ lui_obj_t* lui_slider_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw slider object * * @param obj_slider slider object */ void lui_slider_draw(lui_obj_t* obj_slider); /** * @brief Set extra colors of slider * * @param obj_slider slider object * @param knob_color 16-bit color of slider knob * @param bg_filled_color 16-bit background color of the filled section of slider * @param selection_color 16-bit color of slider when it's selected (hovered) */ void lui_slider_set_extra_colors(lui_obj_t* obj_slider, uint16_t knob_color, uint16_t bg_filled_color, uint16_t selection_color); /** * @brief Set value of slider * * @param obj_slider slider object * @param value value of slider */ void lui_slider_set_value(lui_obj_t* obj_slider, int16_t value); /** * @brief Set whether to show value on the slider or not. * * When using as progress bar, this is very helpful. * * @param obj_slider slider object * @param show_val 0: Do NOT show value, 1: Show value */ void lui_slider_set_show_value(lui_obj_t* obj_slider, uint8_t show_val); /** * @brief Set minimum and maximum values of slider * * @param obj_slider slider object * @param range_min minimum value of slider * @param range_max maximum value of slider */ void lui_slider_set_range(lui_obj_t* obj_slider, int16_t range_min, int16_t range_max); /** * @brief Get value of slider * * @param obj_slider slider object * @return int16_t value of slider */ int16_t lui_slider_get_value(lui_obj_t* obj_slider); /** * @brief Get minimum value of slider's range * * @param obj_slider slider object * @return int16_t minimum value of slider */ int16_t lui_slider_get_min_value(lui_obj_t* obj_slider); /** * @brief Get maximum value of slider's range * * @param obj_slider slider object * @return int16_t maximum value of slider */ int16_t lui_slider_get_max_value(lui_obj_t* obj_slider); /** * @brief Set custom text to be rendered on the slider. * * @param obj_slider slider object * @param custom_text custom text */ void lui_slider_set_text(lui_obj_t* obj_slider, const char* custom_text); /** * @brief Configure the slider as a progress bar. * * When a slider becomes progress bar, it does not take touch input. Value of * the slider is rendered in the center, followed by the custom text (if any). * * @param obj_slider slider object * @param is_progress_bar 1: Set as Progress Bar, 0: Set as normal slider */ void lui_slider_set_progress_bar(lui_obj_t* obj_slider, uint8_t is_progress_bar); /** * @brief Set font of the slider * * @param obj_slider slider object * @param font font */ void lui_slider_set_font(lui_obj_t* obj_slider, const lui_font_t* font); /** * @brief Set knob type of the slider. See @ref LUI_SLIDER_KNOB_TYPE. * * @param obj_slider slider object * @param knob_type Allowed values: `LUI_SLIDER_KNOB_TYPE_NONE`, `LUI_SLIDER_KNOB_TYPE_DEFAULT`, * `LUI_SLIDER_KNOB_TYPE_TEXT`, * @return int8_t 0: Success, -1: Fail */ int8_t lui_slider_set_knob_type(lui_obj_t* obj_slider, uint8_t knob_type); /**@}*/ #endif #if defined(LUI_USE_LIST) /** * @defgroup lui_list List widget API * * @brief API for list widget * * list is a collection of items. List can be dropdown or static. A * dropdown list can be expanded/contracted while a static list cannot be. * * Some important points about list: * 1. Number of maximum items must be set by calling `lui_list_set_max_items_count()` * function before items can be added. * 2. Maximum items count cannot be changed anymore once set. LameUI does NOT * support memory reallocation. * 3. After changes are made to a list like changing area/position, addition/removal * of items etc., `lui_list_prepare()` must be called to prepare the list. * * @section list_example Example * @image html docs/widgets_images/list.png "Dark Theme" * @image html docs/widgets_images/list_2.png "Light Theme" * @code * void my_list_callback(lui_obj_t* list_obj) * { * uint8_t event = lui_object_get_event(list_obj); * if (event == LUI_EVENT_PRESSED) * { * int index = lui_list_get_selected_item_index(list_obj); * char* txt = lui_list_get_item_text(list_obj, index); * * // We got both index and text of selected item. * // Now do something with that information. * } * } * * lui_obj_t* my_list = lui_list_create(); * * // Setting list area is important. Else items won't be properly rendered * lui_object_set_area(my_list, 110, 160); * lui_object_set_position(my_list, 50, 5); * * // Setting max items count is must. Otherwise we can't add items. * // Note: This is a one-time process. Max items count cannot be changed later * lui_list_set_max_items_count(my_list, 20); * * // Now, let's add some items. We can not add more than 20 items * lui_list_add_item(my_list, "--Select--"); * lui_list_add_item(my_list, "Algerian"); * lui_list_add_item(my_list, "Amharic "); * lui_list_add_item(my_list, "Assamese"); * lui_list_add_item(my_list, "Bavarian"); * lui_list_add_item(my_list, "Bengali"); * lui_list_add_item(my_list, "Czech"); * lui_list_add_item(my_list, "Deccan"); * lui_list_add_item(my_list, "Dutch"); * lui_list_add_item(my_list, "English"); * lui_list_add_item(my_list, "French"); * lui_list_add_item(my_list, "German"); * lui_list_add_item(my_list, "Hindi"); * * // Now make this list a dropdown list * lui_list_set_dropdown_mode(my_list, 1); * * // Change the selected item to 6th (index = 5) * lui_list_set_selected_item_index(my_list, 5); * * // Set a callback function * lui_object_set_callback(my_list, my_list_callback); * * // IMPORTANT! After everything is done, we must prepare the list. * // Else nothing will work * lui_list_prepare(my_list); * @endcode * @{ */ /** * @brief Create a list object with initial values * * @return lui_obj_t* created list object */ lui_obj_t* lui_list_create(void); /** * @brief Create a list with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created list object */ lui_obj_t* lui_list_create_and_add(lui_obj_t* obj_parent); /** * @brief Set maximum item count for a list. The list cannot store items more * than this number. * * This function must be called once before adding items to the list. * Trying to add items before setting max items count will fail. * Once max items count is set, it can not be changed anymore. Calling * this function again will fail and return -1. * * @param obj list object * @param max_items_cnt maximum items count * @return int8_t error code. 0: Success, -1: Fail */ int8_t lui_list_set_max_items_count(lui_obj_t* obj, uint8_t max_items_cnt); /** * @brief Draw list object * * @param obj_list list object */ void lui_list_draw(lui_obj_t* obj_list); /** * @brief Add an item to the end of the list. * * Fails if added items exceeds `max items count` set by `lui_list_set_max_items_count()` * function * * @param obj_list list object * @param text item text * @return int8_t error code. 0: Success, -1: Fail */ int8_t lui_list_add_item(lui_obj_t* obj_list, const char* text); /** * @brief Remove an item from list at a specific index * * @param obj list object * @param item_index item index * @return int8_t error code. 0: Success, -1: Fail */ int8_t lui_list_remove_item(lui_obj_t* obj, uint8_t item_index); /** * @brief Remove all items from a list * * @param obj list object * @return int8_t error code. 0: Success, -1: Fail */ int8_t lui_list_remove_all(lui_obj_t* obj); /** * @brief Get index of selected item of a list * * @param obj list object * @return int16_t item index. -1 if failed. */ int16_t lui_list_get_selected_item_index(lui_obj_t* obj); /** * @brief Set selected item's index in a list * * @param obj list object * @param item_index item index * @return int16_t 0: Success, -1: Fail */ int16_t lui_list_set_selected_item_index(lui_obj_t* obj, uint8_t item_index); /** * @brief Get text of a list item by its index * * @param obj list object * @param item_index item index * @return char* text */ const char* lui_list_get_item_text(lui_obj_t* obj, uint8_t item_index); /** * @brief Set text of a list item by its index * * @param obj list object * @param text item text * @param item_index item index * @return int8_t 0: Success, -1:Fail */ int8_t lui_list_set_item_text(lui_obj_t* obj, const char* text, uint8_t item_index); /** * @brief Set if list is a dropdown or not. * * When list is dropdown, it can be expanded/contracted by a button. When a list * is not a dropdown, it is always expanded. * * @param obj list object * @param is_dropdown 0: NOT dropdown, 1: Dropdown * @return int8_t 0:Success, -1: Fail */ int8_t lui_list_set_dropdown_mode(lui_obj_t* obj, uint8_t is_dropdown); /** * @brief Expand a dropdown list manually. Works only if list mode is set as * dropdown. Otherwise, has no effect. * * @param obj list object * @param is_expanded 0: NOT expanded, 1: Expanded * @return int8_t 0: Success, -1: Fail */ int8_t lui_list_set_dropdown_expand(lui_obj_t* obj, uint8_t is_expanded); /** * @brief Prepares a list for final render. This function must be called by * the user after creating a list/making changes in a list. Else, those * changes won't be reflected. * * @param obj_list list object */ void lui_list_prepare(lui_obj_t* obj_list); /** * @brief Sets minimum height of each item in a list * * @param obj_list list object * @param height minimum height of an item */ void lui_list_set_item_min_height(lui_obj_t* obj_list, uint8_t height); /** * @brief Set font of list. If none is set, default font is used * * @param obj_list list object * @param font font of list */ void lui_list_set_font(lui_obj_t* obj_list, const lui_font_t* font); /** * @brief Set alignment of texts in a list. * * If alignment is changed after the list is already prepared, call `list_prepare() * function again so new alignment is applied to all the items. * * @param obj_list list object * @param alignment Alignment flag. Allowed values are: LUI_ALIGN_LEFT, LUI_ALIGN_CENTER, LUI_ALIGN_RIGHT */ void lui_list_set_text_align(lui_obj_t* obj_list, uint8_t alignment); /** * @brief Set text color of list items * * @param obj_list list object * @param color 16-bit color */ void lui_list_set_text_color(lui_obj_t* obj_list, uint16_t color); /** * @brief Set whether list items have border or not * * @param obj_list list object * @param has_border 0: Items have NO border, 1: Items have border * @param border_color 16-bit border color */ void lui_list_set_item_border(lui_obj_t* obj_list, uint8_t has_border, uint16_t border_color); /** * @brief Sets label text color of navigation buttons of a list. Navigation buttons * are used to change current page of list * * @param obj_list list object * @param color 16-bit color */ void lui_list_set_nav_btn_label_color(lui_obj_t* obj_list, uint16_t color); /** * @brief Sets label background color of navigation buttons of a list. Navigation buttons * are used to change current page of list * * @param obj_list list object * @param color 16-bit color */ void lui_list_set_nav_btn_bg_color(lui_obj_t* obj_list, uint16_t color); /** * @brief Sets extra colors of list * * @param obj_list list object * @param pressed_color 16-bit color of list item when pressed * @param selection_color 16-bit color of list item when selected (hovered) */ void lui_list_set_nav_btn_extra_colors(lui_obj_t* obj_list, uint16_t pressed_color, uint16_t selection_color); /** * @brief Sets current page index of a list. The current page is rendered. * Has no effect if index is out of bound. * * @param obj list object * @param index index of current page */ void lui_list_set_page_index(lui_obj_t* obj, uint8_t index); /** * @private * @brief Adds navigation buttons to list. Only called by the library. * * @param obj_list list object */ void _lui_list_add_nav_buttons(lui_obj_t* obj_list); /** * @private * @brief Sets callback function to handle nav button events. Only called by * the library. * * @param obj_list list object */ void _lui_list_nav_btn_cb(lui_obj_t* obj_list); /** * @private * @brief Adds actual button objects that are created during `lui_list_add_item()` call. * Only called by the library. * * @param obj_list list object * @param obj_btn button object, which is a list item */ void _lui_list_add_button_obj(lui_obj_t* obj_list, lui_obj_t* obj_btn); /**@}*/ #endif #if defined(LUI_USE_BUTTONGRID) /** * @defgroup lui_btngrid Buttongrid widget API * * @brief API for buttongrid widget * * buttongrid is a grid of buttons. It's way more effcient than adding * individual button objects to forma grid/matrix. For example, if we need 20 * buttons in a 5x4 grid, creating 20 individual button objects will take lots of * RAM. Rather using a 5x4 buttongrid will only create a single object and saves * RAM significantly. * * Practical examples of buttongrid are qwerty keyboards, numpads etc.. * * @section buttongrid_example1 Example 1 * Let's create a simple numpad using buttongrid. * @image html docs/widgets_images/btngrid_simple.png "Dark Theme" * @image html docs/widgets_images/btngrid_simple_2.png "Light Theme" * @code * lui_obj_t* numpad = lui_btngrid_create(); * // Setting buttongrid area is important. Else items won't be properly rendered * lui_object_set_area(numpad, 200, 200); * * // Text map of the numpad * const char* numpad_txt_map[] = * { * "7", "8", "9", "\n", * "4", "5", "6", "\n", * "1", "2", "3", "\n", * "0", "00", ".", "\n", * "+", "-", "=", "\0" * }; * * // Property map. Notice how the "=" button has twice the width of "+" and "-". * const uint8_t numpad_property_map[] = * { * 1, 1, 1, * 1, 1, 1, * 1, 1, 1, * 1, 1, 1, * 1, 1, 2 * }; * * lui_btngrid_set_textmap(numpad, numpad_txt_map); * lui_btngrid_set_propertymap(numpad, numpad_property_map); * * lui_btngrid_set_btn_margin(numpad, 5, 5); * @endcode * * @section buttongrid_example2 Example 2 * Let's create a simple control panel and use most of the features of buttongrid. * Also we'll see how to use callback for buttongrid. * @image html docs/widgets_images/btngrid_advanced.png "Dark Theme" * @image html docs/widgets_images/btngrid_advanced_2.png "Light Theme" * @code * void controlpanel_callback(lui_obj_t* ctrlpanel_btngrid) * { * // Get index of the pressed button * int active_btn_index = lui_btngrid_get_acive_btn_index(ctrlpanel_btngrid); * if (active_btn_index == -1) return; * // Get text of the button * const char* btn_txt = lui_btngrid_get_btn_text(ctrlpanel_btngrid, active_btn_index); * if (txt == NULL) return; * * // We can check which button is pressed either by its index or by its text. * // In this example we'll use text of the button. * * if (strcmp(txt, "Motor 1") == 0) * { * // Do something with motor 1 * } * else if (strcmp(txt, "Fan 1") == 0) * { * // Do something with fan 1 * } * else if (strcmp(txt, "Clr T1") == 0) * { * // This button is checkable. So, get its check status. * * int8_t clr_T1_status = lui_btngrid_get_btn_check_status(ctrlpanel_btngrid, active_btn_index); * if (clr_T1_status == 1) * { * // Checked, do something * } * else if (clr_T1_status == 0) * { * // Unchecked, do something else * } * else * { * // Error, return * return; * } * } * * //... Check other buttons too .... * } * * lui_obj_t* controlpanel = lui_btngrid_create(); * // Setting buttongrid area is important. Else items won't be properly rendered * lui_object_set_area(controlpanel, 640, 240); * * // Text map of the controlpanel * const char* controlpanel_txt_map[] = * { * "Motor 1", "Fan 1", "Heater L1", "Heater L2", "\n", * "Clr T1", "Clr T2","Ring A", "Ring B", "\n", * "X", "Y", "Z", "Stop", "\n", * "-", "+", "\0" * }; * * // Property map. 2 buttons are set checkable and 1 button is disabled * const uint8_t controlpanel_property_map[] = * { * 1, 1, 1, 1, * 1|LUI_BTNGRID_MASK_BTN_CHECKABLE, 1|LUI_BTNGRID_MASK_BTN_CHECKABLE, 1, 1, * 1, 1, 1, * 1, 1, 1, 3|LUI_BTNGRID_MASK_BTN_DISABLED, * 1, 1, 2 * }; * * lui_btngrid_set_textmap(controlpanel, controlpanel_txt_map); * lui_btngrid_set_propertymap(controlpanel,controlpanel_property_map); * * lui_btngrid_set_btn_margin(controlpanel, 2, 5); * lui_object_set_callback(controlpanel, controlpanel_callback); * * @endcode * @{ */ /** * @brief Create a buttongrid with initial values * * @return lui_obj_t* created buttongrid object */ lui_obj_t* lui_btngrid_create(void); /** * @brief Create a buttongrid with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created buttongrid object */ lui_obj_t* lui_btngrid_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw a buttongrid * * @param obj buttongrid object */ void lui_btngrid_draw(lui_obj_t* obj); /** * @brief Set texts of all buttons as a map. The grid is created based on this * text map. Each item in the array makes a column and `\n` (newline) cretaes * a row. The text map's last item must be a `\0`. This marks the end of the grid * * @param obj buttongrid object * @param texts array of strings to be used as text map. */ void lui_btngrid_set_textmap(lui_obj_t* obj, const char* texts[]); /** * @brief Set properties of all buttons as a map. * * Each item in the array is a 8-bit value denoting various properties of a * button of the buttongrid. The size of array must be same as the number of * buttons in the button grid.The structure of a property byte is as follows: * * | Bit | Meaning | Value | * |-----|----------------------|--------------------------------------------------| * | 7 | Is button checked? | 0: Unchecked,
1: Checked | * | 6 | Is button disabled? | 0: NOT disabled (i.e., Enabled),
1: Disabled | * | 5 | Is button hidden? | 0: NOT hidden (i.e., visible),
1: Hidden | * | 4 | Is button checkable? | 0: NOT checkable,
1: Checkable | * | 3:0 | Button width unit | 1-15,
Setting it to 0 has no effect | * * Example: To make a checkable button with 3 unit width and to set it to `checked` * status, property byte should be: (1 << 7) | (1 << 4) | 3 * * @param obj buttongrid object * @param properties array of property bytes */ void lui_btngrid_set_propertymap(lui_obj_t* obj, const uint8_t properties[]); /** * @brief Set property byte (8 bits) of a particular button in a buttongrid. * * Also see: @ref lui_btngrid_set_propertymap() * * @param obj buttongrid object * @param btn_index index of the button whose property is being set * @param property_byte 8-bit property value */ void lui_btngrid_set_btn_property_bits(lui_obj_t* obj, uint16_t btn_index, uint8_t property_byte); /** * @brief Set text of a particular button in a buttongrid. * * @param obj buttongrid object * @param btn_index index of the button whose text is being set * @param text text of the button */ void lui_btngrid_set_btn_text(lui_obj_t* obj, uint8_t btn_index, char* text); /** * @brief Get text of a particular button in a buttongrid * * @param obj buttongrid object * @param btn_index index of the button * @return const char* text of the button */ const char* lui_btngrid_get_btn_text(lui_obj_t* obj, uint16_t btn_index); /** * @brief Set the width unit of a particular button in a buttongrid * * @param obj buttongrid object * @param btn_index index of the button whose width unit is being set * @param width_unit width unit. Range is 1-15 */ void lui_btngrid_set_btn_width_unit(lui_obj_t* obj, uint16_t btn_index, uint8_t width_unit); /** * @brief Hide/unhide a particular button in the buttongrid * * @param obj buttongrid object * @param btn_index index of the button * @param hidden 0: Visible, 1: Hidden */ void lui_btngrid_set_btn_hidden(lui_obj_t* obj, uint16_t btn_index, uint8_t hidden); /** * @brief Set if a particular button is checkable or not * * @param obj buttongrid object * @param btn_index index of the button * @param checkable 0: NOT checkable, 1: Checkable */ void lui_btngrid_set_btn_checkable(lui_obj_t* obj, uint16_t btn_index, uint8_t checkable); /** * @brief Set the check status of a particular button in button grid * * @param obj buttongrid object * @param btn_index index of the button * @param checked 0: NOT checked, 1: Checked */ void lui_btngrid_set_btn_checked(lui_obj_t* obj, uint16_t btn_index, uint8_t checked); /** * @brief Get the index of currently active button, i.e., the button which has * the input. * * @param obj buttongrid object * @return int16_t Index of active button. -1 if error. */ int16_t lui_btngrid_get_acive_btn_index(lui_obj_t* obj); /** * @brief Get the check status of a particular button in button grid * * @param obj buttongrid object * @param btn_index index of the button * @return int8_t Check status. 0: NOT checked, 1: Checked, -1: Error */ int8_t lui_btngrid_get_btn_check_status(lui_obj_t* obj, uint8_t btn_index); /** * @brief Set font of button grid text * * @param obj buttongrid object * @param font font object */ void lui_btngrid_set_font(lui_obj_t* obj, const lui_font_t* font); /** * @brief Set extra colors of button grid * * @param obj buttongrid object * @param btn_color 16-bit color of button * @param label_color 16-bit color of button texts * @param btn_pressed_color 16-bit color of pressed buttons */ void lui_btngrid_set_extra_colors(lui_obj_t* obj, uint16_t btn_color, uint16_t label_color, uint16_t btn_pressed_color); /** * @brief Set margin of buttons in a button grid * * @param obj buttongrid object * @param margin_x margin in X axis * @param margin_y margin in Y axis */ void lui_btngrid_set_btn_margin(lui_obj_t* obj, uint8_t margin_x, uint16_t margin_y); /** * @private * @brief Calculate buttongrid area * * @param obj buttongrid object */ void _lui_btngrid_calc_btn_area(lui_obj_t* obj); /**@}*/ #endif #if defined(LUI_USE_KEYBOARD) && defined(LUI_USE_BUTTONGRID) /** * @defgroup lui_keyboard Keyboard widget API * * @brief API for Keyboard widget * * keyboard is a special typw of buttongrid. Keyboard has 3 modes. * See : @ref LUI_KEYBOARD_MODE. * * Usually keyboard is used along with a textbox. See: @ref lui_textbox * * Steps to use a keyboard with a textbox are: * 1. Create a keyboard object. Note: Keyboards are hidden by default. * 2. Create a textbox object. * 3. Create a callback function for the textbox * 3.1. If event is LUI_EVENT_ENTERED, set the target keyboard for this textbox. * This will make the keyboard visible. * 3.2. If event is LUI_EVENT_EXITED, set target keyboard as NULL. This will hide * the keyboard again. * * @section keyboard_example Example * This example only creates a keyboard and links it with an existing textbox. * To see a more complete example, see textbox example section. * See: @ref lui_textbox * @image html docs/widgets_images/keyboard.png "Dark Theme" * @image html docs/widgets_images/keyboard_2.png "Light Theme" * @code * lui_obj_t* my_keyboard = lui_keyboard_create(); * // Keyboard is by default hidden. It is supposed to be made visible when a * // textbox is clicked on. But for this example, we are making it visible * // manually. * lui_object_set_visibility(my_keyboard, 1); * * // Set the target textbox * lui_keyboard_set_target_txtbox(my_keyboard. my_txtbox); * @endcode * @{ */ /** * @brief Create a keyboard object with initial values * * @return lui_obj_t* Created keyboard (buttongrid) object */ lui_obj_t* lui_keyboard_create(void); /** * @brief Create a keyboard with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created keyboard object */ lui_obj_t* lui_keyboard_create_and_add(lui_obj_t* obj_parent); /** * @brief Get the text of a key against its index. * * @param obj keyboard (buttongrid) object * @param btn_index index of the key/button * @return const char* text of the key */ const char* lui_keyboard_get_key_text(lui_obj_t* obj, uint8_t btn_index); /** * @brief Set the operation mode of keyboard. * * For allowed modes, see: @ref LUI_KEYBOARD_MODE * * @param obj keyboard (buttongrid) object * @param mode mode */ void lui_keyboard_set_mode(lui_obj_t* obj, uint8_t mode); /** * @brief Set font of the keyboard * * @param obj keyboard (buttongrid) object * @param font font */ void lui_keyboard_set_font(lui_obj_t* obj, const lui_font_t* font); /** * @brief Set the target textbox of the keyboard. When target textbox is set, * the keyboard becomes visible and only the target textbox receives input. * To hide the keyboard again, tap/click on the "check/ok" button on the keyboard. * * @param obj_kb keyboard (buttongrid) object * @param obj_txtbox textbox object */ void lui_keyboard_set_target_txtbox(lui_obj_t* obj_kb, lui_obj_t* obj_txtbox); /** * @brief Keyboard callback function. This function handles all key presses. * * If user needs to write their own callback for keyboard, they must call this * function from their own callback function. * * Example: * @code * // User defined custom callback function for keyboard * void kb_user_callback(lui_obj_t* sender) * { * // Keyboard key is pressed. Do something * // .......... * // [Mandatory] After all user stuffs are done, must call lui_keyboard_sys_cb() * lui_keyboard_sys_cb(sender); * } * * lui_obj_t* keyboard = lui_keyboard_create(); * lui_object_set_callback(keyboard, kb_user_callback); * @endcode * * @param obj_sender sender object */ void lui_keyboard_sys_cb(lui_obj_t* obj_sender); /**@}*/ #endif #if defined(LUI_USE_TEXTBOX) /** * @defgroup lui_textbox Textbox widget API * * @brief API for textbox widget * Usually textbox is used along with a keyboard. See: @ref lui_keyboard * * Steps to use a keyboard with a textbox are: * 1. Create a keyboard object. Note: Keyboards are hidden by default. * 2. Create a textbox object. * 3. Create a callback function for the textbox * 3.1. If event is LUI_EVENT_ENTERED, set the target keyboard for this textbox. * This will make the keyboard visible. * 3.2. If event is LUI_EVENT_EXITED, set target keyboard as NULL. This will hide * the keyboard again. * * @section textbox_example Example * @image html docs/widgets_images/textbox_keyboard.png "Dark Theme" * @image html docs/widgets_images/textbox_keyboard_2.png "Light Theme" * @code * char txtbox_buff[50]; * lui_obj_t* my_keyboard; * lui_obj_t* my_textbox; * * // This callback is fired when user enters/exists the textbox. * // Here, we set the target textbox of the keyboard when user enters the textbox. * // This unhides the keyboard and textbox will receive inputs from the textbox. * // When user exits the textbox by closing the keyboard, keyboard gets hidden. * void textbox_callback(lui_obj_t* obj_txtbox) * { * int8_t event = lui_object_get_event(obj_txtbox); * if (event == LUI_EVENT_ENTERED) * { * lui_keyboard_set_target_txtbox(my_keyboard, my_textbox); * } * else if (event == LUI_EVENT_EXITED) * { * lui_keyboard_set_target_txtbox(my_keyboard, NULL); * } * } * * // Create a textbox object * my_textbox = lui_textbox_create(); * // Important to set area of textbox. * lui_object_set_area(my_textbox, 200, 40); * //[Mandatory] Must set a buffer where the text will be stored * lui_textbox_set_text_buffer(my_textbox, txtbox_buff, 40); * // Let's set an initial string for the testbox. * // Note: the size of string does NOT include the null (\0) terminating char. * lui_textbox_insert_string(my_textbox, (char*)"Hello!!", 7); * //[Important] Set the callback for textbox. In this callback, we will * // link/unlink this textbox with a keyboard object. That will hide/unhide * // the keyboard. * lui_object_set_callback(my_textbox, textbox_callback); * * // Create a keyboard * my_keyboard = lui_keyboard_create(); * // Keyboard is by default hidden. It is made visible when a * // textbox is clicked on. * @endcode * @{ */ /** * @brief Create a textbox object with initial values * * @return lui_obj_t* created textbox object */ lui_obj_t* lui_textbox_create(void); /** * @brief Create a textbox with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created textbox object */ lui_obj_t* lui_textbox_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw a textbox * */ void lui_textbox_draw(lui_obj_t* obj); /** * @brief Enter edit mode (input mode) of a textbox * * @param obj Textbox object */ void lui_textbox_enter_edit_mode(lui_obj_t* obj); /** * @brief Exit edit mode of a textbox * * @param obj Textbox object */ void lui_textbox_exit_edit_mode(lui_obj_t* obj); /** * @brief Set the index (position) of caret (cursor) in the textbox * * Text inputs are inserted at the position of caret. * * @param obj textbox object * @param caret_index caret index */ void lui_textbox_set_caret_index(lui_obj_t* obj, uint16_t caret_index); /** * @brief Get the caret index * * @param obj textbox object * @return uint16_t caret index */ uint16_t lui_textbox_get_caret_index(lui_obj_t* obj); /** * @brief Insert a character at the position of caret. * * This increments the caret index by 1 after the insert operation. * * @param obj textbox object * @param c character * @return int8_t 0: Success, -1: Error */ int8_t lui_textbox_insert_char(lui_obj_t* obj, char c); /** * @brief Insert a string at the position of caret * * This increments the caret index by number of inserted chars after the insert operation. * * @param obj textbox object * @param str string (character array) * @param len length of the string NOT including the null character * @return int8_t 0: Success, -1: Error */ int8_t lui_textbox_insert_string(lui_obj_t* obj, char* str, uint16_t len); /** * @brief Delete a character at the caret index. Does not work when caret is at 0 * * @param obj textbox object * @return int8_t 0: Success, -1: Error */ int8_t lui_textbox_delete_char(lui_obj_t* obj); /** * @brief Set the text buffer of a textbox. This is where the text is stored. * * @param obj textbox object * @param text_buffer buffer (character array) * @param buff_size buffer size */ void lui_textbox_set_text_buffer(lui_obj_t* obj, char* text_buffer, uint16_t buff_size); /** * @brief Empty the text buffer and reset caret position * * @param obj textbox object */ void lui_textbox_clear_text_buffer(lui_obj_t* obj); /** * @brief Set font of the textbox * * @param obj textbox object * @param font font object */ void lui_textbox_set_font(lui_obj_t* obj, const lui_font_t* font); /**@}*/ #endif #if defined(LUI_USE_PANEL) /** * @defgroup lui_panel Panel widget API * * @brief API for panel widget * * A panel is just a container for multiple widgets (objects). This is used for * grouping widgets together. Panels can act as parent widget and must have a * scene as its parent. * * When widgets are added as children to a panel, their posions are relative to * the panel. For example, assume a panel is at (X=10, Y=20) position relative to its * parent scene. Now create a button and set the panel as its parent. Now, the position * of the button will be realtive to the panel. Setting the button's position to * (X=5, Y=3) means it global position actually is (X=15, Y=23). * * Moving a panel to a new position also moves all its children with it. Making a panel * hidden also hides all its children with it. Scaling a panel does NOT scales its * children. But if the new scale is too small to contain all its children, render * result will be unpredictable. * * @note A panel can have layout. All children under the panel will follow the layout. When layout * is enabled, children's position is set by that layout. Currently only horizontal and vertical layouts are supported. * * @section panel_example1 Example of panel * @code * * // Create a panel object * lui_obj_t* my_panel = lui_panel_create(); * // Important to set area of panel. * lui_object_set_area(my_panel, 320, 300); * // Set position of the panel * lui_object_set_position(my_panel, 10, 20); * // Set panel background color * lui_object_set_bg_color(my_panel, lui_rgb(200, 128, 189)) * * // Create a button * lui_obj_t* my_button_1 = lui_button_create(); * // .... [ set buttons area, text, callback etc.] ... * // Now add it to the panel * lui_object_add_to_parent(my_button_1, my_panel); * // This position is relative to the panel * lui_object_set_position(my_button_1, 5, 5); * * // Create a label * lui_obj_t* my_label_1 = lui_label_create(); * // .... [ set label text, color, area etc.] ... * // Now add it to the panel * lui_object_add_to_parent(my_label_1, my_panel); * // This position is relative to the panel * lui_object_set_position(my_label_1, 5, 35); * * // ... [Keep adding more widgets under the panel] ... * @endcode * * @section panel_example2 Example of setting background image * Example of setting a background bitmap image * @code * #include "sunset_hill.h" // include the image bitmap * lui_obj_t* img_panel = lui_panel_create(); * // Important to set area of panel. * lui_object_set_area(img_panel, 320, 300); * // Set position of the panel * lui_object_set_position(img_panel, 10, 20); * // Now set the bitmap image as background * lui_panel_set_bitmap_image(img_panel, &BITMAP_sunset_hill); * @endcode * * @section panel_example3 Example of setting color palette for 1-bpp mono bitmap image * Example of setting color palette for 1-bpp mono bitmap image. Color palettes are applicable * only if the bitmap image is 1-bpp monochrome. If no palette is set by user, default palette * is used. * @code * #include "some_logo.h" // include the 1-bpp mono image bitmap * lui_obj_t* img_panel = lui_panel_create(); * // Important to set area of panel. * lui_object_set_area(img_panel, 320, 300); * // Set position of the panel * lui_object_set_position(img_panel, 10, 20); * // Now set the bitmap image as background * lui_panel_set_bitmap_image(img_panel, &BITMAP_some_logo); * // Prepare the color palette for 1-bpp mono image, and set it * lui_bitmap_mono_pal_t palette = { * .fore_color = lui_rgb(5, 250, 10), * .back_color = lui_rgb(120, 50, 10), * .is_backgrnd = 1 // Setting to 1 to draw the background with `back_color`. Set it to 0 to NOT draw background of bitmap * }; * // Now set those palettes * lui_panel_set_bitmap_image_mono_palette(img_panel, &palette); * @endcode * * @section panel_example4 Example of using layout * Example of setting a layout for the panel * @code * lui_obj_t* panel1 = lui_panel_create(); * // Important to set area of panel. * lui_object_set_area(panel1, 320, 300); * // Set position of the panel * lui_object_set_position(panel1, 10, 20); * // Now add a vertical layout to the panel * lui_panel_layout_set_properties(panel1, LUI_LAYOUT_VERTICAL, 5, 15); * * // Now add a few items. But don't set their positions. * // Because their position will be set by the layout * * lui_obj_t* my_button_1 = lui_button_create_and_add(panel1); * lui_button_set_label_text(my_button_1, "Button 1"); * * lui_obj_t* my_button_2 = lui_button_create_and_add(panel1); * lui_button_set_label_text(my_button_2, "Button 2"); * * lui_obj_t* my_button_3 = lui_button_create_and_add(panel1); * lui_button_set_label_text(my_button_3, "Button 3"); * * lui_obj_t* my_button_4 = lui_button_create_and_add(panel1); * lui_button_set_label_text(my_button_4, "Button 4"); * * lui_obj_t* my_button_5 = lui_button_create_and_add(panel1); * lui_button_set_label_text(my_button_5, "Button 5"); * * // After adding all items to the panel, we'll calculate the layout * // Without calculating, actual layout won't take effect * lui_panel_layout_calculate(panel1); * * @endcode * * @{ */ /** * @brief Create a panel object with initial values * * @return lui_obj_t* Created panel object */ lui_obj_t* lui_panel_create(void); /** * @brief Create a panel with initial values and add it to a parent * * @param obj_parent parent object * @return lui_obj_t* Created panel object */ lui_obj_t* lui_panel_create_and_add(lui_obj_t* obj_parent); /** * @brief Draw apanel * * @param obj_panel panel object */ void lui_panel_draw(lui_obj_t* obj_panel); /** * @brief Set background bitmap image of the panel * * @param obj_panel panel object * @param bitmap bitmap image object */ void lui_panel_set_bitmap_image(lui_obj_t* obj_panel, const lui_bitmap_t* bitmap); /** * @brief Set color palette for 1-bpp mono bitmap image. * * This function has no effect if the bitmap is not 1-bpp. * * @param obj_panel panel object * @param palette color palette for 1-bpp mono bitmap */ void lui_panel_set_bitmap_image_mono_palette(lui_obj_t* obj_panel, lui_bitmap_mono_pal_t* palette); /** * @brief Set the layout properties of a panel. * * All items added as children to this panel will follow the specified layout * after calling `lui_panel_layout_calculate()`. * * Also see: @ref lui_panel_layout_calculate() * @ref LUI_LAYOUT * * @param obj_panel panel object * @param type Type of layout. See `LUI_LAYOUT_` macros for supported values * @param pad_x Padding between children along x-axis * @param pad_y Padding between children along y-axis * @return int8_t 0: Success, -1: Failure */ int8_t lui_panel_layout_set_properties(lui_obj_t* obj_panel, uint8_t type, uint8_t pad_x, uint8_t pad_y); /** * @brief Calculate the layout after adding all children to the parent panel. * * Call this function only after all children are added to the parent. * @note: Must call `lui_panel_layout_set_properties()` before calling this one. * * Also see: @ref lui_panel_layout_set_properties() * * @param obj_panel panel object * @return int8_t int8_t 0: Success, < 0: Failure */ int8_t lui_panel_layout_calculate(lui_obj_t* obj_panel); /**@}*/ #endif /** * @defgroup lui_scene Scene widget API * * @brief API for scene widget * * Scene is the main container of all widgets. It is at the top of hierarchy. * Scene has no parent and must have at least one child. All widgets must be * decedents of a scene. * * An application may have multiple scenes. Only the active scene is rendered * and it is set by `lui_scene_set_active(lui_obj_t* obj_scene)` function. * * @{ */ /** * @brief Create a scene * * @return lui_obj_t* created scene */ lui_obj_t* lui_scene_create(); /** * @brief Draw scene * * @param obj_scene scene widget */ void lui_scene_draw(lui_obj_t* obj_scene); /** * @brief Set the active scene. Only active scene is rendered. * * @param obj_scene scene widget */ void lui_scene_set_active(lui_obj_t* obj_scene); /** * @brief Get the currently active scene * * @return lui_obj_t* active scene widget */ lui_obj_t* lui_scene_get_active(); /** * @brief Set background bitmap image of a scene. * * See the example of panel background image setting. Same applies for scene too. * @param obj_scene scene object * @param bitmap bitmap image object */ void lui_scene_set_bitmap_image(lui_obj_t* obj_scene, const lui_bitmap_t* bitmap); /** * @brief Set color palette for 1-bpp mono bitmap image. * * This function has no effect if the bitmap is not 1-bpp. * * @param obj_scene scene object * @param palette color palette for 1-bpp mono bitmap */ void lui_scene_set_bitmap_image_mono_palette(lui_obj_t* obj_scene, lui_bitmap_mono_pal_t* palette); /** * @brief Set the layout properties of a scene. * * All items added as children to this scene will follow the specified layout * after calling `lui_scene_layout_calculate()`. * * Also see: @ref lui_scene_layout_calculate() * @ref LUI_LAYOUT * * @param obj_scene scene object * @param layout_type Type of layout. See `LUI_LAYOUT_` macros for supported values * @param pad_x Padding between children along x-axis * @param pad_y Padding between children along y-axis * @return int8_t 0: Success, -1: Failure */ int8_t lui_scene_layout_set_properties(lui_obj_t* obj_scene, uint8_t type, uint8_t pad_x, uint8_t pad_y); /** * @brief Calculate the layout after adding all children to the parent scene. * * Call this function only after all children are added to the parent. * @note: Must call `lui_scene_layout_set_properties()` before calling this one. * * Also see: @ref lui_scene_layout_set_properties() * * @param obj_scene scene object * @return int8_t int8_t 0: Success, < 0: Failure */ int8_t lui_scene_layout_calculate(lui_obj_t* obj_scene); // /** // * @brief Set font of a scene // * // * @param obj_scene scene widget // * @param font font // */ // void lui_scene_set_font(lui_obj_t* obj_scene, const lui_font_t* font); /**@}*/ /** * @defgroup lui_dispdrv Display Driver API * * @brief API for display driver object * * LameUI does NOT have its own display driver. User must supply their own functions * to draw pixels on a display. The displaydriver object is a virtual driver that * actually calls user supplied callback functions. * * The example below is using TFT_eSPI library on Arduino framework * Hardware: [MCU = ESP32, Display: ILI9341, Touch IC = XPT2046] * * @section displaydriver_touchinput_example Example * @code * // This example uses TFT_eSPI library on Arduino framework * // Hardware: [MCU = ESP32, Display: ILI9341, Touch IC = XPT2046] * * #include // Graphics and font library for ILI9341 driver chip * #include * // ... [ Include LameUI library and other required headers too] ... * * #define HOR_RES 240 * #define VER_RES 320 * * #define DISP_BUFF_PX (HOR_RES * 10) // display buffer pixels count * #define LAMEUI_MEM_BYTES 4000 // LameUI working memory size in bytes * * uint16_t disp_buffer[DISP_BUFF_PX]; * uint8_t lui_memory[LAMEUI_MEM_BYTES]; * * TFT_eSPI tft = TFT_eSPI(); // Invoke library * * void draw_pixels_buff_cb(uint16_t* disp_buff, lui_area_t* area) * { * tft.setAddrWindow(area->x, area->y, area->w, area->h); * tft.pushColors(disp_buff, (area->w * area->h), true); // swap_byte is true for ili9341 * } * void read_touch_input_cb(lui_touch_input_data_t* inputdata) * { * uint16_t x = 0, y = 0; // To store the touch coordinates * * // Pressed will be set true is there is a valid touch on the screen * bool pressed = tft.getTouch(&x, &y); * inputdata->is_pressed = pressed; * if (pressed) * { * inputdata->x = x; * inputdata->y = y; * } * else * { * inputdata->x = -1; * inputdata->y = -1; * } * } * * void setup(void) * { * // Initilaize tft * tft.init(); * tft.setTouch(touch_cal_data); * * // Initialize LameUI with some memory * lui_init(lui_memory, sizeof(lui_memory)); * * // Create a display driver object * lui_dispdrv_t* display_driver = lui_dispdrv_create(); * lui_dispdrv_register(display_driver); * lui_dispdrv_set_resolution(display_driver, HOR_RES, VER_RES); * lui_dispdrv_set_disp_buff(display_driver, disp_buffer, DISP_BUFF_PX); * lui_dispdrv_set_draw_disp_buff_cb(display_driver, draw_pixels_buff_cb); * * // Create touch input device * lui_touch_input_dev_t* input_device = lui_touch_inputdev_create(); * lui_touch_inputdev_register(input_device); * lui_touch_inputdev_set_read_input_cb(input_device, read_touch_input_cb); * * * // ... [Add scene (mandatory) and other widgets] ... * } * * void loop() * { * // Must update the UI periodically * lui_update(); * * // ... [Do other stuffs] ... * } * @endcode * * @{ */ /** * @brief Create display driver object * * @return lui_dispdrv_t* created display driver */ lui_dispdrv_t* lui_dispdrv_create(void); /** * @brief Register display driver. * * @param dispdrv display driver object */ void lui_dispdrv_register(lui_dispdrv_t* dispdrv); /** * @brief Create display driver object and register it * * @return lui_dispdrv_t* created display driver */ lui_dispdrv_t* lui_dispdrv_create_and_register(void); /** * @brief Set horizontal and vertical resolution of display * * @param dispdrv display driver object * @param hor_res horizontal resolution * @param vert_res vertical resolution */ void lui_dispdrv_set_resolution(lui_dispdrv_t* dispdrv, uint16_t hor_res, uint16_t vert_res); /** * @brief Set the display buffer. This buffer is provided by user and filled * with colors by library. Then user passes this buffer to the display. * * Display buffer is an array of uint16_t. Array size must be multiple of * horizontal resolution of display. If display's horizontal res is 320px, * minimum buffer size should be 320. It's recommended to use at least 10 times * horizontal resolution as the buffer size. * * @param dispdrv display driver object * @param disp_buff display buffer of type uint16_t * @param size_in_px buffer size (in pixel count) * * @return int8_t -1: Failure, 0: Success */ int8_t lui_dispdrv_set_disp_buff(lui_dispdrv_t* dispdrv, uint16_t* disp_buff, uint32_t size_in_px); /** * @brief Set callback function for drawing an area of pixels with a display buffer. * * @param dispdrv display driver object * @param draw_pixels_buff_cb callback function pointer */ void lui_dispdrv_set_draw_disp_buff_cb(lui_dispdrv_t* dispdrv, void (*draw_pixels_buff_cb)(uint16_t* disp_buff, lui_area_t* area)); /** * @private * @brief Check if display driver and pixel drawing callback function are properly registered * * @return uint8_t 0: Not registered, 1: Registered */ uint8_t _lui_disp_drv_check(); /**@}*/ /** * @defgroup lui_input Touch Input Device API * * @brief API for touch input device object * * LameUI does NOT have its own Touch Input driver. User must supply their own functions * to read touch input. Touch input data is stored in `lui_touch_input_data_t`: * ```C * typedef struct _lui_touch_input_data_s * { * uint8_t is_pressed; * int16_t x; * int16_t y; * }lui_touch_input_data_t; * ``` * @note When touch input is NOT pressed, x and y value must be -1. * * @section touchinput_example Example * Example code for touch input can be found inside the display driver example code. * * See: @ref displaydriver_touchinput_example * * @{ */ /** * @brief Create touch input device object * * @return lui_touch_input_dev_t* Created touch input device object */ lui_touch_input_dev_t* lui_touch_inputdev_create(void); /** * @brief Register a touch input device * * @param touch_inputdev touch input device object */ void lui_touch_inputdev_register(lui_touch_input_dev_t* touch_inputdev); /** * @brief Create touch input device object and register it * * @return lui_touch_input_dev_t* Created touch input device object */ lui_touch_input_dev_t* lui_touch_inputdev_create_and_register(void); /** * @brief * * @param touch_inputdev * @param read_touch_input_cb */ void lui_touch_inputdev_set_read_input_cb(lui_touch_input_dev_t* touch_inputdev, void (*read_touch_input_cb)(lui_touch_input_data_t* touch_inputdata)); /**@}*/ //------------------------------------------------------------------------------- //-------------------------------- HELPER FUNCTIONS ----------------------------- //------------------------------------------------------------------------------- void _lui_mem_init(uint8_t mem_block[], uint32_t size); void *_lui_mem_alloc(uint16_t element_size); double _lui_map_range(double old_val, double old_max, double old_min, double new_max, double new_min); uint8_t _lui_clip_line(double* point_0, double* point_1, const lui_area_t* clip_win); uint8_t _lui_calc_clip_region_code(double x, double y, const lui_area_t* clip_win); lui_obj_t* _lui_process_input_of_act_scene(); lui_obj_t* _lui_scan_all_obj_for_input(lui_touch_input_data_t* touch_input_data, lui_obj_t* obj_root, lui_obj_t* obj_excluded); lui_obj_t* _lui_scan_individual_object_for_input(lui_touch_input_data_t* touch_input_data, lui_obj_t* obj); void _lui_set_obj_props_on_touch_input(lui_touch_input_data_t* input_data, lui_obj_t* obj); uint8_t _lui_check_if_active_obj_touch_input(lui_touch_input_data_t* input_data, lui_obj_t* obj); // const lui_font_t* _lui_get_font_from_active_scene(); uint8_t _lui_get_event_against_state(uint8_t new_state, uint8_t old_state); int8_t _lui_verify_obj(lui_obj_t* obj, uint8_t obj_type); int8_t _lui_layout_set_properties(lui_obj_t* obj, uint8_t layout_type, uint8_t pad_x, uint8_t pad_y); int8_t _lui_layout_calculate(lui_obj_t* obj); /** * @defgroup lui_gfx Graphics related API (for drawing shapes and text) * * @brief API for various graphics related functions like drawing line, rectangle, text etc. * User does NOT require to use them. But if needed for some special reason, user may * call these functions. * * Note: `lui_update()` function will overwrite any manual gfx calls made by user. * So, user must call gfx functions after the update function in a loop. * * @{ */ /** * @brief Advanced function to draw a string. For internal use only, but user * may call it if needed. Most of the time `draw_string_simple` is enough for user. * * This function lets user draw a string with specified fore color and background * color. The background can be a bitmap image instead of color. * * `area` sets string bounding box. When the area of the string is not known, * width and height of area (`area.w` and `area.h`) can be set to 0. In this case, * the function calculates the area. Width and height can be found using * `lui_gfx_get_string_dimension()`. * * When the `is_bg` arg is 0, background color/image is not rendered, creating a * tranaparent background. But the downside is, if the text is cahnged later, it * cannot clear the previous pixels when `is_bg` is 0. * * When `is_bg` is 1 and `bg_bitmap` is not NULL, the bitmap is rendered as background * instead of `bg_color`. Set bitmap to NULL for rendering `bg_color`. * * `bitmap_crop` argument is useful when the backgrounf bitmap image is bigger than * the text area. * * @param str text string * @param area area of the string. It sets drawing start positions and the dimension. * @param fore_color text color * @param bg_color text background color * @param bg_bitmap text background bimap. * @param palette color palette for 1-bpp mono bitmap. Has no effect if bitmap is NOT 1-bpp. * @param bitmap_crop crop area of the bitmap image. * @param is_bg flag decides whether to render background color/image or not * @param font font of the text */ void lui_gfx_draw_string_advanced(const char* str, lui_area_t* area, uint16_t fore_color, uint16_t bg_color, const lui_bitmap_t* bg_bitmap, lui_bitmap_mono_pal_t* palette, lui_area_t* bitmap_crop, uint8_t is_bg, const lui_font_t* font); /** * @brief Simplified function to draw a string * * Note: This function does not render the background * * @param str text * @param x start X position * @param y start Y position * @param fore_color text color * @param font tetx font */ void lui_gfx_draw_string_simple(const char* str, uint16_t x, uint16_t y, uint16_t fore_color, const lui_font_t* font); /** * @brief Draw a single character. * * @param c character * @param x postion X * @param y position Y * @param fore_color character color * @param bg_color background color * @param is_bg flag decides whether to draw bg_color or not * @param font character font */ void lui_gfx_draw_char(char c, uint16_t x, uint16_t y, uint16_t fore_color, uint16_t bg_color, uint8_t is_bg, const lui_font_t* font); /** * @brief Get height of the font * * @param font font * @return uint16_t height of font in pixels */ uint16_t lui_gfx_get_font_height(const lui_font_t* font); /** * @brief Get dimension of a string along x and y axis. * * `max_w` (max width) sets the text's bounding box width. Past this width, text * is wrapped and goes to next line. This value must not be bigger than the width * of the display. * * It does not return any value, rather modifies the `str_dim` array. * * @param str text * @param font_obj font * @param max_w maximum allowed width * @param str_dim array of 2 items to return string dimension ({w, h}) */ void lui_gfx_get_string_dimension(const char* str, const lui_font_t* font_obj, uint16_t max_w, uint16_t str_dim[2]); /** * @brief Draw a line * * @param x0 start X * @param y0 start Y * @param x1 end X * @param y1 end Y * @param line_width width in px * @param color line color */ void lui_gfx_draw_line(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, uint8_t line_width, uint16_t color); /** * @brief Draw a line within a clipping area * * @param x0 start X * @param y0 start Y * @param x1 end X * @param y1 end Y * @param clip_area pointer to the clipping area * @param line_width width in px * @param color line color */ void lui_gfx_draw_line_clipped(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, lui_area_t* clip_area, uint8_t line_width, uint16_t color); /** * @brief Draw a rectangle * * @param x start X * @param y start Y * @param w width * @param h height * @param line_width width of line in px * @param color color of line */ void lui_gfx_draw_rect(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint8_t line_width, uint16_t color); /** * @brief Draw a filled rectangle * * @param x start X * @param y start Y * @param w width * @param h height * @param color fill color */ void lui_gfx_draw_rect_fill(uint16_t x, uint16_t y, uint16_t w, uint16_t h, uint16_t color); /** * @brief Draw a filled rectangle within a clipping area/window * * @param x start X * @param y start Y * @param w width * @param h height * @param clip_area pointer to the clipping area * @param color fill color */ void lui_gfx_draw_rect_fill_clipped(uint16_t x, uint16_t y, uint16_t w, uint16_t h, lui_area_t* clip_area, uint16_t color); /** * @brief Draws a bitmap at given x,y position. Crop area can be NULL if cropping * is not needed. `palette` parameter is only applicable if image is 1-bpp mono bitmap. * * Set `pallete` to NULL if the `bitmap` image is snot 1-bpp. * * @param bitmap pointer to bitmap data * @param palette color palette for 1-bpp mono bitmap. Has no effect for 8-bpp and 16-bpp bitmaps. * @param x start X position * @param y start Y position * @param crop_area pointer to crop area. Set NULL for no cropping. */ void lui_gfx_draw_bitmap(const lui_bitmap_t* bitmap, lui_bitmap_mono_pal_t* palette, uint16_t x, uint16_t y, lui_area_t* crop_area); /** * @brief Create 16-bit RGB565 color using R, G, and B values (each 8-bit) * * Since LameUI uses RGB565 (16-bit) internally, this function is needed when * when setting color for any item/object. * * @param red 8-bit red color * @param green 8-bit green color * @param blue 8-bit blue color * @return uint16_t 16-bit color */ uint16_t lui_rgb(uint8_t red, uint8_t green, uint8_t blue); /**@}*/ const _lui_glyph_t* _lui_gfx_get_glyph_from_char(char c, const lui_font_t* font); void _lui_gfx_render_char_glyph(uint16_t x, uint16_t y, uint16_t fore_color, uint16_t bg_color, uint8_t is_bg, const _lui_glyph_t* glyph, const lui_font_t* font); void _lui_gfx_plot_line_low(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, lui_area_t* clip_area, uint8_t line_width, uint16_t color); void _lui_gfx_plot_line_high(uint16_t x0, uint16_t y0, uint16_t x1, uint16_t y1, lui_area_t* clip_area, uint8_t line_width, uint16_t color); /*-------------------------------------------- * End Function Prototypes *-------------------------------------------- */ /*-------------------------------------------- * Themes (Dark/Light) *-------------------------------------------- */ #define _LUI_R_POS_RGB 11 // Red last bit position for RGB display #define _LUI_G_POS_RGB 5 // Green last bit position for RGB display #define _LUI_B_POS_RGB 0 // Blue last bit position for RGB display #define LUI_RGB(R, G, B) (((uint16_t)(R >> 3) << _LUI_R_POS_RGB) | \ ((uint16_t)(G >> 2) << _LUI_G_POS_RGB) | \ ((uint16_t)(B >> 3) << _LUI_B_POS_RGB)) /*------------------------------------------------------------------------------------ * Dark and Light Theme. User may modify here if needed *------------------------------------------------------------------------------------ */ #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_BUTTON_LABEL_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_BUTTON_PRESSED_COLOR LUI_RGB(91, 160, 235) #define LUI_STYLE_BUTTON_SELECTION_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_BUTTON_BG_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_BUTTON_BORDER_COLOR LUI_RGB(75, 81, 92) #else #define LUI_STYLE_BUTTON_LABEL_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_BUTTON_PRESSED_COLOR LUI_RGB(91, 160, 235) #define LUI_STYLE_BUTTON_SELECTION_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_BUTTON_BG_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_BUTTON_BORDER_COLOR LUI_RGB(75, 81, 92) #endif #define LUI_STYLE_BUTTON_BORDER_THICKNESS 0 #define LUI_STYLE_BUTTON_WIDTH 40 #define LUI_STYLE_BUTTON_HEIGHT 30 #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_LABEL_TEXT_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_LABEL_BG_COLOR LUI_RGB(23, 33, 43) #define LUI_STYLE_LABEL_BORDER_COLOR LUI_RGB(74, 129, 188) #else #define LUI_STYLE_LABEL_TEXT_COLOR LUI_RGB(0, 0, 0) #define LUI_STYLE_LABEL_BG_COLOR LUI_RGB(255, 255, 255) #define LUI_STYLE_LABEL_BORDER_COLOR LUI_RGB(74, 129, 188) #endif #define LUI_STYLE_LABEL_BORDER_THICKNESS 0 #define LUI_STYLE_LABEL_WIDTH 0 /*40*/ #define LUI_STYLE_LABEL_HEIGHT 0 /*30*/ #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_SWITCH_SELECTION_COLOR LUI_RGB(0, 170, 179) #define LUI_STYLE_SWITCH_KNOB_OFF_COLOR LUI_RGB(57, 62, 70) #define LUI_STYLE_SWITCH_KNOB_ON_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_SWITCH_BG_COLOR LUI_RGB(23, 33, 43) #define LUI_STYLE_SWITCH_BORDER_COLOR LUI_RGB(74, 129, 188) #else #define LUI_STYLE_SWITCH_SELECTION_COLOR LUI_RGB(0, 170, 179) #define LUI_STYLE_SWITCH_KNOB_OFF_COLOR LUI_RGB(150, 150, 150) #define LUI_STYLE_SWITCH_KNOB_ON_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_SWITCH_BG_COLOR LUI_RGB(255, 255, 255) #define LUI_STYLE_SWITCH_BORDER_COLOR LUI_RGB(74, 129, 188) #endif #define LUI_STYLE_SWITCH_BORDER_THICKNESS 1 #define LUI_STYLE_SWITCH_WIDTH 40 #define LUI_STYLE_SWITCH_HEIGHT 20 #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_CHECKBOX_SELECTION_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_CHECKBOX_TICK_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_CHECKBOX_LABEL_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_CHECKBOX_BG_COLOR LUI_RGB(23, 33, 43) #define LUI_STYLE_CHECKBOX_BG_CHECKED_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_CHECKBOX_BORDER_COLOR LUI_RGB(74, 129, 188) #else #define LUI_STYLE_CHECKBOX_SELECTION_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_CHECKBOX_TICK_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_CHECKBOX_LABEL_COLOR LUI_RGB(0, 0, 0) #define LUI_STYLE_CHECKBOX_BG_COLOR LUI_RGB(255, 255, 255) #define LUI_STYLE_CHECKBOX_BG_CHECKED_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_CHECKBOX_BORDER_COLOR LUI_RGB(74, 129, 188) #endif #define LUI_STYLE_CHECKBOX_BORDER_THICKNESS 1 #define LUI_STYLE_CHECKBOX_WIDTH 20 #define LUI_STYLE_CHECKBOX_HEIGHT LUI_STYLE_CHECKBOX_WIDTH #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_SLIDER_SELECTION_COLOR LUI_RGB(0, 170, 179) #define LUI_STYLE_SLIDER_KNOB_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_SLIDER_BG_COLOR LUI_RGB(57, 62, 70) #define LUI_STYLE_SLIDER_BG_FILLED_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_SLIDER_BORDER_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_SLIDER_BORDER_THICKNESS 0 #else // TODO: Improve light theme #define LUI_STYLE_SLIDER_SELECTION_COLOR LUI_RGB(0, 170, 179) #define LUI_STYLE_SLIDER_KNOB_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_SLIDER_BG_COLOR LUI_RGB(150, 150,150) #define LUI_STYLE_SLIDER_BG_FILLED_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_SLIDER_BORDER_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_SLIDER_BORDER_THICKNESS 1 #endif #define LUI_STYLE_SLIDER_KNOB_WIDTH 20 #define LUI_STYLE_SLIDER_WIDTH 80 #define LUI_STYLE_SLIDER_HEIGHT 20 #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_LINECHART_LINE_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_LINECHART_POINT_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_LINECHART_GRID_COLOR LUI_RGB(75, 81, 92) #define LUI_STYLE_LINECHART_BG_COLOR LUI_RGB(35, 46, 60) #define LUI_STYLE_LINECHART_BORDER_COLOR LUI_RGB(74, 129, 188) #else #define LUI_STYLE_LINECHART_LINE_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_LINECHART_POINT_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_LINECHART_GRID_COLOR LUI_RGB(150, 150, 150) #define LUI_STYLE_LINECHART_BG_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_LINECHART_BORDER_COLOR LUI_RGB(74, 129, 188) #endif #define LUI_STYLE_LINECHART_GRID_VISIBLE 1 #define LUI_STYLE_LINECHART_BORDER_THICKNESS 1 #define LUI_STYLE_LINECHART_WIDTH 40 #define LUI_STYLE_LINECHART_HEIGHT 20 #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_LIST_NAV_BG_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_LIST_NAV_LABEL_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_LIST_NAV_PRESSED_COLOR LUI_RGB(91, 160, 235) #define LUI_STYLE_LIST_NAV_SELECTION_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_LIST_ITEM_BG_COLOR LUI_RGB(57, 62, 70) #define LUI_STYLE_LIST_ITEM_SELECTION_COLOR LUI_RGB(84, 91, 102) #define LUI_STYLE_LIST_ITEM_PRESSED_COLOR LUI_RGB(109, 118, 133) #define LUI_STYLE_LIST_ITEM_LABEL_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_LIST_ITEM_BORDER_COLOR LUI_RGB(75, 81, 92) #define LUI_STYLE_LIST_BORDER_THICKNESS 0 #else #define LUI_STYLE_LIST_NAV_BG_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_LIST_NAV_LABEL_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_LIST_NAV_PRESSED_COLOR LUI_RGB(91, 160, 235) #define LUI_STYLE_LIST_NAV_SELECTION_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_LIST_ITEM_BG_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_LIST_ITEM_SELECTION_COLOR LUI_RGB(109, 118, 133) #define LUI_STYLE_LIST_ITEM_PRESSED_COLOR LUI_RGB(137, 173, 232) #define LUI_STYLE_LIST_ITEM_LABEL_COLOR LUI_RGB(0, 0, 0) #define LUI_STYLE_LIST_ITEM_BORDER_COLOR LUI_RGB(75, 81, 92) #define LUI_STYLE_LIST_BORDER_THICKNESS 1 #endif #define LUI_STYLE_LIST_ITEM_BORDER_THICKNESS 0 #define LUI_STYLE_LIST_ITEM_MIN_HEIGHT 30 #define LUI_STYLE_LIST_BORDER_COLOR LUI_RGB(74, 129, 188) #define LUI_STYLE_LIST_WIDTH 40 #define LUI_STYLE_LIST_HEIGHT 60 #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_BTNGRID_BASE_BG_COLOR LUI_RGB(23, 33, 43) #define LUI_STYLE_BTNGRID_LABEL_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_BTNGRID_PRESSED_COLOR LUI_RGB(91, 160, 235) #define LUI_STYLE_BTNGRID_BG_COLOR LUI_RGB(39, 55, 71) #define LUI_STYLE_BTNGRID_SELECTION_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_BTNGRID_BORDER_COLOR LUI_RGB(75, 81, 92) #define LUI_STYLE_BTNGRID_BORDER_THICKNESS 0 #else #define LUI_STYLE_BTNGRID_BASE_BG_COLOR LUI_RGB(255, 255, 255) #define LUI_STYLE_BTNGRID_LABEL_COLOR LUI_RGB(0, 0, 0) #define LUI_STYLE_BTNGRID_PRESSED_COLOR LUI_RGB(91, 160, 235) #define LUI_STYLE_BTNGRID_BG_COLOR LUI_RGB(200, 200, 200) #define LUI_STYLE_BTNGRID_SELECTION_COLOR LUI_RGB(82, 143, 209) #define LUI_STYLE_BTNGRID_BORDER_COLOR LUI_RGB(150, 150, 150) #define LUI_STYLE_BTNGRID_BORDER_THICKNESS 1 #endif #define LUI_STYLE_BTNGRID_WIDTH 300 #define LUI_STYLE_BTNGRID_HEIGHT 180 #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_TEXTBOX_TEXT_COLOR LUI_RGB(238, 238, 238) #define LUI_STYLE_TEXTBOX_BG_COLOR LUI_RGB(45, 56, 70) #define LUI_STYLE_TEXTBOX_BORDER_COLOR LUI_RGB(74, 129, 188) #else #define LUI_STYLE_TEXTBOX_TEXT_COLOR LUI_RGB(0, 0, 0) #define LUI_STYLE_TEXTBOX_BG_COLOR LUI_RGB(255, 255, 255) #define LUI_STYLE_TEXTBOX_BORDER_COLOR LUI_RGB(74, 129, 188) #endif #define LUI_STYLE_TEXTBOX_BORDER_THICKNESS 1 #define LUI_STYLE_TEXTBOX_WIDTH 200 #define LUI_STYLE_TEXTBOX_HEIGHT 20 #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_PANEL_BG_COLOR LUI_RGB(23, 33, 43) #define LUI_STYLE_PANEL_BORDER_COLOR LUI_RGB(74, 129, 188) #else #define LUI_STYLE_PANEL_BG_COLOR LUI_RGB(255, 255, 255) #define LUI_STYLE_PANEL_BORDER_COLOR LUI_RGB(74, 129, 188) #endif #define LUI_STYLE_PANEL_BORDER_THICKNESS 1 #define LUI_STYLE_PANEL_WIDTH 100 #define LUI_STYLE_PANEL_HEIGHT 100 #if LUI_USE_DARK_THEME == 1 #define LUI_STYLE_SCENE_BG_COLOR LUI_RGB(23, 33, 43) #else #define LUI_STYLE_SCENE_BG_COLOR LUI_RGB(255, 255, 255) #endif /*-------------------------------------------- * End Themes (Dark/Light) *-------------------------------------------- */ /*-------------------------------------------- * Helper Macros *-------------------------------------------- */ #ifndef NULL #define NULL ((void *)0) #endif // TODO: Inspect the code and use MIN, MAX, and BOUND where needed #define _LUI_MIN(A,B) ({ (A) < (B) ? (A) : (B); }) #define _LUI_MAX(A,B) ({ (A) < (B) ? (B) : (A); }) #define _LUI_BOUNDS(x, low, high) ({\ (x) > (high) ? (high) : ((x) < (low) ? (low) : (x));\ }) #define _LUI_SWAP(type, a, b) ({ type tmp = (a); (a) = (b); (b) = tmp; }) #define _LUI_CREATE_AND_ADD(type, parent) \ lui_obj_t* obj = lui_##type##_create(); \ lui_object_add_to_parent(obj, parent); \ return obj; #endif /* INC_LAME_UI_H_ */