GUIslice.h

Go to the documentation of this file.

#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.16.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.
//
// =======================================================================


#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);

extern GSLC_CB_DEBUG_OUT g_pfDebugOut;


// -----------------------------------------------------------------------
// Constants
// -----------------------------------------------------------------------
#define GSLC_2PI  6.28318530718

// -----------------------------------------------------------------------
// Enumerations
// -----------------------------------------------------------------------

  typedef enum {
    // Public usage
    GSLC_ID_USER_BASE       = 0,      
    GSLC_ID_NONE            = -1999,  
    GSLC_ID_AUTO,                     
    GSLC_ID_TEMP,                     
    // Internal usage
    GSLC_ID_AUTO_BASE       = 16384,  
  } gslc_teElemId;


  typedef enum {
    // Public usage
    GSLC_PAGE_USER_BASE     = 0,      
    // Internal usage
    GSLC_PAGE_NONE          = -2999,  
  } gslc_tePageId;

  typedef enum {
    GSLC_STACK_BASE = 0,               
    GSLC_STACK_CUR,                    
    GSLC_STACK_OVERLAY,                

    GSLC_STACK__MAX                    
  } gslc_teStackPage;

  typedef enum {
    // Public usage
    GSLC_GROUP_ID_USER_BASE = 0,      
    // Internal usage
    GSLC_GROUP_ID_NONE      = -6999,  
  } gslc_teGroupId;

  typedef enum {
    // Public usage
    GSLC_FONT_USER_BASE     = 0,      
    GSLC_FONT_NONE          = -4999,  
  } gslc_teFontId;


  //    into the GUI's array of elements
  typedef enum {
    // Internal usage
    GSLC_IND_NONE           = -9999,  
    GSLC_IND_FIRST          = 0,      
  } gslc_teElemInd;


typedef enum {
    // Core elements:
    GSLC_TYPE_NONE,         
    GSLC_TYPE_BKGND,        
    GSLC_TYPE_BTN,          
    GSLC_TYPE_TXT,          
    GSLC_TYPE_BOX,          
    GSLC_TYPE_LINE,         

    GSLC_TYPE_BASE_EXTEND = 0x1000
} gslc_teTypeCore;

#define GSLC_ELEM_FEA_VALID     0x80      
#define GSLC_ELEM_FEA_EDIT_EN   0x20      
#define GSLC_ELEM_FEA_ROUND_EN  0x10      
#define GSLC_ELEM_FEA_CLICK_EN  0x08      
#define GSLC_ELEM_FEA_GLOW_EN   0x04      
#define GSLC_ELEM_FEA_FRAME_EN  0x02      
#define GSLC_ELEM_FEA_FILL_EN   0x01      
#define GSLC_ELEM_FEA_NONE      0x00      


#define GSLC_ALIGNV_TOP       0x10                                
#define GSLC_ALIGNV_MID       0x20                                
#define GSLC_ALIGNV_BOT       0x40                                
#define GSLC_ALIGNH_LEFT      0x01                                
#define GSLC_ALIGNH_MID       0x02                                
#define GSLC_ALIGNH_RIGHT     0x04                                
#define GSLC_ALIGN_TOP_LEFT   GSLC_ALIGNH_LEFT  | GSLC_ALIGNV_TOP 
#define GSLC_ALIGN_TOP_MID    GSLC_ALIGNH_MID   | GSLC_ALIGNV_TOP 
#define GSLC_ALIGN_TOP_RIGHT  GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_TOP 
#define GSLC_ALIGN_MID_LEFT   GSLC_ALIGNH_LEFT  | GSLC_ALIGNV_MID 
#define GSLC_ALIGN_MID_MID    GSLC_ALIGNH_MID   | GSLC_ALIGNV_MID 
#define GSLC_ALIGN_MID_RIGHT  GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_MID 
#define GSLC_ALIGN_BOT_LEFT   GSLC_ALIGNH_LEFT  | GSLC_ALIGNV_BOT 
#define GSLC_ALIGN_BOT_MID    GSLC_ALIGNH_MID   | GSLC_ALIGNV_BOT 
#define GSLC_ALIGN_BOT_RIGHT  GSLC_ALIGNH_RIGHT | GSLC_ALIGNV_BOT 


