kemonine/serial_debugger
kemonine
/
serial_debugger
1
0
Fork 0
Code Issues 1 Pull Requests Projects 3 Releases Activity
serial_debugger/hardware/sd_card_formatter/src/guislice/GUIslice.h

3802 lines
154 KiB
C
Raw Blame History

#ifndef _GUISLICE_H_
#define _GUISLICE_H_
// =======================================================================
// GUIslice library
// - Calvin Hass
// - https://www.impulseadventure.com/elec/guislice-gui.html
// - https://github.com/ImpulseAdventure/GUIslice
//
// - Version 0.15.0
// =======================================================================
//
// The MIT License
//
// Copyright 2016-2020 Calvin Hass
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// =======================================================================
/// \file GUIslice.h
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <inttypes.h>
// -----------------------------------------------------------------------
// Configuration
// -----------------------------------------------------------------------
// Import configuration ( which will import a sub-config depending on device type)
#include "GUIslice_config.h"
// Provide an alias for PROGMEM so that we can disable
// it on devices that don't use it when defining constant
// strings in FLASH memory.
#if (GSLC_USE_PROGMEM)
#define GSLC_PMEM PROGMEM
#else
#define GSLC_PMEM
#endif
// -----------------------------------------------------------------------
// Globals
// -----------------------------------------------------------------------
// Type for user-provided debug output function
typedef int16_t (*GSLC_CB_DEBUG_OUT)(char ch);
/// Global debug output function
/// - The user assigns this function via gslc_InitDebug()
extern GSLC_CB_DEBUG_OUT g_pfDebugOut;
// -----------------------------------------------------------------------
// Constants
// -----------------------------------------------------------------------
#define GSLC_2PI 6.28318530718
// -----------------------------------------------------------------------
// Enumerations
// -----------------------------------------------------------------------
/// Element ID enumerations
/// - The Element ID is the primary means for user code to
/// reference a graphic element.
/// - Application code can assign arbitrary Element ID values
/// in the range of 0...16383
/// - Specifying GSLC_ID_AUTO to ElemCreate() requests that
/// GUIslice auto-assign an ID value for the Element. These
/// auto-assigned values will begin at GSLC_ID_AUTO_BASE.
/// - Negative Element ID values are reserved
typedef enum {
// Public usage
GSLC_ID_USER_BASE = 0, ///< Starting Element ID for user assignments
GSLC_ID_NONE = -1999, ///< No Element ID has been assigned
GSLC_ID_AUTO, ///< Auto-assigned Element ID requested
GSLC_ID_TEMP, ///< ID for Temporary Element
// Internal usage
GSLC_ID_AUTO_BASE = 16384, ///< Starting Element ID to start auto-assignment
///< (when GSLC_ID_AUTO is specified)
} gslc_teElemId;
/// Page ID enumerations
/// - The Page ID is the primary means for user code to
/// reference a specific page of elements.
/// - Application code can assign arbitrary Page ID values
/// in the range of 0...16383
/// - Negative Page ID values are reserved
typedef enum {
// Public usage
GSLC_PAGE_USER_BASE = 0, ///< Starting Page ID for user assignments
// Internal usage
GSLC_PAGE_NONE = -2999, ///< No Page ID has been assigned
} gslc_tePageId;
/// Define page stack
typedef enum {
GSLC_STACK_BASE = 0, ///< Base page
GSLC_STACK_CUR, ///< Current page
GSLC_STACK_OVERLAY, ///< Overlay page (eg. popups)
GSLC_STACK__MAX ///< Defines maximum number of pages in stack
} gslc_teStackPage;
/// Group ID enumerations
typedef enum {
// Public usage
GSLC_GROUP_ID_USER_BASE = 0, ///< Starting Group ID for user assignments
// Internal usage
GSLC_GROUP_ID_NONE = -6999, ///< No Group ID has been assigned
} gslc_teGroupId;
/// Font ID enumerations
/// - The Font ID is the primary means for user code to
/// reference a specific font.
/// - Application code can assign arbitrary Font ID values
/// in the range of 0...16383
/// - Negative Font ID values are reserved
typedef enum {
// Public usage
GSLC_FONT_USER_BASE = 0, ///< Starting Font ID for user assignments
GSLC_FONT_NONE = -4999, ///< No Font ID has been assigned
} gslc_teFontId;
/// Element Index enumerations
/// - The Element Index is used for internal purposes as an offset
// into the GUI's array of elements
typedef enum {
// Internal usage
GSLC_IND_NONE = -9999, ///< No Element Index is available
GSLC_IND_FIRST = 0, ///< User elements start at index 0
} gslc_teElemInd;
/// Element type
typedef enum {
// Core elements:
GSLC_TYPE_NONE, ///< No element type specified
GSLC_TYPE_BKGND, ///< Background element type
GSLC_TYPE_BTN, ///< Button element type
GSLC_TYPE_TXT, ///< Text label element type
GSLC_TYPE_BOX, ///< Box / frame element type
GSLC_TYPE_LINE, ///< Line element type
/// Base value for extended type enumerations
GSLC_TYPE_BASE_EXTEND = 0x1000
} gslc_teTypeCore;
/// Element features type
#define GSLC_ELEM_FEA_VALID 0x80 ///< Element record is valid
#define GSLC_ELEM_FEA_ROUND_EN 0x10 ///< Element is drawn with a rounded profile
#define GSLC_ELEM_FEA_CLICK_EN 0x08 ///< Element accepts touch presses
#define GSLC_ELEM_FEA_GLOW_EN 0x04 ///< Element supports glowing state
#define GSLC_ELEM_FEA_FRAME_EN 0x02 ///< Element is drawn with a frame
#define GSLC_ELEM_FEA_FILL_EN 0x01 ///< Element is drawn with a fill
#define GSLC_ELEM_FEA_NONE 0x00 ///< Element default (no features set))
/// Element text alignment
#define GSLC_ALIGNV_TOP 0x10 ///< Vertical align to top
#define GSLC_ALIGNV_MID 0x20 ///< Vertical align to middle
#define GSLC_ALIGNV_BOT 0x40 ///< Vertical align to bottom
#define GSLC_ALIGNH_LEFT 0x01 ///< Horizontal align to left
#define GSLC_ALIGNH_MID 0x02 ///< Horizontal align to middle
#define GSLC_ALIGNH_RIGHT 0x04 ///< Horizontal align to right
#define GSLC_ALIGN_TOP_LEFT GSLC_ALIGNH_LEFT | GSLC_ALIGNV_TOP ///< Align to top-left
#define GSLC_ALIGN_TOP_MID GSLC_ALIGNH_MID | GSLC_ALIGNV_TOP ///< Align to middle of top
#define GSLC_ALIGN_TOP_RIGHT GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_TOP ///< Align to top-right
#define GSLC_ALIGN_MID_LEFT GSLC_ALIGNH_LEFT | GSLC_ALIGNV_MID ///< Align to middle of left side
#define GSLC_ALIGN_MID_MID GSLC_ALIGNH_MID | GSLC_ALIGNV_MID ///< Align to center
#define GSLC_ALIGN_MID_RIGHT GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_MID ///< Align to middle of right side
#define GSLC_ALIGN_BOT_LEFT GSLC_ALIGNH_LEFT | GSLC_ALIGNV_BOT ///< Align to bottom-left
#define GSLC_ALIGN_BOT_MID GSLC_ALIGNH_MID | GSLC_ALIGNV_BOT ///< Align to middle of bottom
#define GSLC_ALIGN_BOT_RIGHT GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_BOT ///< Align to bottom-right
/// Basic color definition
#define GSLC_COL_RED_DK4 (gslc_tsColor) {128, 0, 0} ///< Red (dark4)
#define GSLC_COL_RED_DK3 (gslc_tsColor) {160, 0, 0} ///< Red (dark3)
#define GSLC_COL_RED_DK2 (gslc_tsColor) {192, 0, 0} ///< Red (dark2)
#define GSLC_COL_RED_DK1 (gslc_tsColor) {224, 0, 0} ///< Red (dark1)
#define GSLC_COL_RED (gslc_tsColor) {255, 0, 0} ///< Red
#define GSLC_COL_RED_LT1 (gslc_tsColor) {255, 32, 32} ///< Red (light1)
#define GSLC_COL_RED_LT2 (gslc_tsColor) {255, 64, 64} ///< Red (light2)
#define GSLC_COL_RED_LT3 (gslc_tsColor) {255, 96, 96} ///< Red (light3)
#define GSLC_COL_RED_LT4 (gslc_tsColor) {255,128,128} ///< Red (light4)
#define GSLC_COL_GREEN_DK4 (gslc_tsColor) { 0,128, 0} ///< Green (dark4)
#define GSLC_COL_GREEN_DK3 (gslc_tsColor) { 0,160, 0} ///< Green (dark3)
#define GSLC_COL_GREEN_DK2 (gslc_tsColor) { 0,192, 0} ///< Green (dark2)
#define GSLC_COL_GREEN_DK1 (gslc_tsColor) { 0,224, 0} ///< Green (dark1)
#define GSLC_COL_GREEN (gslc_tsColor) { 0,255, 0} ///< Green
#define GSLC_COL_GREEN_LT1 (gslc_tsColor) { 32,255, 32} ///< Green (light1)
#define GSLC_COL_GREEN_LT2 (gslc_tsColor) { 64,255, 64} ///< Green (light2)
#define GSLC_COL_GREEN_LT3 (gslc_tsColor) { 96,255, 96} ///< Green (light3)
#define GSLC_COL_GREEN_LT4 (gslc_tsColor) {128,255,128} ///< Green (light4)
#define GSLC_COL_BLUE_DK4 (gslc_tsColor) { 0, 0,128} ///< Blue (dark4)
#define GSLC_COL_BLUE_DK3 (gslc_tsColor) { 0, 0,160} ///< Blue (dark3)
#define GSLC_COL_BLUE_DK2 (gslc_tsColor) { 0, 0,192} ///< Blue (dark2)
#define GSLC_COL_BLUE_DK1 (gslc_tsColor) { 0, 0,224} ///< Blue (dark1)
#define GSLC_COL_BLUE (gslc_tsColor) { 0, 0,255} ///< Blue
#define GSLC_COL_BLUE_LT1 (gslc_tsColor) { 32, 32,255} ///< Blue (light1)
#define GSLC_COL_BLUE_LT2 (gslc_tsColor) { 64, 64,255} ///< Blue (light2)
#define GSLC_COL_BLUE_LT3 (gslc_tsColor) { 96, 96,255} ///< Blue (light3)
#define GSLC_COL_BLUE_LT4 (gslc_tsColor) {128,128,255} ///< Blue (light4)
#define GSLC_COL_BLACK (gslc_tsColor) { 0, 0, 0} ///< Black
#define GSLC_COL_GRAY_DK3 (gslc_tsColor) { 32, 32, 32} ///< Gray (dark)
#define GSLC_COL_GRAY_DK2 (gslc_tsColor) { 64, 64, 64} ///< Gray (dark)
#define GSLC_COL_GRAY_DK1 (gslc_tsColor) { 96, 96, 96} ///< Gray (dark)
#define GSLC_COL_GRAY (gslc_tsColor) {128,128,128} ///< Gray
#define GSLC_COL_GRAY_LT1 (gslc_tsColor) {160,160,160} ///< Gray (light1)
#define GSLC_COL_GRAY_LT2 (gslc_tsColor) {192,192,192} ///< Gray (light2)
#define GSLC_COL_GRAY_LT3 (gslc_tsColor) {224,224,224} ///< Gray (light3)
#define GSLC_COL_WHITE (gslc_tsColor) {255,255,255} ///< White
#define GSLC_COL_YELLOW (gslc_tsColor) {255,255,0} ///< Yellow
#define GSLC_COL_YELLOW_DK (gslc_tsColor) {64,64,0} ///< Yellow (dark)
#define GSLC_COL_PURPLE (gslc_tsColor) {128,0,128} ///< Purple
#define GSLC_COL_CYAN (gslc_tsColor) {0,255,255} ///< Cyan
#define GSLC_COL_MAGENTA (gslc_tsColor) {255,0,255} ///< Magenta
#define GSLC_COL_TEAL (gslc_tsColor) {0,128,128} ///< Teal
#define GSLC_COL_ORANGE (gslc_tsColor) {255,165,0} ///< Orange
#define GSLC_COL_BROWN (gslc_tsColor) {165,42,42} ///< Brown
// Monochrome definitions
#define GSLC_COLMONO_BLACK (gslc_tsColor) {255,255,255} ///< Black
#define GSLC_COLMONO_WHITE (gslc_tsColor) { 0, 0, 0} ///< White
/// Raw input event types: touch, key, GPIOs
typedef enum {
GSLC_INPUT_NONE, ///< No input event
GSLC_INPUT_TOUCH, ///< Touch / mouse event
GSLC_INPUT_KEY_DOWN, ///< Key press down / pin input asserted
GSLC_INPUT_KEY_UP, ///< Key press up (released)
GSLC_INPUT_PIN_ASSERT, ///< GPIO pin input asserted (eg. set to 1 / High)
GSLC_INPUT_PIN_DEASSERT, ///< GPIO pin input deasserted (eg. set to 0 / Low)
} gslc_teInputRawEvent;
/// GUI Action Requested
/// These actions are usually the result of an InputMap lookup
typedef enum {
GSLC_ACTION_UNDEF, ///< Invalid action
GSLC_ACTION_NONE, ///< No action to perform
GSLC_ACTION_FOCUS_PREV, ///< Advance focus to the previous GUI element
GSLC_ACTION_FOCUS_NEXT, ///< Advance focus to the next GUI element
GSLC_ACTION_SELECT, ///< Select the currently focused GUI element
GSLC_ACTION_SET_REL, ///< Adjust value (relative) of focused element
GSLC_ACTION_SET_ABS, ///< Adjust value (absolute) of focused element
GSLC_ACTION_DEBUG ///< Internal debug action
} gslc_teAction;
/// General purpose pin/button constants
typedef enum {
GSLC_PIN_BTN_A, ///< Button A (short press)
GSLC_PIN_BTN_A_LONG, ///< Button A (long press)
GSLC_PIN_BTN_B, ///< Button B (short press)
GSLC_PIN_BTN_B_LONG, ///< Button B (long press)
GSLC_PIN_BTN_C, ///< Button C (short press)
GSLC_PIN_BTN_C_LONG, ///< Button C (long press)
GSLC_PIN_BTN_D, ///< Button D (short press)
GSLC_PIN_BTN_D_LONG, ///< Button D (long press)
GSLC_PIN_BTN_E, ///< Button E (short press)
GSLC_PIN_BTN_E_LONG, ///< Button E (long press)
GSLC_PIN_BTN_UP, ///< Button Up (short press)
GSLC_PIN_BTN_DOWN, ///< Button Down (short press)
GSLC_PIN_BTN_LEFT, ///< Button Left (short press)
GSLC_PIN_BTN_RIGHT, ///< Button Right (short press)
GSLC_PIN_BTN_SEL, ///< Button Select (short press)
} gslc_tePin;
/// Processed event from input raw events and actions
typedef enum {
GSLC_TOUCH_NONE = 0, ///< No touch event active
// Indexed state (ie. key/GPIO selects specific element vs touch coordinate)
GSLC_TOUCH_TYPE_MASK = (1<<7), ///< Mask for type: coord/direct mode
GSLC_TOUCH_COORD = (0<<7), ///< Event based on touch coordinate
GSLC_TOUCH_DIRECT = (1<<7), ///< Event based on specific element index (keyboard/GPIO action)
GSLC_TOUCH_SUBTYPE_MASK = (15<<0), ///< Mask for subtype
// Coordinate-based events
GSLC_TOUCH_DOWN = GSLC_TOUCH_COORD | ( 1<<0), ///< Touch event (down)
GSLC_TOUCH_DOWN_IN = GSLC_TOUCH_COORD | ( 2<<0), ///< Touch event (down inside tracked element)
GSLC_TOUCH_DOWN_OUT = GSLC_TOUCH_COORD | ( 3<<0), ///< Touch event (down outside tracked element)
GSLC_TOUCH_UP = GSLC_TOUCH_COORD | ( 4<<0), ///< Touch event (up)
GSLC_TOUCH_UP_IN = GSLC_TOUCH_COORD | ( 5<<0), ///< Touch event (up inside tracked element)
GSLC_TOUCH_UP_OUT = GSLC_TOUCH_COORD | ( 6<<0), ///< Touch event (up outside tracked element)
GSLC_TOUCH_MOVE = GSLC_TOUCH_COORD | ( 7<<0), ///< Touch event (move)
GSLC_TOUCH_MOVE_IN = GSLC_TOUCH_COORD | ( 8<<0), ///< Touch event (move inside tracked element)
GSLC_TOUCH_MOVE_OUT = GSLC_TOUCH_COORD | ( 9<<0), ///< Touch event (move outside tracked element)
// Index-based events
GSLC_TOUCH_FOCUS_ON = GSLC_TOUCH_DIRECT | ( 1<<0), ///< Direct event focus on element
GSLC_TOUCH_FOCUS_OFF = GSLC_TOUCH_DIRECT | ( 2<<0), ///< Direct event focus away from focused element
GSLC_TOUCH_FOCUS_SELECT = GSLC_TOUCH_DIRECT | ( 3<<0), ///< Direct event select focus element
GSLC_TOUCH_SET_REL = GSLC_TOUCH_DIRECT | ( 4<<0), ///< Direct event set value (relative) on focus element
GSLC_TOUCH_SET_ABS = GSLC_TOUCH_DIRECT | ( 5<<0), ///< Direct event set value (absolute) on focus element
} gslc_teTouch;
/// Status of a module's initialization
typedef enum {
GSLC_INITSTAT_UNDEF = 0, ///< Module status has not been defined yet
GSLC_INITSTAT_INACTIVE, ///< Module is not enabled
GSLC_INITSTAT_FAIL, ///< Module is enabled but failed to init
GSLC_INITSTAT_ACTIVE ///< Module is enabled and initalized OK
} gslc_teInitStat;
/// Additional definitions for Touch Handling
/// These macros define the transforms used in remapping the touchscreen
/// inputs on the basis of the GUI nRotation setting.
#define TOUCH_ROTATION_DATA 0x6350
#define TOUCH_ROTATION_SWAPXY(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 2 ) & 0x01 )
#define TOUCH_ROTATION_FLIPX(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 1 ) & 0x01 )
#define TOUCH_ROTATION_FLIPY(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 0 ) & 0x01 )
/// Event types
typedef enum {
GSLC_EVT_NONE, ///< No event; ignore
GSLC_EVT_DRAW, ///< Perform redraw
GSLC_EVT_TOUCH, ///< Track touch event
GSLC_EVT_TICK, ///< Perform background tick handling
GSLV_EVT_CUSTOM ///< Custom event
} gslc_teEventType;
/// Event sub-types
typedef enum {
GSLC_EVTSUB_NONE,
GSLC_EVTSUB_DRAW_NEEDED, ///< Incremental redraw (as needed)
GSLC_EVTSUB_DRAW_FORCE ///< Force a full redraw
} gslc_teEventSubType;
/// Redraw types
typedef enum {
GSLC_REDRAW_NONE, ///< No redraw requested
GSLC_REDRAW_FULL, ///< Full redraw of element requested
GSLC_REDRAW_INC ///< Incremental redraw of element requested
} gslc_teRedrawType;
/// Font Reference types
/// - The Font Reference type defines the way in which a
/// font is selected. In some device targets (such as
/// LINUX SDL) a filename to a font file is provided. In
/// others (such as Arduino, ESP8266), a pointer is given to a
/// font structure (or NULL for default).
typedef enum {
GSLC_FONTREF_FNAME, ///< Font reference is a filename (full path)
GSLC_FONTREF_PTR ///< Font reference is a pointer to a font structure
} gslc_teFontRefType;
/// Font Reference modes
/// - The Font Reference mode defines the source for the
/// selected font. For graphics libraries that offer
/// multiple types of fonts, this can be used to differentiate
/// between a default font, hardware fonts, software fonts, etc.
/// - The encoding between the different modes is driver-specific.
typedef enum {
GSLC_FONTREF_MODE_DEFAULT, ///< Default font mode
GSLC_FONTREF_MODE_1, ///< Font mode 1
GSLC_FONTREF_MODE_2, ///< Font mode 2
GSLC_FONTREF_MODE_3 ///< Font mode 3
} gslc_teFontRefMode;
/// Element reference flags: Describes characteristics of an element
/// - Primarily used to support relocation of elements to Flash memory (PROGMEM)
typedef enum {
GSLC_ELEMREF_NONE = 0, ///< No element defined
// Define element sources
GSLC_ELEMREF_SRC_RAM = (1<<0), ///< Element is read/write
///< Stored in RAM (internal element array))
///< Access directly
GSLC_ELEMREF_SRC_PROG = (2<<0), ///< Element is read-only / const
///< Stored in FLASH (external to element array)
///< Access via PROGMEM
GSLC_ELEMREF_SRC_CONST = (3<<0), ///< Element is read-only / const
///< Stored in FLASH (external to element array)
///< Access directly
// Element State
GSLC_ELEMREF_REDRAW_NONE = (0<<4), ///< No redraw requested
GSLC_ELEMREF_REDRAW_FULL = (1<<4), ///< Full redraw of element requested
GSLC_ELEMREF_REDRAW_INC = (2<<4), ///< Incremental redraw of element requested
GSLC_ELEMREF_GLOWING = (1<<6), ///< Element state is glowing
GSLC_ELEMREF_VISIBLE = (1<<7), ///< Element is currently shown (ie. visible)
// Mask values for bitfield comparisons
GSLC_ELEMREF_SRC = (3<<0), ///< Mask for Source flags
GSLC_ELEMREF_REDRAW_MASK = (3<<4), ///< Mask for Redraw flags
} gslc_teElemRefFlags;
/// Define the default element reference flags for new elements
#define GSLC_ELEMREF_DEFAULT (GSLC_ELEMREF_SRC_RAM | GSLC_ELEMREF_VISIBLE)
/// Image reference flags: Describes characteristics of an image reference
typedef enum {
GSLC_IMGREF_NONE = 0, ///< No image defined
// Define image sources
GSLC_IMGREF_SRC_FILE = (1<<0), ///< Image is stored in file system
GSLC_IMGREF_SRC_SD = (2<<0), ///< Image is stored on SD card
GSLC_IMGREF_SRC_RAM = (3<<0), ///< Image is stored in RAM
GSLC_IMGREF_SRC_PROG = (4<<0), ///< Image is stored in program memory (PROGMEM)
// Define image types
GSLC_IMGREF_FMT_BMP24 = (1<<4), ///< Image format is BMP (24-bit)
GSLC_IMGREF_FMT_BMP16 = (2<<4), ///< Image format is BMP (16-bit RGB565)
GSLC_IMGREF_FMT_RAW1 = (3<<4), ///< Image format is raw monochrome (1-bit)
GSLC_IMGREF_FMT_JPG = (4<<4), ///< Image format is JPG (ESP32/ESP8366)
// Mask values for bitfield comparisons
GSLC_IMGREF_SRC = (7<<0), ///< Mask for Source flags
GSLC_IMGREF_FMT = (7<<4), ///< Mask for Format flags
} gslc_teImgRefFlags;
/// Text reference flags: Describes the characteristics of a text string
/// (ie. whether internal to element or external and RAM vs Flash).)
///
/// Supported flag combinations are:
/// - ALLOC_NONE
/// - ALLOC_INT | MEM_RAM
/// - ALLOC_EXT | MEM_RAM
/// - ALLOC_EXT | MEM_PROG
typedef enum {
// Values
GSLC_TXT_MEM_RAM = (0<<0), ///< Text string is in SRAM (read-write)
GSLC_TXT_MEM_PROG = (1<<0), ///< Text string is in PROGMEM (read-only)
GSLC_TXT_ALLOC_NONE = (0<<2), ///< No text string present
GSLC_TXT_ALLOC_INT = (1<<2), ///< Text string allocated in internal element memory (GSLC_STR_LOCAL=1)
GSLC_TXT_ALLOC_EXT = (2<<2), ///< Text string allocated in external memory (GSLC_STR_LOCAL=0), ie. user code
GSLC_TXT_ENC_PLAIN = (0<<4), ///< Encoding is plain text (LATIN1))
GSLC_TXT_ENC_UTF8 = (1<<4), ///< Encoding is UTF-8
// Masks
GSLC_TXT_MEM = (3<<0), ///< Mask for updating text memory type
GSLC_TXT_ALLOC = (3<<2), ///< Mask for updating location of text string buffer allocation
GSLC_TXT_ENC = (3<<4), ///< Mask for updating text encoding
// Defaults
GSLC_TXT_DEFAULT = GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_NONE | GSLC_TXT_ENC_PLAIN,
} gslc_teTxtFlags;
// -----------------------------------------------------------------------
// Forward declarations
// -----------------------------------------------------------------------
typedef struct gslc_tsElem gslc_tsElem;
typedef struct gslc_tsEvent gslc_tsEvent;
// -----------------------------------------------------------------------
// Callback functions
// -----------------------------------------------------------------------
/// Callback function for element drawing
typedef bool (*GSLC_CB_EVENT)(void* pvGui,gslc_tsEvent sEvent);
/// Callback function for element drawing
typedef bool (*GSLC_CB_DRAW)(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
/// Callback function for element touch tracking
typedef bool (*GSLC_CB_TOUCH)(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);
/// Callback function for element tick
typedef bool (*GSLC_CB_TICK)(void* pvGui,void* pvElemRef);
/// Callback function for pin polling
typedef bool (*GSLC_CB_PIN_POLL)(void* pvGui,int16_t* pnPinInd,int16_t* pnPinVal);
/// Callback function for element input ready
typedef bool (*GSLC_CB_INPUT)(void* pvGui,void* pvElemRef,int16_t nStatus,void* pvData);
// -----------------------------------------------------------------------
// Structures
// -----------------------------------------------------------------------
/// Rectangular region. Defines X,Y corner coordinates plus dimensions.
typedef struct gslc_tsRect {
int16_t x; ///< X coordinate of corner
int16_t y; ///< Y coordinate of corner
uint16_t w; ///< Width of region
uint16_t h; ///< Height of region
} gslc_tsRect;
/// Define point coordinates
typedef struct gslc_tsPt {
int16_t x; ///< X coordinate
int16_t y; ///< Y coordinate
} gslc_tsPt;
/// Color structure. Defines RGB triplet.
typedef struct gslc_tsColor {
uint8_t r; ///< RGB red value
uint8_t g; ///< RGB green value
uint8_t b; ///< RGB blue value
} gslc_tsColor;
/// Event structure
typedef struct gslc_tsEvent {
gslc_teEventType eType; ///< Event type
uint8_t nSubType; ///< Event sub-type
void* pvScope; ///< Event target scope (eg. Page,Collection,Event)
void* pvData; ///< Generic data pointer for event. This member is
///< used to either pass a pointer to a simple data
///< datatype (such as Element or Collection) or
///< to a another structure that contains multiple fields.
} gslc_tsEvent;
/// Structure used to pass touch data through event
typedef struct gslc_tsEventTouch {
gslc_teTouch eTouch; ///< Touch state
int16_t nX; ///< Touch X coordinate (or param1)
int16_t nY; ///< Touch Y coordinate (or param2)
} gslc_tsEventTouch;
/// Font reference structure
typedef struct {
int16_t nId; ///< Font ID specified by user
gslc_teFontRefType eFontRefType; ///< Font reference type
gslc_teFontRefMode eFontRefMode; ///< Font reference mode
const void* pvFont; ///< Void ptr to the font reference (type defined by driver)
uint16_t nSize; ///< Font size
} gslc_tsFont;
/// Image reference structure
typedef struct {
const unsigned char* pImgBuf; ///< Pointer to input image buffer in memory [RAM,FLASH]
const char* pFname; ///< Pathname to input image file [FILE,SD]
gslc_teImgRefFlags eImgFlags; ///< Image reference flags
void* pvImgRaw; ///< Ptr to raw output image data (for pre-loaded images)
} gslc_tsImgRef;
/// Element reference structure
typedef struct {
gslc_tsElem* pElem; ///< Pointer to element in memory [RAM,FLASH]
gslc_teElemRefFlags eElemFlags; ///< Element reference flags
} gslc_tsElemRef;
///
/// Element Struct
/// - Represents a single graphic element in the GUIslice environment
/// - A page is made up of a number of elements
/// - Each element is created with a user-specified ID for further
/// accesses (or GSLC_ID_AUTO for it to be auto-generated)
/// - Display order of elements in a page is based upon the creation order
/// - Extensions to the core element types is provided through the
/// pXData reference and pfuncX* callback functions.
///
typedef struct gslc_tsElem {
int16_t nId; ///< Element ID specified by user
uint8_t nFeatures; ///< Element feature vector (appearance/behavior))
int16_t nType; ///< Element type enumeration
gslc_tsRect rElem; ///< Rect region containing element
int16_t nGroup; ///< Group ID that the element belongs to
gslc_tsColor colElemFrame; ///< Color for frame
gslc_tsColor colElemFill; ///< Color for background fill
gslc_tsColor colElemFrameGlow; ///< Color to use for frame when glowing
gslc_tsColor colElemFillGlow; ///< Color to use for fill when glowing
gslc_tsImgRef sImgRefNorm; ///< Image reference to draw (normal)
gslc_tsImgRef sImgRefGlow; ///< Image reference to draw (glowing)
// if (GSLC_FEATURE_COMPOUND)
/// Parent element reference. Used during redraw
/// to notify parent elements that they require
/// redraw as well. Primary usage is in compound
/// elements.
/// NOTE: Although this field is only used in GLSC_COMPOUND mode, it
/// is not wrapped in an ifdef because the ElemCreate*_P()
/// function macros currently initialize this field.
gslc_tsElemRef* pElemRefParent;
// endif
// Text handling
#if (GSLC_LOCAL_STR)
char pStrBuf[GSLC_LOCAL_STR_LEN]; ///< Text string to overlay
#else
char* pStrBuf; ///< Ptr to text string buffer to overlay
#endif
uint8_t nStrBufMax; ///< Size of string buffer
gslc_teTxtFlags eTxtFlags; ///< Flags associated with text buffer
gslc_tsColor colElemText; ///< Color of overlay text
gslc_tsColor colElemTextGlow; ///< Color of overlay text when glowing
int8_t eTxtAlign; ///< Alignment of overlay text
int8_t nTxtMarginX; ///< Margin of overlay text within rect region (x offset)
int8_t nTxtMarginY; ///< Margin of overlay text within rect region (y offset)
gslc_tsFont* pTxtFont; ///< Ptr to Font for overlay text
// Extended data elements
void* pXData; ///< Ptr to extended data structure
// Callback functions
GSLC_CB_EVENT pfuncXEvent; ///< UNUSED: Callback func ptr for event tree (draw,touch,tick)
GSLC_CB_DRAW pfuncXDraw; ///< Callback func ptr for custom drawing
GSLC_CB_TOUCH pfuncXTouch; ///< Callback func ptr for touch
GSLC_CB_TICK pfuncXTick; ///< Callback func ptr for timer/main loop tick
} gslc_tsElem;
/// Element collection struct
/// - Collections are used to maintain a list of elements and any
/// touch tracking status.
/// - Pages and Compound Elements both instantiate a Collection
typedef struct {
gslc_tsElem* asElem; ///< Array of elements
uint16_t nElemMax; ///< Maximum number of elements to allocate (in RAM)
uint16_t nElemCnt; ///< Number of elements allocated
int16_t nElemAutoIdNext; ///< Next Element ID for auto-assignment
gslc_tsElemRef* asElemRef; ///< Array of element references
uint16_t nElemRefMax; ///< Maximum number of element references to allocate
uint16_t nElemRefCnt; ///< Number of element references allocated
// Touch tracking
gslc_tsElemRef* pElemRefTracked; ///< Element reference currently being touch-tracked (NULL for none)
// Input focus
int16_t nElemIndFocused; ///< Element index currently in focus (eg. by keyboard/pin control), GSLC_IND_NONE for none
// Callback functions
//GSLC_CB_EVENT pfuncXEvent; ///< UNUSED: Callback func ptr for events
} gslc_tsCollect;
/// Page structure
/// - A page contains a collection of elements
/// - Many redraw functions operate at a page level
/// - Maintains state as to whether redraw or screen flip is required
typedef struct {
gslc_tsCollect sCollect; ///< Collection of elements on page
int16_t nPageId; ///< Page identifier
// Callback functions
//GSLC_CB_EVENT pfuncXEvent; ///< UNUSED: Callback func ptr for events
// Bounding region
gslc_tsRect rBounds; ///< Bounding rect for page elements
} gslc_tsPage;
/// Input mapping
/// - Describes mapping from keyboard or GPIO input
/// to a GUI action (such as changing the current
/// element focus)
/// - This is generally used to support keyboard or GPIO
/// control over the GUI operation
typedef struct {
gslc_teInputRawEvent eEvent; ///< The input event
int16_t nVal; ///< The value associated with the input event
gslc_teAction eAction; ///< Resulting action
int16_t nActionVal; ///< The value for the output action
} gslc_tsInputMap;
/// GUI structure
/// - Contains all GUI state and content
/// - Maintains list of one or more pages
typedef struct {
uint16_t nDispW; ///< Width of the display (pixels)
uint16_t nDispH; ///< Height of the display (pixels)
uint16_t nDisp0W; ///< Width of the display (pixels) in native orientation
uint16_t nDisp0H; ///< Height of the display (pixels) in native orientation
uint8_t nDispDepth; ///< Bit depth of display (bits per pixel)
// NOTE: The following config is currently only used by the Adafruit-GFX & TFT_eSPI drivers
uint8_t nRotation; ///< Adafruit GFX Rotation of display
#if !defined(DRV_TOUCH_NONE)
// Touch remapping
uint8_t nTouchRotation; ///< Touchscreen rotation offset vs display
uint8_t nSwapXY; ///< Adafruit GFX Touch Swap x and y axes
uint8_t nFlipX; ///< Adafruit GFX Touch Flip x axis
uint8_t nFlipY; ///< Adafruit GFX Touch Flip x axis
// Calibration for resistive touch displays
uint16_t nTouchCalXMin; ///< Calibration X minimum reading
uint16_t nTouchCalXMax; ///< Calibration X maximum reading
uint16_t nTouchCalYMin; ///< Calibration Y minimum reading
uint16_t nTouchCalYMax; ///< Calibration Y maximum reading
#endif
gslc_tsFont* asFont; ///< Collection of loaded fonts
uint8_t nFontMax; ///< Maximum number of fonts to allocate
uint8_t nFontCnt; ///< Number of fonts allocated
uint8_t nRoundRadius; ///< Radius for rounded elements
gslc_tsColor sTransCol; ///< Color used for transparent image regions (GSLC_BMP_TRANS_EN=1)
#if (GSLC_FEATURE_COMPOUND)
gslc_tsElem sElemTmp; ///< Temporary element
gslc_tsElemRef sElemRefTmp; ///< Temporary element reference
#endif
gslc_tsElem sElemTmpProg; ///< Temporary element for Flash compatibility
gslc_teInitStat eInitStatTouch; ///< Status of touch initialization
// TODO: exclude these in DRV_TOUCH_NONE
int16_t nTouchLastX; ///< Last touch event X coord
int16_t nTouchLastY; ///< Last touch event Y coord
uint16_t nTouchLastPress; ///< Last touch event pressure (0=none))
bool bTouchRemapEn; ///< Enable touch remapping?
bool bTouchRemapYX; ///< Enable touch controller swapping of X & Y
void* pvDriver; ///< Driver-specific members (gslc_tsDriver*)
bool bRedrawPartialEn; ///< Driver supports partial page redraw.
///< If true, only changed elements are redrawn
///< during next page redraw command.
///< If false, entire page is redrawn when any
///< element has been updated prior to next
///< page redraw command.
// Primary surface definitions
gslc_tsImgRef sImgRefBkgnd; ///< Image reference for background
uint8_t nFrameRateCnt; ///< Diagnostic frame rate count
uint8_t nFrameRateStart; ///< Diagnostic frame rate timestamp
// Pages
gslc_tsPage* asPage; ///< Array of all pages defined in system
uint8_t nPageMax; ///< Maximum number of pages that can be defined
uint8_t nPageCnt; ///< Current number of pages defined
gslc_tsPage* apPageStack[GSLC_STACK__MAX]; ///< Stack of pages
bool abPageStackActive[GSLC_STACK__MAX]; ///< Whether page in stack can receive touch events
bool abPageStackDoDraw[GSLC_STACK__MAX]; ///< Whether page in stack is still actively drawn
// Redraw of screen (ie. across page stack)
bool bScreenNeedRedraw; ///< Screen requires a redraw
bool bScreenNeedFlip; ///< Screen requires a page flip
// Current clip region
bool bInvalidateEn; ///< A region of the display has been invalidated
gslc_tsRect rInvalidateRect; ///< The rect region that has been invalidated
// Callback functions
//GSLC_CB_EVENT pfuncXEvent; ///< UNUSED: Callback func ptr for events
GSLC_CB_PIN_POLL pfuncPinPoll; ///< Callback func ptr for pin polling
// Key/pin input control mapping
gslc_tsInputMap* asInputMap; ///< Array of input maps
uint8_t nInputMapMax; ///< Maximum number of input maps
uint8_t nInputMapCnt; ///< Current number of input maps
} gslc_tsGui;
// ------------------------------------------------------------------------
/// \defgroup _GeneralFunc_ General Functions
/// General functions for configuring the GUI
/// @{
// ------------------------------------------------------------------------
///
/// Get the GUIslice version number
///
/// \param[in] pGui: Pointer to GUI
///
/// \return String containing version number
///
char* gslc_GetVer(gslc_tsGui* pGui);
///
/// Get the GUIslice display driver name
///
/// \param[in] pGui: Pointer to GUI
///
/// \return String containing driver name
///
const char* gslc_GetNameDisp(gslc_tsGui* pGui);
///
/// Get the GUIslice touch driver name
///
/// \param[in] pGui: Pointer to GUI
///
/// \return String containing driver name
///
const char* gslc_GetNameTouch(gslc_tsGui* pGui);
///
/// Get the native display driver instance
/// - This can be useful to access special commands
/// available in the selected driver.
///
/// \param[in] pGui: Pointer to GUI
///
/// \return Void pointer to the display driver instance.
/// This pointer should be typecast to the particular
/// driver being used. If no driver was created then
/// this function will return NULL.
///
void* gslc_GetDriverDisp(gslc_tsGui* pGui);
///
/// Get the native touch driver instance
/// - This can be useful to access special commands
/// available in the selected driver.
///
/// \param[in] pGui: Pointer to GUI
///
/// \return Void pointer to the touch driver instance.
/// This pointer should be typecast to the particular
/// driver being used. If no driver was created then
/// this function will return NULL.
///
void* gslc_GetDriverTouch(gslc_tsGui* pGui);
///
/// Initialize the GUIslice library
/// - Configures the primary screen surface(s)
/// - Initializes font support
///
/// PRE:
/// - The environment variables should be configured before
/// calling gslc_Init().
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pvDriver: Void pointer to Driver struct (gslc_tsDriver*)
/// \param[in] asPage: Pointer to Page array
/// \param[in] nMaxPage: Size of Page array
/// \param[in] asFont: Pointer to Font array
/// \param[in] nMaxFont: Size of Font array
///
/// \return true if success, false if fail
///
bool gslc_Init(gslc_tsGui* pGui,void* pvDriver,gslc_tsPage* asPage,uint8_t nMaxPage,gslc_tsFont* asFont,uint8_t nMaxFont);
///
/// Initialize debug output
/// - Defines the user function used for debug/error output
/// - pfunc is responsible for outputing a single character
/// - For Arduino, this user function would typically call Serial.print()
///
/// \param[in] pfunc: Pointer to user character-out function
///
/// \return none
///
void gslc_InitDebug(GSLC_CB_DEBUG_OUT pfunc);
///
/// Optimized printf routine for GUIslice debug/error output
/// - Only supports '%s','%d','%u' tokens
/// - Calls on the output function configured in gslc_InitDebug()
///
/// \param[in] pFmt: Format string to use for printing
/// \param[in] ...: Variable parameter list
///
/// \return none
void gslc_DebugPrintf(const char* pFmt, ...);
///
/// Dynamically change rotation, automatically adapt touchscreen axes swap/flip
///
/// The function assumes that the touchscreen settings for swap and flip
/// in the GUIslice config are valid for the configured GSLC_ROTATE.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nRotation: Screen Rotation value (0, 1, 2 or 3)
///
/// \return true if success, false otherwise
///
bool gslc_GuiRotate(gslc_tsGui* pGui, uint8_t nRotation);
///
/// Exit the GUIslice environment
/// - Calls lower-level destructors to clean up any initialized subsystems
/// and deletes any created elements or fonts
///
/// \param[in] pGui: Pointer to GUI
///
/// \return None
///
void gslc_Quit(gslc_tsGui* pGui);
///
/// Perform main GUIslice handling functions
/// - Handles any touch events
/// - Performs any necessary screen redraw
///
/// \param[in] pGui: Pointer to GUI
///
/// \return None
///
void gslc_Update(gslc_tsGui* pGui);
///
/// Configure the background to use a bitmap image
/// - The background is used when redrawing the entire page
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] sImgRef: Image reference
///
/// \return true if success, false if fail
///
bool gslc_SetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
///
/// Configure the background to use a solid color
/// - The background is used when redrawing the entire page
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nCol: RGB Color to use
///
/// \return true if success, false if fail
///
bool gslc_SetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
///
/// Configure the color to use for image transparency
/// - Drawing a BMP with transparency enabled will cause
/// regions in this specific color to appear transparent
/// - This API overrides the config option GSLC_BMP_TRANS_RGB
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nCol: RGB Color to use
///
/// \return true if success, false if fail
///
bool gslc_SetTransparentColor(gslc_tsGui* pGui,gslc_tsColor nCol);
///
/// Set the clipping rectangle for further drawing
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pRect: Pointer to Rect for clipping (or NULL for entire screen)
///
/// \return true if success, false if error
///
bool gslc_SetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _GraphicsGenFunc_ Graphics General Functions
/// Helper functions that support graphics operations
/// @{
// ------------------------------------------------------------------------
///
/// Determine if a coordinate is inside of a rectangular region.
/// - This routine is useful in determining if a touch
/// coordinate is inside of a button.
///
/// \param[in] nSelX: X coordinate to test
/// \param[in] nSelY: X coordinate to test
/// \param[in] rRect: Rectangular region to compare against
///
/// \return true if inside region, false otherwise
///
bool gslc_IsInRect(int16_t nSelX,int16_t nSelY,gslc_tsRect rRect);
///
/// Expand or contract a rectangle in width and/or height (equal
/// amounts on both side), based on the centerpoint of the rectangle.
///
/// \param[in] rRect: Rectangular region before resizing
/// \param[in] nExpandW: Number of pixels to expand the width (if positive)
/// of contract the width (if negative)
/// \param[in] nExpandH: Number of pixels to expand the height (if positive)
/// of contract the height (if negative)
///
/// \return gslc_tsRect() with resized dimensions
///
gslc_tsRect gslc_ExpandRect(gslc_tsRect rRect,int16_t nExpandW,int16_t nExpandH);
///
/// Determine if a coordinate is inside of a width x height region.
/// - This routine is useful in determining if a relative coordinate
/// is within a given W x H dimension
///
/// \param[in] nSelX: X coordinate to test
/// \param[in] nSelY: X coordinate to test
/// \param[in] nWidth: Width to test against
/// \param[in] nHeight: Height to test against
///
/// \return true if inside region, false otherwise
///
bool gslc_IsInWH(int16_t nSelX,int16_t nSelY,uint16_t nWidth,uint16_t nHeight);
///
/// Expand a rect to include another rect
/// - This routine can be useful to modify an invalidation region to
/// include another modified element
///
/// \param[in] pRect: Initial rect region
/// \param[in] rAddRect: Rectangle to add to the rect region
///
/// \return none
///
void gslc_UnionRect(gslc_tsRect* pRect, gslc_tsRect rAddRect);
///
/// Reset the invalidation region
///
/// \param[in] pGui: Pointer to GUI
///
/// \return none
///
void gslc_InvalidateRgnReset(gslc_tsGui* pGui);
///
/// Include an entire page (eg. from a page stack) in the invalidation region
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pPage: Pointer to page
///
/// \return none
///
void gslc_InvalidateRgnPage(gslc_tsGui* pGui, gslc_tsPage* pPage);
///
/// Mark the entire screen as invalidated
///
/// \param[in] pGui: Pointer to GUI
///
/// \return none
///
void gslc_InvalidateRgnScreen(gslc_tsGui* pGui);
///
/// Add a rectangular region to the invalidation region
/// - This is usually called when an element has been modified
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] rAddRect: Rectangle to add to the invalidation region
///
/// \return none
///
void gslc_InvalidateRgnAdd(gslc_tsGui* pGui, gslc_tsRect rAddRect);
///
/// Perform basic clipping of a single point to a clipping region
///
/// \param[in] pClipRect: Pointer to clipping region
/// \param[in] nX: X coordinate of point
/// \param[in] nY: Y coordinate of point
///
/// \return true if point is visible, false if it should be discarded
///
bool gslc_ClipPt(gslc_tsRect* pClipRect,int16_t nX,int16_t nY);
///
/// Perform basic clipping of a line to a clipping region
/// - Implements Cohen-Sutherland algorithm
/// - Coordinates in parameter list are modified to fit the region
///
/// \param[in] pClipRect: Pointer to clipping region
/// \param[inout] pnX0: Ptr to X coordinate of line start
/// \param[inout] pnY0: Ptr to Y coordinate of line start
/// \param[inout] pnX1: Ptr to X coordinate of line end
/// \param[inout] pnY1: Ptr to Y coordinate of line end
///
/// \return true if line is visible, false if it should be discarded
///
bool gslc_ClipLine(gslc_tsRect* pClipRect,int16_t* pnX0,int16_t* pnY0,int16_t* pnX1,int16_t* pnY1);
///
/// Perform basic clipping of a rectangle to a clipping region
/// - Coordinates in parameter rect are modified to fit the region
///
/// \param[in] pClipRect: Pointer to clipping region
/// \param[inout] pRect: Ptr to rectangle
///
/// \return true if rect is visible, false if it should be discarded
///
bool gslc_ClipRect(gslc_tsRect* pClipRect,gslc_tsRect* pRect);
///
/// Create an image reference to a bitmap file in LINUX filesystem
///
/// \param[in] pFname Pointer to filename string of image in filesystem
/// \param[in] eFmt Image format
///
/// \return Loaded image reference
///
gslc_tsImgRef gslc_GetImageFromFile(const char* pFname,gslc_teImgRefFlags eFmt);
///
/// Create an image reference to a bitmap file in SD card
///
/// \param[in] pFname Pointer to filename string of image in SD card
/// \param[in] eFmt Image format
///
/// \return Loaded image reference
///
gslc_tsImgRef gslc_GetImageFromSD(const char* pFname,gslc_teImgRefFlags eFmt);
///
/// Create an image reference to a bitmap in SRAM
///
/// \param[in] pImgBuf Pointer to image buffer in memory
/// \param[in] eFmt Image format
///
/// \return Loaded image reference
///
gslc_tsImgRef gslc_GetImageFromRam(unsigned char* pImgBuf,gslc_teImgRefFlags eFmt);
///
/// Create an image reference to a bitmap in program memory (PROGMEM)
///
/// \param[in] pImgBuf Pointer to image buffer in memory
/// \param[in] eFmt Image format
///
/// \return Loaded image reference
///
gslc_tsImgRef gslc_GetImageFromProg(const unsigned char* pImgBuf,gslc_teImgRefFlags eFmt);
///
/// Convert polar coordinate to cartesian
///
/// \param[in] nRad Radius of ray
/// \param[in] n64Ang Angle of ray (in units of 1/64 degrees, 0 is up)
/// \param[out] nDX X offset for ray end
/// \param[out] nDY Y offset for ray end
///
/// \return none
///
void gslc_PolarToXY(uint16_t nRad,int16_t n64Ang,int16_t* nDX,int16_t* nDY);
///
/// Calculate fixed-point sine function from fractional degrees
/// - Depending on configuration, the result is derived from either
/// floating point math library or fixed point lookup table.
/// - gslc_sinFX(nAngDeg*64)/32768.0 = sin(nAngDeg*2pi/360)
///
/// \param[in] n64Ang Angle (in units of 1/64 degrees)
///
/// \return Fixed-point sine result. Signed 16-bit; divide by 32768
/// to get the actual value.
///
int16_t gslc_sinFX(int16_t n64Ang);
///
/// Calculate fixed-point cosine function from fractional degrees
/// - Depending on configuration, the result is derived from either
/// floating point math library or fixed point lookup table.
/// - gslc_cosFX(nAngDeg*64)/32768.0 = cos(nAngDeg*2pi/360)
///
/// \param[in] n64Ang Angle (in units of 1/64 degrees)
///
/// \return Fixed-point cosine result. Signed 16-bit; divide by 32768
/// to get the actual value.
///
int16_t gslc_cosFX(int16_t n64Ang);
///
/// Create a color based on a blend between two colors
///
/// \param[in] colStart: Starting color
/// \param[in] colEnd: Ending color
/// \param[in] nMidAmt: Position (0..1000) between start and end color at which the
/// midpoint between colors should appear. Normally set to 500 (half-way).
/// \param[in] nBlendAmt: The position (0..1000) between start and end at which we
/// want to calculate the resulting blended color.
///
/// \return Blended color
///
gslc_tsColor gslc_ColorBlend2(gslc_tsColor colStart,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt);
///
/// Create a color based on a blend between three colors
///
/// \param[in] colStart: Starting color
/// \param[in] colMid: Intermediate color
/// \param[in] colEnd: Ending color
/// \param[in] nMidAmt: Position (0..1000) between start and end color at which the
/// intermediate color should appear.
/// \param[in] nBlendAmt: The position (0..1000) between start and end at which we
/// want to calculate the resulting blended color.
///
/// \return Blended color
///
gslc_tsColor gslc_ColorBlend3(gslc_tsColor colStart,gslc_tsColor colMid,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt);
///
/// Check whether two colors are equal
///
/// \param[in] a: First color
/// \param[in] b: Second color
///
/// \return True iff a and b are the same color.
///
bool gslc_ColorEqual(gslc_tsColor a,gslc_tsColor b);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _GraphicsPrimFunc_ Graphics Primitive Functions
/// These routines cause immediate drawing to occur on the
/// primary screen
/// @{
// ------------------------------------------------------------------------
///
/// Set a pixel on the active screen to the given color with lock
/// - Calls upon gslc_DrvDrawSetPixelRaw() but wraps with a surface lock lock
/// - If repeated access is needed, use gslc_DrvDrawSetPixelRaw() instead
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nX: Pixel X coordinate to set
/// \param[in] nY: Pixel Y coordinate to set
/// \param[in] nCol: Color pixel value to assign
///
/// \return none
///
void gslc_DrawSetPixel(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
///
/// Draw an arbitrary line using Bresenham's algorithm
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nX0: X coordinate of line startpoint
/// \param[in] nY0: Y coordinate of line startpoint
/// \param[in] nX1: X coordinate of line endpoint
/// \param[in] nY1: Y coordinate of line endpoint
/// \param[in] nCol: Color RGB value for the line
///
/// \return none
///
void gslc_DrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
///
/// Draw a horizontal line
/// - Note that direction of line is in +ve X axis
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nX: X coordinate of line startpoint
/// \param[in] nY: Y coordinate of line startpoint
/// \param[in] nW: Width of line (in +X direction)
/// \param[in] nCol: Color RGB value for the line
///
/// \return none
///
void gslc_DrawLineH(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nW,gslc_tsColor nCol);
///
/// Draw a vertical line
/// - Note that direction of line is in +ve Y axis
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nX: X coordinate of line startpoint
/// \param[in] nY: Y coordinate of line startpoint
/// \param[in] nH: Height of line (in +Y direction)
/// \param[in] nCol: Color RGB value for the line
///
/// \return none
///
void gslc_DrawLineV(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nH,gslc_tsColor nCol);
///
/// Draw a polar ray segment
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nX: X coordinate of line startpoint
/// \param[in] nY: Y coordinate of line startpoint
/// \param[in] nRadStart: Starting radius of line
/// \param[in] nRadEnd: Ending radius of line
/// \param[in] n64Ang: Angle of ray (degrees * 64). 0 is up, +90*64 is to right
/// From -180*64 to +180*64
/// \param[in] nCol: Color RGB value for the line
///
/// \return none
///
void gslc_DrawLinePolar(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint16_t nRadStart,uint16_t nRadEnd,int16_t n64Ang,gslc_tsColor nCol);
///
/// Draw a framed rectangle
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] rRect: Rectangular region to frame
/// \param[in] nCol: Color RGB value for the frame
///
/// \return none
///
void gslc_DrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
///
/// Draw a framed rounded rectangle
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] rRect: Rectangular region to frame
/// \param[in] nRadius: Radius for the rounded corners
/// \param[in] nCol: Color RGB value for the frame
///
/// \return none
///
void gslc_DrawFrameRoundRect(gslc_tsGui* pGui, gslc_tsRect rRect, int16_t nRadius, gslc_tsColor nCol);
///
/// Draw a filled rectangle
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] rRect: Rectangular region to fill
/// \param[in] nCol: Color RGB value to fill
///
/// \return none
///
void gslc_DrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
///
/// Draw a filled rounded rectangle
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] rRect: Rectangular region to fill
/// \param[in] nRadius: Radius for the rounded corners
/// \param[in] nCol: Color RGB value to fill
///
/// \return none
///
void gslc_DrawFillRoundRect(gslc_tsGui* pGui, gslc_tsRect rRect, int16_t nRadius, gslc_tsColor nCol);
///
/// Draw a framed circle
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nMidX: Center X coordinate
/// \param[in] nMidY: Center Y coordinate
/// \param[in] nRadius: Radius of circle
/// \param[in] nCol: Color RGB value for the frame
///
/// \return none
///
void gslc_DrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
uint16_t nRadius,gslc_tsColor nCol);
///
/// Draw a filled circle
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nMidX: Center X coordinate
/// \param[in] nMidY: Center Y coordinate
/// \param[in] nRadius: Radius of circle
/// \param[in] nCol: Color RGB value for the fill
///
/// \return none
///
void gslc_DrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
uint16_t nRadius,gslc_tsColor nCol);
///
/// Draw a framed triangle
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nX0: X Coordinate #1
/// \param[in] nY0: Y Coordinate #1
/// \param[in] nX1: X Coordinate #2
/// \param[in] nY1: Y Coordinate #2
/// \param[in] nX2: X Coordinate #3
/// \param[in] nY2: Y Coordinate #3
/// \param[in] nCol: Color RGB value for the frame
///
/// \return true if success, false if error
///
void gslc_DrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
///
/// Draw a filled triangle
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nX0: X Coordinate #1
/// \param[in] nY0: Y Coordinate #1
/// \param[in] nX1: X Coordinate #2
/// \param[in] nY1: Y Coordinate #2
/// \param[in] nX2: X Coordinate #3
/// \param[in] nY2: Y Coordinate #3
/// \param[in] nCol: Color RGB value for the fill
///
/// \return true if success, false if error
///
void gslc_DrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
///
/// Draw a framed quadrilateral
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] psPt: Pointer to array of 4 points
/// \param[in] nCol: Color RGB value for the frame
///
/// \return true if success, false if error
///
void gslc_DrawFrameQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol);
///
/// Draw a filled quadrilateral
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] psPt: Pointer to array of 4 points
/// \param[in] nCol: Color RGB value for the frame
///
/// \return true if success, false if error
///
void gslc_DrawFillQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol);
///
/// Draw a gradient filled sector of a circle with support for inner and outer radius
/// - Can be used to create a ring or pie chart
/// - Note that the gradient fill is defined by both the color stops (cArcStart..cArcEnd) as well as
/// a gradient angular range (nAngGradStart..nAngGradStart+nAngGradRange). This gradient angular
/// range can be differeng from the drawing angular range (nAngSegStart..nAngSecEnd) to enable
/// more advanced control styling / updates.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nQuality: Number of segments used to depict a full circle.
/// The higher the value, the smoother the resulting
/// arcs. A value of 72 provides 360/72=5 degrees per
/// segment which is a reasonable compromise between
/// smoothness and performance. Note that 360/nQuality
/// should be an integer result, thus the allowable
/// quality settings are: 360 (max quality), 180, 120,
/// 90, 72, 60, 45, 40, 36 (low quality), etc.
/// \param[in] nMidX: Midpoint X coordinate of circle
/// \param[in] nMidY: Midpoint Y coordinate of circle
/// \param[in] nRad1: Inner sector radius (0 for sector / pie, non-zero for ring)
/// \param[in] nRad2: Outer sector radius. Delta from nRad1 defines ring thickness.
/// \param[in] cArcStart: Start color for gradient fill (with angular range defined by nAngGradStart,nAngGradRange)
/// \param[in] cArcEnd: End color for gradient fill
/// \param[in] nAngSecStart: Angle of start of sector drawing (0 at top), measured in degrees.
/// \param[in] nAngSecEnd: Angle of end of sector drawing (0 at top), measured in degrees.
/// \param[in] nAngGradStart: For gradient fill, defines the starting angle associated with the starting color (cArcStart)
/// \param[in] nAngGradRange: For gradient fill, defines the angular range associated with the start-to-end color range (cArcStart..cArcEnd)
///
/// \return none
///
void gslc_DrawFillGradSector(gslc_tsGui* pGui, int16_t nQuality, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2,
gslc_tsColor cArcStart, gslc_tsColor cArcEnd, int16_t nAngSecStart, int16_t nAngSecEnd, int16_t nAngGradStart, int16_t nAngGradRange);
///
/// Draw a flat filled sector of a circle with support for inner and outer radius
/// - Can be used to create a ring or pie chart
///
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nQuality: Number of segments used to depict a full circle.
/// The higher the value, the smoother the resulting
/// arcs. A value of 72 provides 360/72=5 degrees per
/// segment which is a reasonable compromise between
/// smoothness and performance.
/// \param[in] nMidX: Midpoint X coordinate of circle
/// \param[in] nMidY: Midpoint Y coordinate of circle
/// \param[in] nRad1: Inner sector radius (0 for sector / pie, non-zero for ring)
/// \param[in] nRad2: Outer sector radius. Delta from nRad1 defines ring thickness.
/// \param[in] cArc: Color for flat fill
/// \param[in] nAngSecStart: Angle of start of sector drawing (0 at top), measured in degrees.
/// \param[in] nAngSecEnd: Angle of end of sector drawing (0 at top), measured in degrees.
///
/// \return none
///
void gslc_DrawFillSector(gslc_tsGui* pGui, int16_t nQuality, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2,
gslc_tsColor cArc, int16_t nAngSecStart, int16_t nAngSecEnd);
// -----------------------------------------------------------------------
/// @}
/// \defgroup _Font_ Font Functions
/// Functions that load fonts
/// @{
// -----------------------------------------------------------------------
///
/// Load a font into the local font cache and assign
/// font ID (nFontId).
/// - Font is stored into next available internal array element
/// - NOTE: Use FontSet() instead
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nFontId: ID to use when referencing this font
/// \param[in] eFontRefType: Font reference type (eg. filename or pointer)
/// \param[in] pvFontRef: Reference pointer to identify the font. In the case of SDL
/// mode, it is a filepath to the font file. In the case of Arduino
/// it is a pointer value to the font bitmap array (GFXFont)
/// \param[in] nFontSz: Typeface size to use (only used in SDL mode)
///
/// \return true if load was successful, false otherwise
///
bool gslc_FontAdd(gslc_tsGui* pGui,int16_t nFontId,gslc_teFontRefType eFontRefType,
const void* pvFontRef,uint16_t nFontSz);
///
/// Load a font into the local font cache and store as font ID (nFontId)
/// - Font is stored into index nFontId, so nFontId must be from
/// separate font enum (0-based).
/// - Example:
/// enum { E_FONT_BTN, E_FONT_TXT, MAX_FONT };
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nFontId: ID to use when referencing this font
/// \param[in] eFontRefType: Font reference type (eg. filename or pointer)
/// \param[in] pvFontRef: Reference pointer to identify the font. In the case of SDL
/// mode, it is a filepath to the font file. In the case of Arduino
/// it is a pointer value to the font bitmap array (GFXFont)
/// \param[in] nFontSz: Typeface size to use (only used in SDL mode)
///
/// \return true if load was successful, false otherwise
///
bool gslc_FontSet(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefType eFontRefType,
const void* pvFontRef, uint16_t nFontSz);
///
/// Fetch a font from its ID value
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nFontId: ID value used to reference the font (supplied
/// originally to gslc_FontAdd()
///
/// \return A pointer to the font structure or NULL if error
///
gslc_tsFont* gslc_FontGet(gslc_tsGui* pGui,int16_t nFontId);
///
/// Set the font operating mode
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nFontId: ID value used to reference the font (supplied
/// originally to gslc_FontAdd()
/// \param[in,out] eFontMode: Font mode to assign to this font
///
/// \return true if success
///
bool gslc_FontSetMode(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefMode eFontMode);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _Page_ Page Functions
/// Functions that operate at the page level
/// @{
// ------------------------------------------------------------------------
///
/// Fetch the current page ID
///
/// \param[in] pGui: Pointer to GUI
///
/// \return Page ID
///
int gslc_GetPageCur(gslc_tsGui* pGui);
///
/// Assign a page to the page stack
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nStackPos: Position to update in the page stack (0..GSLC_STACK__MAX-1)
/// \param[in] nPageId: Page ID to select as current
///
/// \return none
///
void gslc_SetStackPage(gslc_tsGui* pGui,uint8_t nStackPos,int16_t nPageId);
///
/// Change the status of a page in a page stack
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nStackPos: Position to update in the page stack (0..GSLC_STACK__MAX-1)
/// \param[in] bActive: Indicate if page should receive touch events
/// \param[in] bDoDraw: Indicate if page should continue to be redrawn. If pages in
/// the stack are overlapping and an element in a lower layer
/// continues to receive updates, then the element may "show through"
/// the layers above it. In such cases where pages in the stack
/// are overlapping and lower pages contain dynamically updating
/// elements, it may be best to disable redraw while the overlapping
/// page is visible (by setting bDoDraw to false).
///
/// \return none
///
void gslc_SetStackState(gslc_tsGui* pGui, uint8_t nStackPos, bool bActive, bool bDoDraw);
///
/// Assigns a page for the base layer in the page stack
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: Page ID to select (or GSLC_PAGE_NONE to disable)
///
/// \return none
///
void gslc_SetPageBase(gslc_tsGui* pGui, int16_t nPageId);
///
/// Select a page for the current layer in the page stack
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: Page ID to select
///
/// \return none
///
void gslc_SetPageCur(gslc_tsGui* pGui,int16_t nPageId);
///
/// Select a page for the overlay layer in the page stack
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: Page ID to select (or GSLC_PAGE_NONE to disable)
///
/// \return none
///
void gslc_SetPageOverlay(gslc_tsGui* pGui,int16_t nPageId);
///
/// Show a popup dialog
/// - Popup dialogs use the overlay layer in the page stack
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: Page ID to use as the popup dialog
/// \param[in] bModal: If true, popup is modal (other layers won't accept touch).
/// If false, popup is modeless (other layers still accept touch)
///
/// \return none
///
void gslc_PopupShow(gslc_tsGui* pGui, int16_t nPageId, bool bModal);
///
/// Hides the currently active popup dialog
///
/// \param[in] pGui: Pointer to GUI
///
/// \return none
///
void gslc_PopupHide(gslc_tsGui* pGui);
///
/// Update the need-redraw status for the current page
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] bRedraw: True if redraw required, false otherwise
///
/// \return none
///
void gslc_PageRedrawSet(gslc_tsGui* pGui,bool bRedraw);
///
/// Get the need-redraw status for the current page
///
/// \param[in] pGui: Pointer to GUI
///
/// \return True if redraw required, false otherwise
///
bool gslc_PageRedrawGet(gslc_tsGui* pGui);
/// Add a page to the GUI
/// - This call associates an element array with the collection within the page
/// - Once a page has been added to the GUI, elements can be added to the page
/// by specifying the same page ID
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: Page ID to assign
/// \param[in] psElem: Internal element array storage to associate with the page
/// \param[in] nMaxElem: Maximum number of elements that can be added to the
/// internal element array (ie. RAM))
/// \param[in] psElemRef: Internal element reference array storage to
/// associate with the page. All elements, whether they
/// are located in the internal element array or in
/// external Flash (PROGMEM) storage, require an entry
/// in the element reference array.
/// \param[in] nMaxElemRef: Maximum number of elements in the reference array.
/// This is effectively the maximum number of elements
/// that can appear on a page, irrespective of whether
/// it is stored in RAM or Flash (PROGMEM).
///
/// \return none
///
void gslc_PageAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* psElem,uint16_t nMaxElem,
gslc_tsElemRef* psElemRef,uint16_t nMaxElemRef);
/// Find an element in the GUI by its Page ID and Element ID
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: Page ID to search
/// \param[in] nElemId: Element ID to search
///
/// \return Ptr to an element or NULL if none found
///
gslc_tsElemRef* gslc_PageFindElemById(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _Elem_ Element Functions
/// Functions that are used to create and manipulate elements
/// @{
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
/// \defgroup _ElemCreate_ Element: Creation Functions
/// Functions that create GUI elements
/// @{
// ------------------------------------------------------------------------
///
/// Create a Text Element
/// - Draws a text string with filled background
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
/// \param[in] nPage: Page ID to attach element to
/// \param[in] rElem: Rectangle coordinates defining text background size
/// \param[in] pStrBuf: String to copy into element
/// \param[in] nStrBufMax: Maximum length of string buffer (pStrBuf). Only applicable
/// if GSLC_LOCAL_STR=0. Ignored if GSLC_LOCAL_STR=1.)
/// \param[in] nFontId: Font ID to use for text display
///
/// \return Pointer to the Element reference or NULL if failure
///
gslc_tsElemRef* gslc_ElemCreateTxt(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,int16_t nFontId);
///
/// Create a textual Button Element
/// - Creates a clickable element that has a textual label
/// with frame and fill
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
/// \param[in] nPage: Page ID to attach element to
/// \param[in] rElem: Rectangle coordinates defining text background size
/// \param[in] pStrBuf: String to copy into element
/// \param[in] nStrBufMax: Maximum length of string buffer (pStrBuf). Only applicable
/// if GSLC_LOCAL_STR=0. Ignored if GSLC_LOCAL_STR=1.)
/// \param[in] nFontId: Font ID to use for text display
/// \param[in] cbTouch: Callback for touch events
///
/// \return Pointer to the Element reference or NULL if failure
///
gslc_tsElemRef* gslc_ElemCreateBtnTxt(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,
int16_t nFontId,GSLC_CB_TOUCH cbTouch);
///
/// Create a graphical Button Element
/// - Creates a clickable element that uses a BMP image with
/// no frame or fill
/// - Transparency is supported by bitmap color (0xFF00FF)
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
/// \param[in] nPage: Page ID to attach element to
/// \param[in] rElem: Rectangle coordinates defining image size
/// \param[in] sImgRef: Image reference to load (unselected state)
/// \param[in] sImgRefSel: Image reference to load (selected state)
/// \param[in] cbTouch: Callback for touch events
///
/// \return Pointer to the Element reference or NULL if failure
///
gslc_tsElemRef* gslc_ElemCreateBtnImg(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
gslc_tsRect rElem,gslc_tsImgRef sImgRef,gslc_tsImgRef sImgRefSel,GSLC_CB_TOUCH cbTouch);
///
/// Create a Box Element
/// - Draws a box with frame and fill
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
/// \param[in] nPage: Page ID to attach element to
/// \param[in] rElem: Rectangle coordinates defining box size
///
/// \return Pointer to the Element reference or NULL if failure
///
gslc_tsElemRef* gslc_ElemCreateBox(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem);
///
/// Create a Line Element
/// - Draws a line with fill color
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
/// \param[in] nPage: Page ID to attach element to
/// \param[in] nX0: X coordinate of line startpoint
/// \param[in] nY0: Y coordinate of line startpoint
/// \param[in] nX1: X coordinate of line endpoint
/// \param[in] nY1: Y coordinate of line endpoint
///
/// \return Pointer to the Element reference or NULL if failure
///
gslc_tsElemRef* gslc_ElemCreateLine(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1);
///
/// Create an image Element
/// - Draws an image
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Element ID to assign (0..16383 or GSLC_ID_AUTO to autogen)
/// \param[in] nPage: Page ID to attach element to
/// \param[in] rElem: Rectangle coordinates defining box size
/// \param[in] sImgRef: Image reference to load
///
/// \return Pointer to the Element reference or NULL if failure
///
gslc_tsElemRef* gslc_ElemCreateImg(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem,
gslc_tsImgRef sImgRef);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _ElemGen_ Element: General Functions
/// General-purpose functions that operate on Elements
/// @{
// ------------------------------------------------------------------------
///
/// Get an Element ID from an element structure
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference structure
///
/// \return ID of element or GSLC_ID_NONE if not found
///
int gslc_ElemGetId(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _ElemUpd_ Element: Update Functions
/// Functions that configure or modify an existing eleemnt
/// @{
// ------------------------------------------------------------------------
///
/// Set the fill state for an Element
/// - If not filled, the element can support transparency against an
/// arbitrary background, but this can require full screen redraws
/// if the element is updated.
/// - If filled, the background fill color can be changed by gslc_ElemSetCol()
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] bFillEn: True if filled, false otherwise
///
/// \return none
///
void gslc_ElemSetFillEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFillEn);
///
/// Set the frame state for an Element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] bFrameEn: True if framed, false otherwise
///
/// \return none
///
void gslc_ElemSetFrameEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFrameEn);
///
/// Set the rounded frame/fill state for an Element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] bRoundEn: True if rounded, false otherwise
///
/// \return none
///
void gslc_ElemSetRoundEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bRoundEn);
///
/// Update the common color selection for an Element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] colFrame: Color for the frame
/// \param[in] colFill: Color for the fill
/// \param[in] colFillGlow: Color for the fill when glowing
///
/// \return none
///
void gslc_ElemSetCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrame,gslc_tsColor colFill,gslc_tsColor colFillGlow);
///
/// Update the common color selection for glowing state of an Element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] colFrameGlow: Color for the frame when glowing
/// \param[in] colFillGlow: Color for the fill when glowing
/// \param[in] colTxtGlow Color for the text when glowing
///
/// \return none
///
void gslc_ElemSetGlowCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrameGlow,gslc_tsColor colFillGlow,gslc_tsColor colTxtGlow);
///
/// Set the group ID for an element
/// - Typically used to associate radio button elements together
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] nGroupId: Group ID to assign
///
/// \return none
///
void gslc_ElemSetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nGroupId);
///
/// Get the group ID for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
///
/// \return Group ID or GSLC_GROUP_ID_NONE if unassigned
///
int gslc_ElemGetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
///
/// Set the position and size for an element
/// - This updates the element's rectangular region, which can be used
/// to relocate or resize an element at runtime
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] rElem: Rect region (top-left coord, width, height)
///
/// \return none
///
void gslc_ElemSetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsRect rElem);
///
/// Get the rectangular region for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
///
/// \return Rect region of an element
///
gslc_tsRect gslc_ElemGetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
/// Set the alignment of a textual element (horizontal and vertical)
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] nAlign: Alignment to specify:
/// - GSLC_ALIGN_TOP_LEFT
/// - GSLC_ALIGN_TOP_MID
/// - GSLC_ALIGN_TOP_RIGHT
/// - GSLC_ALIGN_MID_LEFT
/// - GSLC_ALIGN_MID_MID
/// - GSLC_ALIGN_MID_RIGHT
/// - GSLC_ALIGN_BOT_LEFT
/// - GSLC_ALIGN_BOT_MID
/// - GSLC_ALIGN_BOT_RIGHT
///
/// \return none
///
void gslc_ElemSetTxtAlign(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nAlign);
/// Set the margin around of a textual element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] nMargin: Number of pixels gap to leave surrounding text
///
/// \return none
///
void gslc_ElemSetTxtMargin(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nMargin);
/// Set the margin around of a textual element (X & Y offsets can be different)
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] nMarginX: Number of pixels gap to offset text horizontally
/// \param[in] nMarginY: Number of pixels gap to offset text vertically
///
/// \return none
///
void gslc_ElemSetTxtMarginXY(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int8_t nMarginX,int8_t nMarginY);
///
/// Update the text string associated with an Element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] pStr: String to copy into element
///
/// \return none
///
void gslc_ElemSetTxtStr(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,const char* pStr);
///
/// Fetch the current text string associated with an Element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
///
/// \return Pointer to character array string
///
char* gslc_ElemGetTxtStr(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
///
/// Update the text string color associated with an Element ID
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] colVal: RGB color to change to
///
/// \return none
///
void gslc_ElemSetTxtCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colVal);
///
/// Update the text string location in memory
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] eFlags: Flags associated with text memory location (GSLC_TXT_MEM_*)
///
/// \return none
///
void gslc_ElemSetTxtMem(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags);
///
/// Update the text string encoding mode
/// - This function can be used to indicate that the element's text string is
/// encoded in UTF-8, which supports extended / foreign character maps
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] eFlags: Flags associated with text encoding (GSLC_TXT_ENC_*)
///
/// \return none
///
void gslc_ElemSetTxtEnc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags);
///
/// Update the Font selected for an Element's text
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] nFontId: Font ID to select
///
/// \return none
///
void gslc_ElemUpdateFont(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nFontId);
///
/// Update the need-redraw status for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] eRedraw: Redraw state to set
///
/// \return none
///
void gslc_ElemSetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
///
/// Get the need-redraw status for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
///
/// \return Redraw status
///
gslc_teRedrawType gslc_ElemGetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
///
/// Update the glowing enable for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] bGlowEn: True if element should support glowing
///
/// \return none
///
void gslc_ElemSetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowEn);
///
/// Update the click enable for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] bClickEn: True if element should support click events
///
/// \return none
///
void gslc_ElemSetClickEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bClickEn);
///
/// Update the touch function callback for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] funcCb: Pointer to the touch callback function
///
/// \return none
///
void gslc_ElemSetTouchFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_TOUCH funcCb);
///
/// Copy style settings from one element to another
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRefSrc: Pointer to source Element reference
/// \param[in] pElemRefDest: Pointer to destination Element reference
///
/// \return none
///
void gslc_ElemSetStyleFrom(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefSrc,gslc_tsElemRef* pElemRefDest);
///
/// Get the glowing enable for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
///
/// \return True if element supports glowing
///
bool gslc_ElemGetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
///
/// Update the glowing indicator for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] bGlowing: True if element is glowing
///
/// \return none
///
void gslc_ElemSetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowing);
///
/// Get the glowing indicator for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
///
/// \return True if element is glowing
///
bool gslc_ElemGetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
///
/// Update the visibility status for an element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] bVisible: True if element is shown, false if hidden
///
/// \return none
///
void gslc_ElemSetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bVisible);
///
/// Get the visibility status for an element
/// - Note that the visibility state is independent of
/// whether or not the page associated with the element
/// is actively displayed.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
///
/// \return True if element is marked as visible, false if hidden
///
bool gslc_ElemGetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
///
/// Determine whether an element is visible on the screen
/// - This function takes into account both the element's
/// "Visible" state as well as whether the element's
/// associated page is active in the page stack.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
///
/// \return True if element appears on the screen, false otherwise
///
bool gslc_ElemGetOnScreen(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
/* UNUSED
///
/// Assign the event callback function for a element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] funcCb: Function pointer to event routine (or NULL for default))
///
/// \return none
///
void gslc_ElemSetEventFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_EVENT funcCb);
*/
///
/// Assign the drawing callback function for an element
/// - This allows the user to override the default rendering for
/// an element, enabling the creation of a custom element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] funcCb: Function pointer to drawing routine (or NULL for default))
///
/// \return none
///
void gslc_ElemSetDrawFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_DRAW funcCb);
///
/// Assign the tick callback function for an element
/// - This allows the user to provide background updates to
/// an element triggered by the main loop call to gslc_Update()
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference
/// \param[in] funcCb: Function pointer to tick routine (or NULL for none))
///
/// \return none
///
void gslc_ElemSetTickFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_TICK funcCb);
///
/// Determine if a coordinate is inside of an element
/// - This routine is useful in determining if a touch
/// coordinate is inside of a button.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Element reference used for boundary test
/// \param[in] nX: X coordinate to test
/// \param[in] nY: Y coordinate to test
/// \param[in] bOnlyClickEn: Only output true if element was also marked
/// as "clickable" (eg. bClickEn=true)
///
/// \return true if inside element, false otherwise
///
bool gslc_ElemOwnsCoord(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nX,int16_t nY,bool bOnlyClickEn);
/// @} // End of _Elem_
#if !defined(DRV_TOUCH_NONE)
// ------------------------------------------------------------------------
/// @}
/// \defgroup _Touch_ Touchscreen Functions
/// Functions that configure and respond to a touch device
/// @{
// ------------------------------------------------------------------------
// Define the transformation matrix from rotation (0..3) to SWAP / FLIPX / FLIPY
#define TOUCH_ROTATION_DATA 0x6350
#define TOUCH_ROTATION_SWAPXY(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 2 ) & 0x01 )
#define TOUCH_ROTATION_FLIPX(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 1 ) & 0x01 )
#define TOUCH_ROTATION_FLIPY(rotation) ((( TOUCH_ROTATION_DATA >> ((rotation&0x03)*4) ) >> 0 ) & 0x01 )
///
/// Initialize the touchscreen device driver
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] acDev: Device path to touchscreen (or "" if not applicable))
/// eg. "/dev/input/touchscreen"
///
/// \return true if successful
///
bool gslc_InitTouch(gslc_tsGui* pGui,const char* acDev);
///
/// Initialize the touchscreen device driver
///
/// \param[in] pGui: Pointer to GUI
/// \param[out] pnX: Ptr to int to contain latest touch X coordinate
/// \param[out] pnY: Ptr to int to contain latest touch Y coordinate
/// \param[out] pnPress: Ptr to int to contain latest touch pressure value
/// \param[out] peInputEvent Indication of event type
/// \param[out] pnInputVal Additional data for event type
///
/// \return true if touch event, false otherwise
///
bool gslc_GetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
///
/// Configure touchscreen remapping
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] bEn: Enable touchscreen remapping?
///
/// \return none
///
void gslc_SetTouchRemapEn(gslc_tsGui* pGui, bool bEn);
///
/// Configure touchscreen calibration values
/// - Only used if calibration remapping has been enabled
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nXMin: Resistive touchscreen X_MIN calibration value
/// \param[in] nXMax: Resistive touchscreen X_MAX calibration value
/// \param[in] nYMin: Resistive touchscreen Y_MIN calibration value
/// \param[in] nYMax: Resistive touchscreen Y_MAX calibration value
///
/// \return none
///
void gslc_SetTouchRemapCal(gslc_tsGui* pGui,uint16_t nXMin, uint16_t nXMax, uint16_t nYMin, uint16_t nYMax);
///
/// Configure touchscreen XY swap
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] bSwap: Enable touchscreen XY swap
///
/// \return none
///
void gslc_SetTouchRemapYX(gslc_tsGui* pGui, bool bSwap);
#endif // !DRV_TOUCH_NONE
// ------------------------------------------------------------------------
/// @}
/// \defgroup _Input_ Input Mapping Functions
/// Functions that handle GPIO / pin and keyboard input
/// @{
// ------------------------------------------------------------------------
/// \todo Doc. This API is experimental and subject to change
void gslc_SetPinPollFunc(gslc_tsGui* pGui, GSLC_CB_PIN_POLL pfunc);
/// \todo Doc. This API is experimental and subject to change
void gslc_InitInputMap(gslc_tsGui* pGui,gslc_tsInputMap* asInputMap,uint8_t nInputMapMax);
/// \todo Doc. This API is experimental and subject to change
void gslc_InputMapAdd(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction eAction,int16_t nActionVal);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _GenMacro_ General Purpose Macros
/// Macros that are used throughout the GUI for debug
/// @{
// ------------------------------------------------------------------------
// Create debug macro to selectively include the output code
/// \def GSLC_DEBUG_PRINT(fmt, ...)
///
/// Macro to enable optional debug output
/// - Supports printf formatting via gslc_DebugPrintf()
/// - Supports storing the format string in PROGMEM
/// - Note that at least one variable argument must be provided
/// to the macro after the format string. This is a limitation
/// of the macro definition. If no parameters are needed, then
/// simply pass 0. For example:
/// GSLC_DEBUG_PRINT("Loaded OK",0);
///
/// \param[in] sFmt: Format string for debug message
///
#if (GSLC_USE_PROGMEM)
// Debug print macro for CPUs that support PROGMEM (Flash)
#define GSLC_DEBUG_PRINT(sFmt, ...) \
do { \
if (DEBUG_ERR) { \
gslc_DebugPrintf(PSTR(sFmt),__VA_ARGS__); \
} \
} while (0)
#define GSLC_DEBUG2_PRINT(sFmt, ...) \
do { \
if (DEBUG_ERR >= 2) { \
gslc_DebugPrintf(PSTR(sFmt),__VA_ARGS__); \
} \
} while (0)
#else
// Debug print macro for CPUs that don't support PROGMEM (Flash)
#define GSLC_DEBUG_PRINT(sFmt, ...) \
do { \
if (DEBUG_ERR) { \
gslc_DebugPrintf(sFmt,__VA_ARGS__); \
} \
} while (0)
#define GSLC_DEBUG2_PRINT(sFmt, ...) \
do { \
if (DEBUG_ERR >= 2) { \
gslc_DebugPrintf(sFmt,__VA_ARGS__); \
} \
} while (0)
#endif
#define GSLC_DEBUG_PRINT_CONST(sFmt, ...) \
do { \
if (DEBUG_ERR) { \
gslc_DebugPrintf(sFmt,__VA_ARGS__); \
} \
} while (0)
#define GSLC_DEBUG2_PRINT_CONST(sFmt, ...) \
do { \
if (DEBUG_ERR >= 2) { \
gslc_DebugPrintf(sFmt,__VA_ARGS__); \
} \
} while (0)
// ------------------------------------------------------------------------
/// @}
/// \defgroup _MacroFlash_ Flash-based Element Macros
/// Macros that represent element creation routines based in FLASH memory
/// @{
// ------------------------------------------------------------------------
// Macro initializers for Read-Only Elements in Flash/PROGMEM
//
// - Generally useful in Arduino sketches targeting low-RAM CPUs (such as ATmega328)
// - These macros perform initialization of a static tsElem variable (located
// in PROGMEM). If a string is required, then it too is allocated in
// PROGMEM space.
// - The benefit of this macro is in providing significant RAM savings for
// programs that instantiate a number of read-only GUI elements. The net
// cost of each read-only GUI element is approximately 4B when using these
// methods.
// - Unlike the normal ElemCreate*() functions, these ElemCreate*_P() macros
// don't return a tsElem pointer. Since the element definition is in
// Flash/PROGMEM, it is read-only and no updates should be attempted.
// - These macros have to match the current definition and order of gslc_tsElem
// exactly, so any changes to the element definition must be reflected here
// as well.
/// \def gslc_ElemCreateTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn)
///
/// Create a read-only text element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Unique element ID to assign
/// \param[in] nPage: Page ID to attach element to
/// \param[in] nX: X coordinate of element
/// \param[in] nY: Y coordinate of element
/// \param[in] nW: Width of element
/// \param[in] nH: Height of element
/// \param[in] strTxt: Text string to display
/// \param[in] pFont: Pointer to font resource
/// \param[in] colTxt: Color for the text
/// \param[in] colFrame: Color for the frame
/// \param[in] colFill: Color for the fill
/// \param[in] nAlignTxt: Text alignment
/// \param[in] bFrameEn: True if framed, false otherwise
/// \param[in] bFillEn: True if filled, false otherwise
///
/// \def gslc_ElemCreateTxt_P_R(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn)
///
/// Create a read-write text element (element in Flash, string in RAM)
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Unique element ID to assign
/// \param[in] nPage: Page ID to attach element to
/// \param[in] nX: X coordinate of element
/// \param[in] nY: Y coordinate of element
/// \param[in] nW: Width of element
/// \param[in] nH: Height of element
/// \param[in] strTxt: Text string to display
/// \param[in] strLength: Length of text string
/// \param[in] pFont: Pointer to font resource
/// \param[in] colTxt: Color for the text
/// \param[in] colFrame: Color for the frame
/// \param[in] colFill: Color for the fill
/// \param[in] nAlignTxt: Text alignment
/// \param[in] bFrameEn: True if framed, false otherwise
/// \param[in] bFillEn: True if filled, false otherwise
///
/// \def gslc_ElemCreateTxt_P_R_ext(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colTxtGlow,colFrame,colFill,nAlignTxt,nMarginX,nMarginY,bFrameEn,bFillEn,bClickEn,bGlowEn,pfuncXEvent,pfuncXDraw,pfuncXTouch,pfuncXTick)
///
/// Create a read-write text element (element in Flash, string in RAM)
/// with extended customization options.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Unique element ID to assign
/// \param[in] nPage: Page ID to attach element to
/// \param[in] nX: X coordinate of element
/// \param[in] nY: Y coordinate of element
/// \param[in] nW: Width of element
/// \param[in] nH: Height of element
/// \param[in] strTxt: Text string to display
/// \param[in] strLength: Length of text string
/// \param[in] pFont: Pointer to font resource
/// \param[in] colTxt: Color for the text
/// \param[in] colTxtGlow: Color for the text when glowing
/// \param[in] colFrame: Color for the frame
/// \param[in] colFill: Color for the fill
/// \param[in] nAlignTxt: Text alignment
/// \param[in] nMarginX: Text margin (X offset)
/// \param[in] nMarginY: Text margin (Y offset)
/// \param[in] bFrameEn: True if framed, false otherwise
/// \param[in] bFillEn: True if filled, false otherwise
/// \param[in] bClickEn: True if accept click events, false otherwise
/// \param[in] bGlowEn: True if supports glow state, false otherwise
/// \param[in] pfuncXEvent: Callback function ptr for Event
/// \param[in] pfuncXDraw: Callback function ptr for Redraw
/// \param[in] pfuncXTouch: Callback function ptr for Touch
/// \param[in] pfuncXTick: Callback function ptr for Timer tick
///
/// \def gslc_ElemCreateBox_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFrame,colFill,bFrameEn,bFillEn,pfuncXDraw,pfuncXTick)
///
/// Create a read-only box element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Unique element ID to assign
/// \param[in] nPage: Page ID to attach element to
/// \param[in] nX: X coordinate of element
/// \param[in] nY: Y coordinate of element
/// \param[in] nW: Width of element
/// \param[in] nH: Height of element
/// \param[in] colFrame: Color for the frame
/// \param[in] colFill: Color for the fill
/// \param[in] bFrameEn: True if framed, false otherwise
/// \param[in] bFillEn: True if filled, false otherwise
/// \param[in] pfuncXDraw: Pointer to custom draw callback (or NULL if default)
/// \param[in] pfuncXTick: Pointer to custom tick callback (or NULL if default)
///
/// \def gslc_ElemCreateLine_P(pGui,nElemId,nPage,nX0,nY0,nX1,nY1,colFill)
///
/// Create a read-only line element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Unique element ID to assign
/// \param[in] nPage: Page ID to attach element to
/// \param[in] nX0: X coordinate of line start
/// \param[in] nY0: Y coordinate of line start
/// \param[in] nX1: X coordinate of line end
/// \param[in] nY1: Y coordinate of line end
/// \param[in] colFill: Color for the line
/// \def gslc_ElemCreateBtnTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,colFrameGlow,colFillGlow,nAlignTxt,bFrameEn,bFillEn,callFunc,extraData)
///
/// Create a text button element
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: Unique element ID to assign
/// \param[in] nPage: Page ID to attach element to
/// \param[in] nX: X coordinate of element
/// \param[in] nY: Y coordinate of element
/// \param[in] nW: Width of element
/// \param[in] nH: Height of element
/// \param[in] strTxt: Text string to display
/// \param[in] pFont: Pointer to font resource
/// \param[in] colTxt: Color for the text
/// \param[in] colFrame: Color for the frame
/// \param[in] colFill: Color for the fill
/// \param[in] colFrameGlow: Color for the frame when glowing
/// \param[in] colFillGlow: Color for the fill when glowing
/// \param[in] nAlignTxt: Text alignment
/// \param[in] bFrameEn: True if framed, false otherwise
/// \param[in] bFillEn: True if filled, false otherwise
/// \param[in] callFunc: Callback function for button press
/// \param[in] extraData: Ptr to extended data structure
///
#if (GSLC_USE_PROGMEM)
#define gslc_ElemCreateTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn) \
static const char str##nElemId[] PROGMEM = strTxt; \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId PROGMEM = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_TXT, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)str##nElemId, \
0, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_PROG | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxt, \
nAlignTxt, \
0, \
0, \
pFont, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateTxt_P_R(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId PROGMEM = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_TXT, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)strTxt, \
strLength, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxt, \
nAlignTxt, \
0, \
0, \
pFont, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateTxt_P_R_ext(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colTxtGlow,colFrame,colFill,nAlignTxt,nMarginX,nMarginY,bFrameEn,bFillEn,bClickEn,bGlowEn,pfuncXEvent,pfuncXDraw,pfuncXTouch,pfuncXTick) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0) | (bClickEn?GSLC_ELEM_FEA_CLICK_EN:0) | (bGlowEn?GSLC_ELEM_FEA_GLOW_EN:0); \
static const gslc_tsElem sElem##nElemId PROGMEM = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_TXT, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)strTxt, \
strLength, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxtGlow, \
nAlignTxt, \
nMarginX, \
nMarginY, \
pFont, \
NULL, \
pfuncXEvent, \
pfuncXDraw, \
pfuncXTouch, \
pfuncXTick, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateBox_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFrame,colFill,bFrameEn,bFillEn,pfuncXDraw,pfuncXTick) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId PROGMEM = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_BOX, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
NULL, \
0, \
GSLC_TXT_DEFAULT, \
GSLC_COL_WHITE, \
GSLC_COL_WHITE, \
GSLC_ALIGN_MID_MID, \
0, \
0, \
NULL, \
NULL, \
NULL, \
pfuncXDraw, \
NULL, \
pfuncXTick, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateLine_P(pGui,nElemId,nPage,nX0,nY0,nX1,nY1,colFill) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID; \
static const gslc_tsElem sElem##nElemId PROGMEM = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_LINE, \
(gslc_tsRect){nX0,nY0,nX1-nX0+1,nY1-nY0+1}, \
GSLC_GROUP_ID_NONE, \
colFill,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
NULL, \
0, \
GSLC_TXT_DEFAULT, \
GSLC_COL_WHITE, \
GSLC_COL_WHITE, \
GSLC_ALIGN_MID_MID, \
0, \
0, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateBtnTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,colFrameGlow,colFillGlow,nAlignTxt,bFrameEn,bFillEn,callFunc,extraData) \
static const char str##nElemId[] PROGMEM = strTxt; \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_GLOW_EN | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId PROGMEM = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_BTN, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,colFrameGlow,colFillGlow, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)str##nElemId, \
0, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_PROG | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxt, \
nAlignTxt, \
0, \
0, \
pFont, \
(void*)extraData, \
NULL, \
NULL, \
callFunc, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateBtnTxt_P_R(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colFrame,colFill,colFrameGlow,colFillGlow,nAlignTxt,bFrameEn,bFillEn,callFunc,extraData) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_GLOW_EN | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId PROGMEM = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_BTN, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,colFrameGlow,colFillGlow, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)strTxt, \
strLength, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxt, \
nAlignTxt, \
0, \
0, \
pFont, \
(void*)extraData, \
NULL, \
NULL, \
callFunc, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#else
#define gslc_ElemCreateTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn) \
static const char str##nElemId[] = strTxt; \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_TXT, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)str##nElemId, \
0, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxt, \
nAlignTxt, \
0, \
0, \
pFont, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateTxt_P_R(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colFrame,colFill,nAlignTxt,bFrameEn,bFillEn) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_TXT, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)strTxt, \
strLength, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxt, \
nAlignTxt, \
0, \
0, \
pFont, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateTxt_P_R_ext(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,strLength,pFont,colTxt,colTxtGlow,colFrame,colFill,nAlignTxt,nMarginX,nMarginY,bFrameEn,bFillEn,bClickEn,bGlowEn,pfuncXEvent,pfuncXDraw,pfuncXTouch,pfuncXTick) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0) | (bClickEn?GSLC_ELEM_FEA_CLICK_EN:0) | (bGlowEn?GSLC_ELEM_FEA_GLOW_EN:0); \
static const gslc_tsElem sElem##nElemId = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_TXT, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)strTxt, \
strLength, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxtGlow, \
nAlignTxt, \
nMarginX, \
nMarginY, \
pFont, \
NULL, \
pfuncXEvent, \
pfuncXDraw, \
pfuncXTouch, \
pfuncXTick, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateBox_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFrame,colFill,bFrameEn,bFillEn,pfuncXDraw,pfuncXTick) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_BOX, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
NULL, \
0, \
GSLC_TXT_DEFAULT, \
GSLC_COL_WHITE, \
GSLC_COL_WHITE, \
GSLC_ALIGN_MID_MID, \
0, \
0, \
NULL, \
NULL, \
NULL, \
pfuncXDraw, \
NULL, \
pfuncXTick, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateLine_P(pGui,nElemId,nPage,nX0,nY0,nX1,nY1,colFill) \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID; \
static const gslc_tsElem sElem##nElemId = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_LINE, \
(gslc_tsRect){nX0,nY0,nX1-nX0+1,nY1-nY0+1}, \
GSLC_GROUP_ID_NONE, \
colFill,colFill,GSLC_COL_BLACK,GSLC_COL_BLACK, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
NULL, \
0, \
GSLC_TXT_DEFAULT, \
GSLC_COL_WHITE, \
GSLC_COL_WHITE, \
GSLC_ALIGN_MID_MID, \
0, \
0, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#define gslc_ElemCreateBtnTxt_P(pGui,nElemId,nPage,nX,nY,nW,nH,strTxt,pFont,colTxt,colFrame,colFill,colFrameGlow,colFillGlow,nAlignTxt,bFrameEn,bFillEn,callFunc,extraData) \
static const char str##nElemId[] = strTxt; \
static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_GLOW_EN | \
(bFrameEn?GSLC_ELEM_FEA_FRAME_EN:0) | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
static const gslc_tsElem sElem##nElemId = { \
nElemId, \
nFeatures##nElemId, \
GSLC_TYPE_BTN, \
(gslc_tsRect){nX,nY,nW,nH}, \
GSLC_GROUP_ID_NONE, \
colFrame,colFill,colFrameGlow,colFillGlow, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
(gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL}, \
NULL, \
(char*)str##nElemId, \
0, \
(gslc_teTxtFlags)(GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT), \
colTxt, \
colTxt, \
nAlignTxt, \
0, \
0, \
pFont, \
(void*)extraData, \
NULL, \
NULL, \
callFunc, \
NULL, \
}; \
gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId, \
(gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
#endif // GSLC_USE_PROGMEM
// ========================================================================
/// @}
/// \defgroup _Int_ Internal Functions
/// These functions are internal to the GUIslice implementation and are not
/// intended to be called by user code and subject to change even in minor
/// releases.
/// - The following functions are generally not required for
/// typical users of GUIslice. However, for advanced usage
/// more direct access may be required.
/// @{
// ========================================================================
// ------------------------------------------------------------------------
/// \defgroup _IntMisc_ Internal: Misc Functions
/// @{
// ------------------------------------------------------------------------
///
/// Create a blank image reference structure
///
/// \return Image reference struct
///
gslc_tsImgRef gslc_ResetImage();
// ------------------------------------------------------------------------
/// @}
/// \defgroup _IntElem_ Internal: Element Functions
/// @{
// ------------------------------------------------------------------------
///
/// Create a new element with default styling
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nElemId: User-supplied ID for referencing this element
/// (or GSLC_ID_AUTO to auto-generate)
/// \param[in] nPageId: The page ID on which this page should be associated
/// \param[in] nType: Enumeration that indicates the type of element
/// that is requested for creation. The type adjusts
/// the visual representation and default styling.
/// \param[in] rElem: Rectangle region framing the element
/// \param[in] pStrBuf: String to copy into element
/// \param[in] nStrBufMax: Maximum length of string buffer (pStrBuf). Only applicable
/// if GSLC_LOCAL_STR=0. Ignored if GSLC_LOCAL_STR=1.)
/// \param[in] nFontId: Font ID for textual elements
///
/// \return Initialized structure
///
gslc_tsElem gslc_ElemCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPageId,int16_t nType,
gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,int16_t nFontId);
///
/// Add the Element to the list of generated elements
/// in the GUI environment.
/// - NOTE: The content of pElem is copied so the pointer
/// can be released after the call.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: Page ID to add element to (GSLC_PAGE_NONE to skip in
/// case of temporary creation for compound elements)
/// \param[in] pElem: Pointer to Element to add
/// \param[in] eFlags: Flags describing the element (eg. whether the
/// element should be stored in internal RAM array
/// or is located in Flash/PROGMEM).
///
/// \return Pointer to Element reference or NULL if fail
///
gslc_tsElemRef* gslc_ElemAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* pElem,gslc_teElemRefFlags eFlags);
///
/// Get the flags associated with an element reference
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Element reference pointer
/// \param[in] nFlagMask: Flags to read
///
/// \return Values associated with the element reference flags (subject to the flag mask)
///
uint8_t gslc_GetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask);
///
/// Set the flags associated with an element reference
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Element reference pointer
/// \param[in] nFlagMask: Flags to read
/// \param[in] nFlagVal: Values to assign to masked flags
///
/// \return none
///
void gslc_SetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask,uint8_t nFlagVal);
/// Returns a pointer to an element from an element reference, copying
/// from FLASH to RAM if element is stored in PROGMEM. This function
/// enables all APIs to work with Elements irrespective of whether they
/// were created in RAM or Flash.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element Reference
///
/// \return Pointer to Element after ensuring that it is accessible from RAM
///
// TODO: Mark this as public API
gslc_tsElem* gslc_GetElemFromRef(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
/// Returns a pointer to an element from an element reference.
/// This is a wrapper for GetElemFromRef() including debug checking
/// for invalid pointers.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element Reference
/// \param[in] nLineNum: Line number from calling function (ie. __LINE__)
///
/// \return Pointer to Element after ensuring that it is accessible from RAM
///
gslc_tsElem* gslc_GetElemFromRefD(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nLineNum);
/// Returns a pointer to the data structure associated with an extended element.
/// - Example usage:
/// gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element Reference
/// \param[in] nType: Expected type indicator (ie. GSLC_TYPEX_*)
/// \param[in] nLineNum: Line number from calling function (ie. __LINE__)
///
/// \return Void pointer to extended data (pXData), or NULL if error. Needs to be typecasted accordingly.
///
void* gslc_GetXDataFromRef(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nType, int16_t nLineNum);
///
/// Set an element to use a bitmap image
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Pointer to Element reference to update
/// \param[in] sImgRef: Image reference (normal state)
/// \param[in] sImgRefSel: Image reference (glowing state)
///
/// \return none
///
void gslc_ElemSetImage(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsImgRef sImgRef,
gslc_tsImgRef sImgRefSel);
/// Draw an element to the active display
/// - Element is referenced by an element pointer
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRef: Ptr to Element reference to draw
/// \param[in] eRedraw: Redraw mode
///
/// \return true if success, false otherwise
///
bool gslc_ElemDrawByRef(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
///
/// Draw an element to the active display
/// - Element is referenced by a page ID and element ID
/// - Provides similar functionality as ElemDrawByRef() but accepts page and element IDs
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: ID of page containing element
/// \param[in] nElemId: ID of element
///
/// \return none
///
void gslc_ElemDraw(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId);
///
/// Draw text with full text justification
/// - This function is usually only required by internal GUIslice rendering
/// operations but is made available for custom element usage as well
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pStrBuf: Pointer to text string buffer
/// \param[in] rTxt: Rectangle region to contain the text
/// \param[in] pTxtFont: Pointer to the font
/// \param[in] eTxtFlags: Text string attributes
/// \param[in] eTxtAlign: Text alignment / justification mode
/// \param[in] colTxt: Text foreground color
/// \param[in] colBg: Text background color
/// \param[in] nMarginW: Horizontal margin within rect region to keep text away
/// \param[in] nMarginH: Vertical margin within rect region to keep text away
///
/// \return none
///
void gslc_DrawTxtBase(gslc_tsGui* pGui, char* pStrBuf, gslc_tsRect rTxt, gslc_tsFont* pTxtFont, gslc_teTxtFlags eTxtFlags,
int8_t eTxtAlign, gslc_tsColor colTxt, gslc_tsColor colBg, int16_t nMarginW, int16_t nMarginH);
///
/// Set the global rounded radius
/// - Used for rounded rectangles
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nRadius: Radius for rounded elements
///
/// \return none
///
void gslc_SetRoundRadius(gslc_tsGui* pGui, uint8_t nRadius);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _IntPage_ Internal: Page Functions
/// @{
// ------------------------------------------------------------------------
///
/// Common event handler function for a page
///
/// \param[in] pvGui: Void pointer to GUI
/// \param[in] sEvent: Event data structure
///
/// \return true if success, false if fail
///
bool gslc_PageEvent(void* pvGui,gslc_tsEvent sEvent);
/* UNUSED
///
/// Assign the event callback function for a page
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pPage: Pointer to page
/// \param[in] funcCb: Function pointer to event routine (or NULL for default))
///
/// \return none
///
void gslc_PageSetEventFunc(gslc_tsGui* pGui,gslc_tsPage* pPage,GSLC_CB_EVENT funcCb);
*/
///
/// Redraw all elements on the active page. Only the
/// elements that have been marked as needing redraw are
/// rendered unless the entire page has been marked as
/// needing redraw (in which case everything is drawn)
///
/// \param[in] pGui: Pointer to GUI
///
/// \return none
///
void gslc_PageRedrawGo(gslc_tsGui* pGui);
///
/// Indicate whether the screen requires page flip
/// - This is generally called with bNeeded=true whenever
/// drawing has been done to the active page. Page flip
/// is actually performed later when calling PageFlipGo().
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] bNeeded: True if screen requires page flip
///
/// \return None
///
void gslc_PageFlipSet(gslc_tsGui* pGui,bool bNeeded);
///
/// Get state of pending page flip state
///
/// \param[in] pGui: Pointer to GUI
///
/// \return True if screen requires page flip
///
bool gslc_PageFlipGet(gslc_tsGui* pGui);
///
/// Update the visible screen if page has been marked for flipping
/// - On some hardware this can trigger a double-buffering
/// page flip.
///
/// \param[in] pGui: Pointer to GUI
///
/// \return None
///
void gslc_PageFlipGo(gslc_tsGui* pGui);
/// Find a page in the GUI by its ID
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] nPageId: Page ID to search
///
/// \return Ptr to a page or NULL if none found
///
gslc_tsPage* gslc_PageFindById(gslc_tsGui* pGui,int16_t nPageId);
/// Perform a redraw calculation on the page to determine if additional
/// elements should also be redrawn. This routine checks to see if any
/// transparent elements have been marked as needing redraw. If so, the
/// whole page may be marked as needing redraw (or at least the other
/// elements that have been exposed underneath).
///
/// \param[in] pGui: Pointer to GUI
///
/// \return none
///
/// \internal
void gslc_PageRedrawCalc(gslc_tsGui* pGui);
/// \todo Doc. This API is experimental and subject to change
int16_t gslc_PageFocusStep(gslc_tsGui* pGui,gslc_tsPage* pPage,bool bNext);
///
/// Create an event structure
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] eType: Event type (draw, touch, tick, etc.)
/// \param[in] nSubType: Refinement of event type (or 0 if unused)
/// \param[in] pvScope: Void ptr to object receiving event so that
/// the event handler will have the context
/// \param[in] pvData: Void ptr to additional data associated with
/// the event (eg. coordinates for touch events)
///
/// \return None
///
gslc_tsEvent gslc_EventCreate(gslc_tsGui* pGui,gslc_teEventType eType,uint8_t nSubType,void* pvScope,void* pvData);
///
/// Common event handler function for an element
///
/// \param[in] pvGui: Void pointer to GUI
/// \param[in] sEvent: Event data structure
///
/// \return true if success, false if fail
///
bool gslc_ElemEvent(void* pvGui,gslc_tsEvent sEvent);
#if !defined(DRV_TOUCH_NONE)
///
/// Trigger an element's touch event. This is an optional
/// behavior useful in some extended element types.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pElemRefTracked: Pointer to tracked Element reference (or NULL for none))
/// \param[in] eTouch: Touch event type
/// \param[in] nX: X coordinate of event (absolute coordinate)
/// \param[in] nY: Y coordinate of event (absolute coordinate)
///
/// \return true if success, false if error
///
bool gslc_ElemSendEventTouch(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefTracked,
gslc_teTouch eTouch,int16_t nX,int16_t nY);
#endif // !DRV_TOUCH_NONE
// ------------------------------------------------------------------------
// Internal: Element Collection Functions
// ------------------------------------------------------------------------
/// @}
/// \defgroup _IntCollect_ Internal: Element Collection Functions
/// @{
/// Reset the members of an element collection
///
/// \param[in] pCollect: Pointer to the collection
/// \param[in] asElem: Internal element array storage to associate with the
/// collection
/// \param[in] nElemMax: Maximum number of elements that can be added to the
/// internal element array (ie. RAM))
/// \param[in] asElemRef: Internal element reference array storage to
/// associate with the collection. All elements, whether they
/// are located in the internal element array or in
/// external Flash (PROGMEM) storage, require an entry
/// in the element reference array.
/// \param[in] nElemRefMax: Maximum number of elements in the reference array.
/// This is effectively the maximum number of elements
/// that can appear in the collection, irrespective of whether
/// it is stored in RAM or Flash (PROGMEM).
///
/// \return none
///
void gslc_CollectReset(gslc_tsCollect* pCollect,gslc_tsElem* asElem,uint16_t nElemMax,
gslc_tsElemRef* asElemRef,uint16_t nElemRefMax);
/// Add an element to a collection
/// - Note that the contents of pElem are copied to the collection's
/// element array so the pElem pointer can be discarded are the
/// call is complete.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
/// \param[in] pElem: Ptr to the element to add
/// \param[in] eFlags: Flags describing the element (eg. whether the
/// element should be stored in internal RAM array
/// or is located in Flash/PROGMEM).
///
/// \return Pointer to the element reference in the collection that has been added
/// or NULL if there was an error
///
gslc_tsElemRef* gslc_CollectElemAdd(gslc_tsGui* pGui,gslc_tsCollect* pCollect,const gslc_tsElem* pElem,gslc_teElemRefFlags eFlags);
///
/// Determine if any elements in a collection need redraw
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to Element collection
///
/// \return True if redraw required, false otherwise
///
bool gslc_CollectGetRedraw(gslc_tsGui* pGui,gslc_tsCollect* pCollect);
/// Find an element in a collection by its Element ID
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
/// \param[in] nElemId: Element ID to search for
///
/// \return Pointer to the element reference in the collection that was found
/// or NULL if no matches found
///
gslc_tsElemRef* gslc_CollectFindElemById(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nElemId);
/// Find an element in a collection by a coordinate coordinate
/// - A match is found if the element is "clickable" (bClickEn=true)
/// and the coordinate falls within the element's bounds (rElem).
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
/// \param[in] nX: Absolute X coordinate to use for search
/// \param[in] nY: Absolute Y coordinate to use for search
///
/// \return Pointer to the element reference in the collection that was found
/// or NULL if no matches found
///
gslc_tsElemRef* gslc_CollectFindElemFromCoord(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nX, int16_t nY);
/// Allocate the next available Element ID in a collection
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
///
/// \return Element ID that is reserved for use
///
int gslc_CollectGetNextId(gslc_tsGui* pGui,gslc_tsCollect* pCollect);
/// Get the element within a collection that is currently being tracked
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
///
/// \return Pointer to the element reference in the collection that is
/// currently being tracked or NULL if no elements
/// are being tracked
///
gslc_tsElemRef* gslc_CollectGetElemRefTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect);
/// Set the element within a collection that is currently being tracked
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
/// \param[in] pElemRef: Ptr to element reference to mark as being tracked
///
/// \return none
///
void gslc_CollectSetElemTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRef);
/// Get the element index within a collection that is currently in focus
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
///
/// \return Element index or GSLC_IND_NONE for none
///
int16_t gslc_CollectGetFocus(gslc_tsGui* pGui, gslc_tsCollect* pCollect);
/// Set the element index within a collection that is currently in focus
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
/// \param[in] nElemInd: Element index to set in focus, GSLC_IND_NONE for none
///
/// \return none
///
void gslc_CollectSetFocus(gslc_tsGui* pGui, gslc_tsCollect* pCollect, int16_t nElemInd);
/// \todo Doc. This API is experimental and subject to change
bool gslc_CollectFindFocusStep(gslc_tsGui* pGui,gslc_tsCollect* pCollect,bool bNext,bool* pbWrapped,int16_t* pnElemInd);
/// Assign the parent element reference to all elements within a collection
/// - This is generally used in the case of compound elements where updates to
/// a sub-element should cause the parent (compound element) to be redrawn
/// as well.)
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to the collection
/// \param[in] pElemRefParent: Ptr to element reference that is the parent
///
/// \return none
///
void gslc_CollectSetParent(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRefParent);
// ------------------------------------------------------------------------
// Internal: Collect Event Handlers
// ------------------------------------------------------------------------
/// @}
/// \defgroup _IntCollectEvt_ Internal: Element Collection Event Functions
/// @{
/* UNUSED
///
/// Assign the event callback function for an element collection
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to collection
/// \param[in] funcCb: Function pointer to event routine (or NULL for default))
///
/// \return none
///
void gslc_CollectSetEventFunc(gslc_tsGui* pGui,gslc_tsCollect* pCollect,GSLC_CB_EVENT funcCb);
*/
///
/// Common event handler function for an element collection
///
/// \param[in] pvGui: Void pointer to GUI
/// \param[in] sEvent: Event data structure
///
/// \return true if success, false if fail
///
bool gslc_CollectEvent(void* pvGui,gslc_tsEvent sEvent);
#if !defined(DRV_TOUCH_NONE)
/// Handle touch events within the element collection
///
/// \param[in] pGui: Pointer to the GUI
/// \param[in] pCollect: Ptr to the element collection
/// \param[in] pEventTouch: Ptr to the touch event structure
///
/// \return none
///
void gslc_CollectTouch(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch);
/// Handle dispatch of touch (up,down,move) events to compound elements sub elements
///
/// \param[in] pvGui: Void ptr to GUI (typecast to gslc_tsGui*)
/// \param[in] pvElemRef: Void ptr to Element Reference(typecast to gslc_tsElemRef*)
/// \param[in] eTouch: Touch event type
/// \param[in] nRelX: Touch X coord relative to element
/// \param[in] nRelY: Touch Y coord relative to element
/// \param[in] pCollect: Collection containing sub elements
///
/// \return true if success, false otherwise
///
bool gslc_CollectTouchCompound(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY, gslc_tsCollect* pCollect);
/// Handle direct input events within the element collection
///
/// \param[in] pGui: Pointer to the GUI
/// \param[in] pCollect: Ptr to the element collection
/// \param[in] pEventTouch: Ptr to the touch event structure
///
/// \return none
///
void gslc_CollectInput(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch);
// ------------------------------------------------------------------------
/// @}
/// \defgroup _IntTrack_ Internal: Tracking Functions
/// @{
// ------------------------------------------------------------------------
///
/// Handles a touch event and performs the necessary
/// tracking, glowing and selection actions depending
/// on the press state.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pPage: Pointer to current page
/// \param[in] nX: X coordinate of touch event
/// \param[in] nY: Y coordinate of touch event
/// \param[in] nPress: Pressure level of touch event (0 for none, else touch)
///
/// \return none
///
void gslc_TrackTouch(gslc_tsGui* pGui,gslc_tsPage* pPage,int16_t nX,int16_t nY,uint16_t nPress);
///
/// Handles a direct input event and performs the necessary
/// tracking, glowing and selection actions depending
/// on the state.
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pPage: Pointer to current page
/// \param[in] eInputEvent Indication of event type
/// \param[in] nInputVal Additional data for event type
///
/// \return none
///
void gslc_TrackInput(gslc_tsGui* pGui,gslc_tsPage* pPage,gslc_teInputRawEvent eInputEvent,int16_t nInputVal);
/// \todo Doc. This API is experimental and subject to change
bool gslc_InputMapLookup(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction* peAction,int16_t* pnActionVal);
#endif // !DRV_TOUCH_NONE
// ------------------------------------------------------------------------
/// @}
/// \defgroup _IntCleanup_ Internal: Cleanup Functions
/// @{
// ------------------------------------------------------------------------
///
/// Free up any surfaces associated with the GUI,
/// pages, collections and elements. Also frees
/// up any fonts.
/// - Called by gslc_Quit()
///
/// \param[in] pGui: Pointer to GUI
///
/// \return none
///
void gslc_GuiDestruct(gslc_tsGui* pGui);
///
/// Free up any members associated with a page
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pPage: Pointer to Page
///
/// \return none
///
void gslc_PageDestruct(gslc_tsGui* pGui,gslc_tsPage* pPage);
///
/// Free up any members associated with an element collection
///
/// \param[in] pGui: Pointer to GUI
/// \param[in] pCollect: Pointer to collection
///
/// \return none
///
void gslc_CollectDestruct(gslc_tsGui* pGui,gslc_tsCollect* pCollect);
///
/// Free up any members associated with an element
///
/// \param[in] pElem: Pointer to element
///
/// \return none
///
void gslc_ElemDestruct(gslc_tsElem* pElem);
///
/// Initialize a Font struct
///
/// \param[in] pFont: Pointer to Font
///
/// \return none
///
void gslc_ResetFont(gslc_tsFont* pFont);
///
/// Initialize an Element struct
///
/// \param[in] pElem: Pointer to Element
///
/// \return none
///
void gslc_ResetElem(gslc_tsElem* pElem);
/// @}
/// End of Internal Functions
#ifdef __cplusplus
}
#endif // __cplusplus
#endif // _GUISLICE_H_
Reference in New Issue View Git Blame Copy Permalink