#define GSLC_COL_RED_DK4    (gslc_tsColor) {128,  0,  0}   
#define GSLC_COL_RED_DK3    (gslc_tsColor) {160,  0,  0}   
#define GSLC_COL_RED_DK2    (gslc_tsColor) {192,  0,  0}   
#define GSLC_COL_RED_DK1    (gslc_tsColor) {224,  0,  0}   
#define GSLC_COL_RED        (gslc_tsColor) {255,  0,  0}   
#define GSLC_COL_RED_LT1    (gslc_tsColor) {255, 32, 32}   
#define GSLC_COL_RED_LT2    (gslc_tsColor) {255, 64, 64}   
#define GSLC_COL_RED_LT3    (gslc_tsColor) {255, 96, 96}   
#define GSLC_COL_RED_LT4    (gslc_tsColor) {255,128,128}   
#define GSLC_COL_GREEN_DK4  (gslc_tsColor) {  0,128,  0}   
#define GSLC_COL_GREEN_DK3  (gslc_tsColor) {  0,160,  0}   
#define GSLC_COL_GREEN_DK2  (gslc_tsColor) {  0,192,  0}   
#define GSLC_COL_GREEN_DK1  (gslc_tsColor) {  0,224,  0}   
#define GSLC_COL_GREEN      (gslc_tsColor) {  0,255,  0}   
#define GSLC_COL_GREEN_LT1  (gslc_tsColor) { 32,255, 32}   
#define GSLC_COL_GREEN_LT2  (gslc_tsColor) { 64,255, 64}   
#define GSLC_COL_GREEN_LT3  (gslc_tsColor) { 96,255, 96}   
#define GSLC_COL_GREEN_LT4  (gslc_tsColor) {128,255,128}   
#define GSLC_COL_BLUE_DK4   (gslc_tsColor) {  0,  0,128}   
#define GSLC_COL_BLUE_DK3   (gslc_tsColor) {  0,  0,160}   
#define GSLC_COL_BLUE_DK2   (gslc_tsColor) {  0,  0,192}   
#define GSLC_COL_BLUE_DK1   (gslc_tsColor) {  0,  0,224}   
#define GSLC_COL_BLUE       (gslc_tsColor) {  0,  0,255}   
#define GSLC_COL_BLUE_LT1   (gslc_tsColor) { 32, 32,255}   
#define GSLC_COL_BLUE_LT2   (gslc_tsColor) { 64, 64,255}   
#define GSLC_COL_BLUE_LT3   (gslc_tsColor) { 96, 96,255}   
#define GSLC_COL_BLUE_LT4   (gslc_tsColor) {128,128,255}   
#define GSLC_COL_BLACK      (gslc_tsColor) {  0,  0,  0}   
#define GSLC_COL_GRAY_DK3   (gslc_tsColor) { 32, 32, 32}   
#define GSLC_COL_GRAY_DK2   (gslc_tsColor) { 64, 64, 64}   
#define GSLC_COL_GRAY_DK1   (gslc_tsColor) { 96, 96, 96}   
#define GSLC_COL_GRAY       (gslc_tsColor) {128,128,128}   
#define GSLC_COL_GRAY_LT1   (gslc_tsColor) {160,160,160}   
#define GSLC_COL_GRAY_LT2   (gslc_tsColor) {192,192,192}   
#define GSLC_COL_GRAY_LT3   (gslc_tsColor) {224,224,224}   
#define GSLC_COL_WHITE      (gslc_tsColor) {255,255,255}   

#define GSLC_COL_YELLOW     (gslc_tsColor) {255,255,0}     
#define GSLC_COL_YELLOW_DK  (gslc_tsColor) {64,64,0}       
#define GSLC_COL_PURPLE     (gslc_tsColor) {128,0,128}     
#define GSLC_COL_CYAN       (gslc_tsColor) {0,255,255}     
#define GSLC_COL_MAGENTA    (gslc_tsColor) {255,0,255}     
#define GSLC_COL_TEAL       (gslc_tsColor) {0,128,128}     
#define GSLC_COL_ORANGE     (gslc_tsColor) {255,165,0}     
#define GSLC_COL_BROWN      (gslc_tsColor) {165,42,42}     

// Monochrome definitions
#define GSLC_COLMONO_BLACK  (gslc_tsColor) {255,255,255}   
#define GSLC_COLMONO_WHITE  (gslc_tsColor) {  0,  0,  0}   



typedef enum {
  GSLC_INPUT_NONE,          
  GSLC_INPUT_TOUCH,         
  GSLC_INPUT_KEY_DOWN,      
  GSLC_INPUT_KEY_UP,        
  GSLC_INPUT_PIN_ASSERT,    
  GSLC_INPUT_PIN_DEASSERT,  
} gslc_teInputRawEvent;


typedef enum {
  GSLC_ACTION_UNDEF,        
  GSLC_ACTION_NONE,         
  GSLC_ACTION_FOCUS_PREV,   
  GSLC_ACTION_FOCUS_NEXT,   
  GSLC_ACTION_SELECT,       
  GSLC_ACTION_SET_REL,      
  GSLC_ACTION_SET_ABS,      
  GSLC_ACTION_DEBUG         
} gslc_teAction;


typedef enum {
  GSLC_PIN_BTN_A,           
  GSLC_PIN_BTN_A_LONG,      
  GSLC_PIN_BTN_B,           
  GSLC_PIN_BTN_B_LONG,      
  GSLC_PIN_BTN_C,           
  GSLC_PIN_BTN_C_LONG,      
  GSLC_PIN_BTN_D,           
  GSLC_PIN_BTN_D_LONG,      
  GSLC_PIN_BTN_E,           
  GSLC_PIN_BTN_E_LONG,      
  GSLC_PIN_BTN_UP,          
  GSLC_PIN_BTN_DOWN,        
  GSLC_PIN_BTN_LEFT,        
  GSLC_PIN_BTN_RIGHT,       
  GSLC_PIN_BTN_SEL,         
} gslc_tePin;


typedef enum {
  GSLC_TOUCH_NONE         = 0,          

  // Indexed state (ie. key/GPIO selects specific element vs touch coordinate)
  GSLC_TOUCH_TYPE_MASK    = (1<<7),     
  GSLC_TOUCH_COORD        = (0<<7),     
  GSLC_TOUCH_DIRECT       = (1<<7),     

  GSLC_TOUCH_SUBTYPE_MASK =                     (15<<0),    

  // Coordinate-based events
  GSLC_TOUCH_DOWN         = GSLC_TOUCH_COORD  | ( 1<<0),    
  GSLC_TOUCH_DOWN_IN      = GSLC_TOUCH_COORD  | ( 2<<0),    
  GSLC_TOUCH_DOWN_OUT     = GSLC_TOUCH_COORD  | ( 3<<0),    
  GSLC_TOUCH_UP           = GSLC_TOUCH_COORD  | ( 4<<0),    
  GSLC_TOUCH_UP_IN        = GSLC_TOUCH_COORD  | ( 5<<0),    
  GSLC_TOUCH_UP_OUT       = GSLC_TOUCH_COORD  | ( 6<<0),    
  GSLC_TOUCH_MOVE         = GSLC_TOUCH_COORD  | ( 7<<0),    
  GSLC_TOUCH_MOVE_IN      = GSLC_TOUCH_COORD  | ( 8<<0),    
  GSLC_TOUCH_MOVE_OUT     = GSLC_TOUCH_COORD  | ( 9<<0),    
  // Index-based events
  GSLC_TOUCH_FOCUS_ON     = GSLC_TOUCH_DIRECT | ( 1<<0),    
  GSLC_TOUCH_FOCUS_OFF    = GSLC_TOUCH_DIRECT | ( 2<<0),    
  GSLC_TOUCH_FOCUS_SELECT = GSLC_TOUCH_DIRECT | ( 3<<0),    
  GSLC_TOUCH_SET_REL      = GSLC_TOUCH_DIRECT | ( 4<<0),    
  GSLC_TOUCH_SET_ABS      = GSLC_TOUCH_DIRECT | ( 5<<0),    

} gslc_teTouch;

typedef enum {
  GSLC_INITSTAT_UNDEF = 0,       
  GSLC_INITSTAT_INACTIVE,        
  GSLC_INITSTAT_FAIL,            
  GSLC_INITSTAT_ACTIVE           
} gslc_teInitStat;



  #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 )


typedef enum {
  GSLC_EVT_NONE,          
  GSLC_EVT_DRAW,          
  GSLC_EVT_TOUCH,         
  GSLC_EVT_TICK,          
  GSLV_EVT_CUSTOM         
} gslc_teEventType;

typedef enum {
  GSLC_EVTSUB_NONE,
  GSLC_EVTSUB_DRAW_NEEDED,  
  GSLC_EVTSUB_DRAW_FORCE    
} gslc_teEventSubType;

typedef enum {
  GSLC_REDRAW_NONE,         
  GSLC_REDRAW_FULL,         
  GSLC_REDRAW_INC           
} gslc_teRedrawType;


typedef enum {
  GSLC_FONTREF_FNAME,      
  GSLC_FONTREF_PTR         
} gslc_teFontRefType;


typedef enum {
  GSLC_FONTREF_MODE_DEFAULT, 
  GSLC_FONTREF_MODE_1,       
  GSLC_FONTREF_MODE_2,       
  GSLC_FONTREF_MODE_3        
} gslc_teFontRefMode;


typedef enum {
  GSLC_ELEMREF_NONE        = 0,       
  // Define element sources
  GSLC_ELEMREF_SRC_RAM     = (1<<0),  
  GSLC_ELEMREF_SRC_PROG    = (2<<0),  
  GSLC_ELEMREF_SRC_CONST   = (3<<0),  
  // Element State
  GSLC_ELEMREF_REDRAW_NONE = (0<<4),  
  GSLC_ELEMREF_REDRAW_FULL = (1<<4),  
  GSLC_ELEMREF_REDRAW_INC  = (2<<4),  

  GSLC_ELEMREF_GLOWING     = (1<<6),  
  GSLC_ELEMREF_VISIBLE     = (1<<7),  

  // Mask values for bitfield comparisons
  GSLC_ELEMREF_SRC            = (3<<0),   
  GSLC_ELEMREF_REDRAW_MASK    = (3<<4),   

} gslc_teElemRefFlags;

#define GSLC_ELEMREF_DEFAULT  (GSLC_ELEMREF_SRC_RAM | GSLC_ELEMREF_VISIBLE)


typedef enum {
  GSLC_IMGREF_NONE        = 0,        
  // Define image sources
  GSLC_IMGREF_SRC_FILE    = (1<<0),   
  GSLC_IMGREF_SRC_SD      = (2<<0),   
  GSLC_IMGREF_SRC_RAM     = (3<<0),   
  GSLC_IMGREF_SRC_PROG    = (4<<0),   
  // Define image types

  GSLC_IMGREF_FMT_BMP24   = (1<<4),   
  GSLC_IMGREF_FMT_BMP16   = (2<<4),   
  GSLC_IMGREF_FMT_RAW1    = (3<<4),   
  GSLC_IMGREF_FMT_JPG     = (4<<4),   

  // Mask values for bitfield comparisons
  GSLC_IMGREF_SRC         = (7<<0),   
  GSLC_IMGREF_FMT         = (7<<4),   
} gslc_teImgRefFlags;

typedef enum {
  // Values
  GSLC_TXT_MEM_RAM        = (0<<0),   
  GSLC_TXT_MEM_PROG       = (1<<0),   
  GSLC_TXT_ALLOC_NONE     = (0<<2),   
  GSLC_TXT_ALLOC_INT      = (1<<2),   
  GSLC_TXT_ALLOC_EXT      = (2<<2),   
  GSLC_TXT_ENC_PLAIN      = (0<<4),   
  GSLC_TXT_ENC_UTF8       = (1<<4),   

  // Masks
  GSLC_TXT_MEM            = (3<<0),   
  GSLC_TXT_ALLOC          = (3<<2),   
  GSLC_TXT_ENC            = (3<<4),   
  // 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
// -----------------------------------------------------------------------


typedef bool (*GSLC_CB_EVENT)(void* pvGui,gslc_tsEvent sEvent);

typedef bool (*GSLC_CB_DRAW)(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);

typedef bool (*GSLC_CB_TOUCH)(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);

typedef bool (*GSLC_CB_TICK)(void* pvGui,void* pvElemRef);

typedef bool (*GSLC_CB_PIN_POLL)(void* pvGui,int16_t* pnPinInd,int16_t* pnPinVal);

typedef bool (*GSLC_CB_INPUT)(void* pvGui,void* pvElemRef,int16_t nStatus,void* pvData);

// -----------------------------------------------------------------------
// Structures
// -----------------------------------------------------------------------


typedef struct gslc_tsRect {
  int16_t   x;    
  int16_t   y;    
  uint16_t  w;    
  uint16_t  h;    
} gslc_tsRect;


typedef struct gslc_tsPt {
  int16_t   x;        
  int16_t   y;        
} gslc_tsPt;

typedef struct gslc_tsColor {
  uint8_t r;      
  uint8_t g;      
  uint8_t b;      
} gslc_tsColor;

typedef struct gslc_tsEvent {
  gslc_teEventType  eType;    
  uint8_t           nSubType; 
  void*             pvScope;  
  void*             pvData;   
} gslc_tsEvent;

typedef struct gslc_tsEventTouch {
  gslc_teTouch      eTouch;           
  int16_t           nX;               
  int16_t           nY;               
} gslc_tsEventTouch;

typedef struct {
  int16_t               nId;            
  gslc_teFontRefType    eFontRefType;   
  gslc_teFontRefMode    eFontRefMode;   
  const void*           pvFont;         
  uint16_t              nSize;          
} gslc_tsFont;


typedef struct {
  const unsigned char*  pImgBuf;    
  const char*           pFname;     
  gslc_teImgRefFlags    eImgFlags;  
  void*                 pvImgRaw;   
} gslc_tsImgRef;


typedef struct {
  gslc_tsElem*          pElem;      
  gslc_teElemRefFlags   eElemFlags; 
} gslc_tsElemRef;

typedef struct gslc_tsElem {

  int16_t             nId;              
  uint8_t             nFeatures;        

  int16_t             nType;            
  gslc_tsRect         rElem;            
  int16_t             nGroup;           

  gslc_tsColor        colElemFrame;     
  gslc_tsColor        colElemFill;      
  gslc_tsColor        colElemFrameGlow; 
  gslc_tsColor        colElemFillGlow;  

  gslc_tsImgRef       sImgRefNorm;      
  gslc_tsImgRef       sImgRefGlow;      

  // if (GSLC_FEATURE_COMPOUND)
  gslc_tsElemRef*     pElemRefParent;
  // endif

  // Text handling
#if (GSLC_LOCAL_STR)
  char                pStrBuf[GSLC_LOCAL_STR_LEN];  
#else
  char*               pStrBuf;          
#endif
  uint8_t             nStrBufMax;       
  gslc_teTxtFlags     eTxtFlags;        


  gslc_tsColor        colElemText;      
  gslc_tsColor        colElemTextGlow;  
  int8_t              eTxtAlign;        
  int8_t              nTxtMarginX;      
  int8_t              nTxtMarginY;      
  gslc_tsFont*        pTxtFont;         

  // Extended data elements
  void*               pXData;           

  // Callback functions
  GSLC_CB_EVENT       pfuncXEvent;      

  GSLC_CB_DRAW        pfuncXDraw;       
  GSLC_CB_TOUCH       pfuncXTouch;      
  GSLC_CB_TICK        pfuncXTick;       
} gslc_tsElem;




typedef struct {
  gslc_tsElem*          asElem;           
  uint16_t              nElemMax;         
  uint16_t              nElemCnt;         
  int16_t               nElemAutoIdNext;  

  gslc_tsElemRef*       asElemRef;        
  uint16_t              nElemRefMax;      
  uint16_t              nElemRefCnt;      

  // Touch tracking
  gslc_tsElemRef*       pElemRefTracked;  

  // Input focus
  int16_t               nElemIndFocused;  

  // Callback functions
  //GSLC_CB_EVENT         pfuncXEvent;      ///< UNUSED: Callback func ptr for events

} gslc_tsCollect;




typedef struct {

  gslc_tsCollect      sCollect;             

  int16_t             nPageId;              

  // Callback functions
  //GSLC_CB_EVENT       pfuncXEvent;          ///< UNUSED: Callback func ptr for events

  // Bounding region
  gslc_tsRect         rBounds;              

} gslc_tsPage;


typedef struct {
  gslc_teInputRawEvent  eEvent;               
  int16_t               nVal;                 
  gslc_teAction         eAction;              
  int16_t               nActionVal;           
} gslc_tsInputMap;


typedef struct {

  uint16_t            nDispW;           
  uint16_t            nDispH;           
  uint16_t            nDisp0W;          
  uint16_t            nDisp0H;          
  uint8_t             nDispDepth;       

  // NOTE: The following config is currently only used by the Adafruit-GFX & TFT_eSPI drivers
  uint8_t             nRotation;       
  #if !defined(DRV_TOUCH_NONE)
    // Touch remapping
    uint8_t           nTouchRotation;  
    uint8_t           nSwapXY;         
    uint8_t           nFlipX;          
    uint8_t           nFlipY;          
    // Calibration for resistive touch displays
    int16_t           nTouchCalXMin;   
    int16_t           nTouchCalXMax;   
    int16_t           nTouchCalYMin;   
    int16_t           nTouchCalYMax;   
    int16_t           nTouchCalPressMin;  
    int16_t           nTouchCalPressMax;  
  #endif

  gslc_tsFont*        asFont;           
  uint8_t             nFontMax;         
  uint8_t             nFontCnt;         

  uint8_t             nRoundRadius;     

  gslc_tsColor        sTransCol;        

#if (GSLC_FEATURE_COMPOUND)
  gslc_tsElem         sElemTmp;         
  gslc_tsElemRef      sElemRefTmp;      
#endif

  gslc_tsElem         sElemTmpProg;     

  gslc_teInitStat     eInitStatTouch;   
  // TODO: exclude these in DRV_TOUCH_NONE
  int16_t             nTouchLastX;      
  int16_t             nTouchLastY;      
  uint16_t            nTouchLastPress;  
  bool                bTouchRemapEn;    
  bool                bTouchRemapYX;    


  void*               pvDriver;         
  bool                bRedrawPartialEn; 

  // Primary surface definitions
  gslc_tsImgRef       sImgRefBkgnd;     

  uint8_t             nFrameRateCnt;    
  uint8_t             nFrameRateStart;  


  // Pages
  gslc_tsPage*        asPage;           
  uint8_t             nPageMax;         
  uint8_t             nPageCnt;         

  gslc_tsPage*        apPageStack[GSLC_STACK__MAX];       
  bool                abPageStackActive[GSLC_STACK__MAX]; 
  bool                abPageStackDoDraw[GSLC_STACK__MAX]; 

  // Redraw of screen (ie. across page stack)
  bool                bScreenNeedRedraw; 
  bool                bScreenNeedFlip;   

  // Current clip region
  bool                bInvalidateEn;     
  gslc_tsRect         rInvalidateRect;   

  // Callback functions
  //GSLC_CB_EVENT       pfuncXEvent;      ///< UNUSED: Callback func ptr for events
  GSLC_CB_PIN_POLL    pfuncPinPoll;     


  // Key/pin input control mapping
  gslc_tsInputMap*    asInputMap;       
  uint8_t             nInputMapMax;     
  uint8_t             nInputMapCnt;     
  uint8_t             nInputMode;       

} gslc_tsGui;


#define GSLC_MIN(a,b) (a<b)?a:b
#define GSLC_MAX(a,b) (a>b)?a:b

// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

char* gslc_GetVer(gslc_tsGui* pGui);

const char* gslc_GetNameDisp(gslc_tsGui* pGui);

const char* gslc_GetNameTouch(gslc_tsGui* pGui);

void* gslc_GetDriverDisp(gslc_tsGui* pGui);

void* gslc_GetDriverTouch(gslc_tsGui* pGui);

bool gslc_Init(gslc_tsGui* pGui,void* pvDriver,gslc_tsPage* asPage,uint8_t nMaxPage,gslc_tsFont* asFont,uint8_t nMaxFont);


void gslc_InitDebug(GSLC_CB_DEBUG_OUT pfunc);


void gslc_DebugPrintf(const char* pFmt, ...);


bool gslc_GuiRotate(gslc_tsGui* pGui, uint8_t nRotation);


void gslc_Quit(gslc_tsGui* pGui);


void gslc_Update(gslc_tsGui* pGui);


bool gslc_SetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);

bool gslc_SetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);

bool gslc_SetTransparentColor(gslc_tsGui* pGui,gslc_tsColor nCol);

gslc_tsRect gslc_GetClipRect(gslc_tsGui* pGui);

bool gslc_SetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);



// ------------------------------------------------------------------------
// ------------------------------------------------------------------------


bool gslc_IsInRect(int16_t nSelX,int16_t nSelY,gslc_tsRect rRect);


gslc_tsRect gslc_ExpandRect(gslc_tsRect rRect,int16_t nExpandW,int16_t nExpandH);


bool gslc_IsInWH(int16_t nSelX,int16_t nSelY,uint16_t nWidth,uint16_t nHeight);

void gslc_UnionRect(gslc_tsRect* pRect, gslc_tsRect rAddRect);

void gslc_InvalidateRgnReset(gslc_tsGui* pGui);

void gslc_InvalidateRgnPage(gslc_tsGui* pGui, gslc_tsPage* pPage);

void gslc_InvalidateRgnScreen(gslc_tsGui* pGui);

void gslc_InvalidateRgnAdd(gslc_tsGui* pGui, gslc_tsRect rAddRect);

bool gslc_ClipPt(gslc_tsRect* pClipRect,int16_t nX,int16_t nY);

bool gslc_ClipLine(gslc_tsRect* pClipRect,int16_t* pnX0,int16_t* pnY0,int16_t* pnX1,int16_t* pnY1);

bool gslc_ClipRect(gslc_tsRect* pClipRect,gslc_tsRect* pRect);


gslc_tsImgRef gslc_GetImageFromFile(const char* pFname,gslc_teImgRefFlags eFmt);


gslc_tsImgRef gslc_GetImageFromSD(const char* pFname,gslc_teImgRefFlags eFmt);


gslc_tsImgRef gslc_GetImageFromRam(unsigned char* pImgBuf,gslc_teImgRefFlags eFmt);


gslc_tsImgRef gslc_GetImageFromProg(const unsigned char* pImgBuf,gslc_teImgRefFlags eFmt);




void gslc_PolarToXY(uint16_t nRad,int16_t n64Ang,int16_t* nDX,int16_t* nDY);


int16_t gslc_sinFX(int16_t n64Ang);


int16_t gslc_cosFX(int16_t n64Ang);

gslc_tsColor gslc_ColorBlend2(gslc_tsColor colStart,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt);

gslc_tsColor gslc_ColorBlend3(gslc_tsColor colStart,gslc_tsColor colMid,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt);

bool gslc_ColorEqual(gslc_tsColor a,gslc_tsColor b);


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------


void gslc_DrawSetPixel(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);


void gslc_DrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);


void gslc_DrawLineH(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nW,gslc_tsColor nCol);


void gslc_DrawLineV(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nH,gslc_tsColor nCol);


void gslc_DrawLinePolar(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint16_t nRadStart,uint16_t nRadEnd,int16_t n64Ang,gslc_tsColor nCol);


void gslc_DrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);

void gslc_DrawFrameRoundRect(gslc_tsGui* pGui, gslc_tsRect rRect, int16_t nRadius, gslc_tsColor nCol);

void gslc_DrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);

void gslc_DrawFillRoundRect(gslc_tsGui* pGui, gslc_tsRect rRect, int16_t nRadius, gslc_tsColor nCol);

void gslc_DrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
  uint16_t nRadius,gslc_tsColor nCol);

void gslc_DrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
  uint16_t nRadius,gslc_tsColor nCol);


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);


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);


void gslc_DrawFrameQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol);


void gslc_DrawFillQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol);

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);

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);

// -----------------------------------------------------------------------
// -----------------------------------------------------------------------

bool gslc_FontAdd(gslc_tsGui* pGui,int16_t nFontId,gslc_teFontRefType eFontRefType,
    const void* pvFontRef,uint16_t nFontSz);

bool gslc_FontSet(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefType eFontRefType,
  const void* pvFontRef, uint16_t nFontSz);

gslc_tsFont* gslc_FontGet(gslc_tsGui* pGui,int16_t nFontId);



bool gslc_FontSetMode(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefMode eFontMode);


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------


int gslc_GetPageCur(gslc_tsGui* pGui);


void gslc_SetStackPage(gslc_tsGui* pGui,uint8_t nStackPos,int16_t nPageId);


void gslc_SetStackState(gslc_tsGui* pGui, uint8_t nStackPos, bool bActive, bool bDoDraw);


void gslc_SetPageBase(gslc_tsGui* pGui, int16_t nPageId);


void gslc_SetPageCur(gslc_tsGui* pGui,int16_t nPageId);


void gslc_SetPageOverlay(gslc_tsGui* pGui,int16_t nPageId);


void gslc_PopupShow(gslc_tsGui* pGui, int16_t nPageId, bool bModal);


void gslc_PopupHide(gslc_tsGui* pGui);


void gslc_PageRedrawSet(gslc_tsGui* pGui,bool bRedraw);


bool gslc_PageRedrawGet(gslc_tsGui* pGui);



void gslc_PageAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* psElem,uint16_t nMaxElem,
        gslc_tsElemRef* psElemRef,uint16_t nMaxElemRef);

gslc_tsElemRef* gslc_PageFindElemById(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId);


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------


gslc_tsElemRef* gslc_ElemCreateTxt(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
  gslc_tsRect rElem,char* pStrBuf,uint8_t nStrBufMax,int16_t nFontId);


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);

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);


gslc_tsElemRef* gslc_ElemCreateBox(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem);

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);

gslc_tsElemRef* gslc_ElemCreateImg(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem,
  gslc_tsImgRef sImgRef);


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------


int gslc_ElemGetId(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

void gslc_ElemSetFillEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFillEn);

void gslc_ElemSetFrameEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFrameEn);

void gslc_ElemSetRoundEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bRoundEn);

void gslc_ElemSetCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrame,gslc_tsColor colFill,gslc_tsColor colFillGlow);

void gslc_ElemSetGlowCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrameGlow,gslc_tsColor colFillGlow,gslc_tsColor colTxtGlow);


void gslc_ElemSetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nGroupId);


int gslc_ElemGetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);


void gslc_ElemSetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsRect rElem);


gslc_tsRect gslc_ElemGetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);


void gslc_ElemSetTxtAlign(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nAlign);

void gslc_ElemSetTxtMargin(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nMargin);

void gslc_ElemSetTxtMarginXY(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int8_t nMarginX,int8_t nMarginY);

void gslc_StrCopy(char* pDstStr,const char* pSrcStr,uint16_t nDstLen);

void gslc_ElemSetTxtStr(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,const char* pStr);


char* gslc_ElemGetTxtStr(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);


void gslc_ElemSetTxtCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colVal);


void gslc_ElemSetTxtMem(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags);


void gslc_ElemSetTxtEnc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags);


void gslc_ElemUpdateFont(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nFontId);

void gslc_ElemSetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);

gslc_teRedrawType gslc_ElemGetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);

void gslc_ElemSetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowEn);

void gslc_ElemSetClickEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bClickEn);

void gslc_ElemSetTouchFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_TOUCH funcCb);

void gslc_ElemSetStyleFrom(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefSrc,gslc_tsElemRef* pElemRefDest);

bool gslc_ElemGetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);


void gslc_ElemSetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowing);

bool gslc_ElemGetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);

void gslc_ElemSetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bVisible);

bool gslc_ElemGetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);

bool gslc_ElemGetOnScreen(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);

/* UNUSED
void gslc_ElemSetEventFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_EVENT funcCb);
*/


void gslc_ElemSetDrawFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_DRAW funcCb);

void gslc_ElemSetTickFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_TICK funcCb);


bool gslc_ElemOwnsCoord(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nX,int16_t nY,bool bOnlyClickEn);






#if !defined(DRV_TOUCH_NONE)

// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

// 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 )


bool gslc_InitTouch(gslc_tsGui* pGui,const char* acDev);


bool gslc_GetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);


void gslc_SetTouchRemapEn(gslc_tsGui* pGui, bool bEn);

void gslc_SetTouchRemapCal(gslc_tsGui* pGui,uint16_t nXMin, uint16_t nXMax, uint16_t nYMin, uint16_t nYMax);

void gslc_SetTouchPressCal(gslc_tsGui* pGui,uint16_t nPressMin, uint16_t nPressMax);

void gslc_SetTouchRemapYX(gslc_tsGui* pGui, bool bSwap);

#endif // !DRV_TOUCH_NONE

// ------------------------------------------------------------------------
// ------------------------------------------------------------------------


void gslc_SetPinPollFunc(gslc_tsGui* pGui, GSLC_CB_PIN_POLL pfunc);

void gslc_InitInputMap(gslc_tsGui* pGui,gslc_tsInputMap* asInputMap,uint8_t nInputMapMax);

void gslc_InputMapAdd(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction eAction,int16_t nActionVal);


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

// Create debug macro to selectively include the output code


#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)



// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

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











#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



// ========================================================================
// ========================================================================

// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

gslc_tsImgRef gslc_ResetImage();


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
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);


gslc_tsElemRef* gslc_ElemAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* pElem,gslc_teElemRefFlags eFlags);


uint8_t gslc_GetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask);

void gslc_SetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask,uint8_t nFlagVal);


// TODO: Mark this as public API
gslc_tsElem* gslc_GetElemFromRef(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);


gslc_tsElem* gslc_GetElemFromRefD(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nLineNum);

void* gslc_GetXDataFromRef(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nType, int16_t nLineNum);


void gslc_ElemSetImage(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsImgRef sImgRef,
  gslc_tsImgRef sImgRefSel);



bool gslc_ElemDrawByRef(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);


void gslc_ElemDraw(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId);


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);


void gslc_SetRoundRadius(gslc_tsGui* pGui, uint8_t nRadius);

// ------------------------------------------------------------------------
// ------------------------------------------------------------------------

bool gslc_PageEvent(void* pvGui,gslc_tsEvent sEvent);

/* UNUSED
void gslc_PageSetEventFunc(gslc_tsGui* pGui,gslc_tsPage* pPage,GSLC_CB_EVENT funcCb);
*/

void gslc_PageRedrawGo(gslc_tsGui* pGui);

void gslc_PageFlipSet(gslc_tsGui* pGui,bool bNeeded);


bool gslc_PageFlipGet(gslc_tsGui* pGui);


void gslc_PageFlipGo(gslc_tsGui* pGui);

gslc_tsPage* gslc_PageFindById(gslc_tsGui* pGui,int16_t nPageId);

void gslc_PageRedrawCalc(gslc_tsGui* pGui);


int16_t gslc_PageFocusStep(gslc_tsGui* pGui,gslc_tsPage* pPage,bool bNext);


gslc_tsEvent gslc_EventCreate(gslc_tsGui* pGui,gslc_teEventType eType,uint8_t nSubType,void* pvScope,void* pvData);


bool gslc_ElemEvent(void* pvGui,gslc_tsEvent sEvent);


#if !defined(DRV_TOUCH_NONE)
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
// ------------------------------------------------------------------------


void gslc_CollectReset(gslc_tsCollect* pCollect,gslc_tsElem* asElem,uint16_t nElemMax,
        gslc_tsElemRef* asElemRef,uint16_t nElemRefMax);


gslc_tsElemRef* gslc_CollectElemAdd(gslc_tsGui* pGui,gslc_tsCollect* pCollect,const gslc_tsElem* pElem,gslc_teElemRefFlags eFlags);


bool gslc_CollectGetRedraw(gslc_tsGui* pGui,gslc_tsCollect* pCollect);


gslc_tsElemRef* gslc_CollectFindElemById(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nElemId);


gslc_tsElemRef* gslc_CollectFindElemFromCoord(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nX, int16_t nY);


int gslc_CollectGetNextId(gslc_tsGui* pGui,gslc_tsCollect* pCollect);


gslc_tsElemRef* gslc_CollectGetElemRefTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect);


void gslc_CollectSetElemTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRef);



int16_t gslc_CollectGetFocus(gslc_tsGui* pGui, gslc_tsCollect* pCollect);


void gslc_CollectSetFocus(gslc_tsGui* pGui, gslc_tsCollect* pCollect, int16_t nElemInd);


bool gslc_CollectFindFocusStep(gslc_tsGui* pGui,gslc_tsCollect* pCollect,bool bNext,bool* pbWrapped,int16_t* pnElemInd);


void gslc_CollectSetParent(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRefParent);


// ------------------------------------------------------------------------
// Internal: Collect Event Handlers
// ------------------------------------------------------------------------

/* UNUSED
void gslc_CollectSetEventFunc(gslc_tsGui* pGui,gslc_tsCollect* pCollect,GSLC_CB_EVENT funcCb);
*/

bool gslc_CollectEvent(void* pvGui,gslc_tsEvent sEvent);


#if !defined(DRV_TOUCH_NONE)

void gslc_CollectTouch(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch);

bool gslc_CollectTouchCompound(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY, gslc_tsCollect* pCollect);


void gslc_CollectInput(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch);



// ------------------------------------------------------------------------
// ------------------------------------------------------------------------


void gslc_TrackTouch(gslc_tsGui* pGui,gslc_tsPage* pPage,int16_t nX,int16_t nY,uint16_t nPress);

void gslc_TrackInput(gslc_tsGui* pGui,gslc_tsPage* pPage,gslc_teInputRawEvent eInputEvent,int16_t nInputVal);

bool gslc_InputMapLookup(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction* peAction,int16_t* pnActionVal);

#endif // !DRV_TOUCH_NONE


// ------------------------------------------------------------------------
// ------------------------------------------------------------------------



void gslc_GuiDestruct(gslc_tsGui* pGui);


void gslc_PageDestruct(gslc_tsGui* pGui,gslc_tsPage* pPage);

void gslc_CollectDestruct(gslc_tsGui* pGui,gslc_tsCollect* pCollect);

void gslc_ElemDestruct(gslc_tsElem* pElem);

void gslc_ResetFont(gslc_tsFont* pFont);

void gslc_ResetElem(gslc_tsElem* pElem);




#ifdef __cplusplus
}
#endif // __cplusplus
#endif // _GUISLICE_H_