From 8c8b4fd831caf67f0f906925401293cb7274cb49 Mon Sep 17 00:00:00 2001
From: KemoNine <kemonine@kemonine.info>
Date: Tue, 8 Sep 2020 21:53:59 -0400
Subject: [PATCH] Convert UI to GUI Slice and cleanup some small stuff along
 the way

---
 .gitignore                                 |    4 +-
 .vscode/settings.json                      |   15 +
 serial_debugger.ino                        |  170 +-
 serial_debugger.ino.beta                   |  203 +
 serial_debugger.ino.orig                   |  218 +
 serial_debugger.prj                        |  Bin 0 -> 2487 bytes
 serial_debugger_GSLC.h                     |  172 +
 src/guislice/GUIslice.c                    | 5140 ++++++++++++++++++++
 src/guislice/GUIslice.h                    | 3801 +++++++++++++++
 src/guislice/GUIslice_config.h             |  218 +
 src/guislice/GUIslice_config_ard.h         |  526 ++
 src/guislice/GUIslice_config_linux.h       |  191 +
 src/guislice/GUIslice_drv.h                |   66 +
 src/guislice/GUIslice_drv_adagfx.cpp       | 3063 ++++++++++++
 src/guislice/GUIslice_drv_adagfx.h         |  757 +++
 src/guislice/GUIslice_drv_m5stack.cpp      | 1071 ++++
 src/guislice/GUIslice_drv_m5stack.h        |  656 +++
 src/guislice/GUIslice_drv_sdl.c            | 1470 ++++++
 src/guislice/GUIslice_drv_sdl.h            |  722 +++
 src/guislice/GUIslice_drv_tft_espi.cpp     | 2188 +++++++++
 src/guislice/GUIslice_drv_tft_espi.h       |  755 +++
 src/guislice/GUIslice_drv_utft.cpp         | 1361 ++++++
 src/guislice/GUIslice_drv_utft.h           |  672 +++
 src/guislice/GUIslice_ex.h                 |   52 +
 src/guislice/GUIslice_th.cpp               |  119 +
 src/guislice/GUIslice_th.h                 |   71 +
 src/guislice/GUIslice_th_XPT2046.h         |   52 +
 src/guislice/GUIslice_version.h            |   42 +
 src/guislice/NotoMono8pt7b.h               |  185 +
 src/guislice/XCheckbox.c                   |  517 ++
 src/guislice/XCheckbox.h                   |  290 ++
 src/guislice/XGauge.c                      |  699 +++
 src/guislice/XGauge.h                      |  394 ++
 src/guislice/XGlowball.c                   |  348 ++
 src/guislice/XGlowball.h                   |  136 +
 src/guislice/XGraph.c                      |  366 ++
 src/guislice/XGraph.h                      |  186 +
 src/guislice/XKeyPad.c                     |  714 +++
 src/guislice/XKeyPad.h                     |  409 ++
 src/guislice/XKeyPad_Alpha.c               |  204 +
 src/guislice/XKeyPad_Alpha.h               |  100 +
 src/guislice/XKeyPad_Num.c                 |  206 +
 src/guislice/XKeyPad_Num.h                 |  100 +
 src/guislice/XListbox.c                    |  982 ++++
 src/guislice/XListbox.h                    |  329 ++
 src/guislice/XProgress.c                   |  365 ++
 src/guislice/XProgress.h                   |  287 ++
 src/guislice/XRadial.c                     |  363 ++
 src/guislice/XRadial.h                     |  327 ++
 src/guislice/XRamp.c                       |  300 ++
 src/guislice/XRamp.h                       |  264 +
 src/guislice/XRingGauge.c                  |  413 ++
 src/guislice/XRingGauge.h                  |  268 +
 src/guislice/XSeekbar.c                    |  530 ++
 src/guislice/XSeekbar.h                    |  336 ++
 src/guislice/XSelNum.c                     |  384 ++
 src/guislice/XSelNum.h                     |  177 +
 src/guislice/XSlider.c                     |  478 ++
 src/guislice/XSlider.h                     |  315 ++
 src/guislice/XSpinner.c                    |  425 ++
 src/guislice/XSpinner.h                    |  210 +
 src/guislice/XTemplate.c                   |  307 ++
 src/guislice/XTemplate.h                   |  128 +
 src/guislice/XTextbox.c                    |  663 +++
 src/guislice/XTextbox.h                    |  221 +
 src/guislice/XTogglebtn.c                  |  453 ++
 src/guislice/XTogglebtn.h                  |  282 ++
 src/guislice/ard-adagfx-ili9341-notouch.h  |  207 +
 src/guislice/ard-adagfx-ili9341-stmpe610.h |  246 +
 69 files changed, 37841 insertions(+), 48 deletions(-)
 create mode 100644 .vscode/settings.json
 create mode 100644 serial_debugger.ino.beta
 create mode 100644 serial_debugger.ino.orig
 create mode 100644 serial_debugger.prj
 create mode 100644 serial_debugger_GSLC.h
 create mode 100644 src/guislice/GUIslice.c
 create mode 100644 src/guislice/GUIslice.h
 create mode 100644 src/guislice/GUIslice_config.h
 create mode 100644 src/guislice/GUIslice_config_ard.h
 create mode 100644 src/guislice/GUIslice_config_linux.h
 create mode 100644 src/guislice/GUIslice_drv.h
 create mode 100644 src/guislice/GUIslice_drv_adagfx.cpp
 create mode 100644 src/guislice/GUIslice_drv_adagfx.h
 create mode 100644 src/guislice/GUIslice_drv_m5stack.cpp
 create mode 100644 src/guislice/GUIslice_drv_m5stack.h
 create mode 100644 src/guislice/GUIslice_drv_sdl.c
 create mode 100644 src/guislice/GUIslice_drv_sdl.h
 create mode 100644 src/guislice/GUIslice_drv_tft_espi.cpp
 create mode 100644 src/guislice/GUIslice_drv_tft_espi.h
 create mode 100644 src/guislice/GUIslice_drv_utft.cpp
 create mode 100644 src/guislice/GUIslice_drv_utft.h
 create mode 100644 src/guislice/GUIslice_ex.h
 create mode 100644 src/guislice/GUIslice_th.cpp
 create mode 100644 src/guislice/GUIslice_th.h
 create mode 100644 src/guislice/GUIslice_th_XPT2046.h
 create mode 100644 src/guislice/GUIslice_version.h
 create mode 100644 src/guislice/NotoMono8pt7b.h
 create mode 100644 src/guislice/XCheckbox.c
 create mode 100644 src/guislice/XCheckbox.h
 create mode 100644 src/guislice/XGauge.c
 create mode 100644 src/guislice/XGauge.h
 create mode 100644 src/guislice/XGlowball.c
 create mode 100644 src/guislice/XGlowball.h
 create mode 100644 src/guislice/XGraph.c
 create mode 100644 src/guislice/XGraph.h
 create mode 100644 src/guislice/XKeyPad.c
 create mode 100644 src/guislice/XKeyPad.h
 create mode 100644 src/guislice/XKeyPad_Alpha.c
 create mode 100644 src/guislice/XKeyPad_Alpha.h
 create mode 100644 src/guislice/XKeyPad_Num.c
 create mode 100644 src/guislice/XKeyPad_Num.h
 create mode 100644 src/guislice/XListbox.c
 create mode 100644 src/guislice/XListbox.h
 create mode 100644 src/guislice/XProgress.c
 create mode 100644 src/guislice/XProgress.h
 create mode 100644 src/guislice/XRadial.c
 create mode 100644 src/guislice/XRadial.h
 create mode 100644 src/guislice/XRamp.c
 create mode 100644 src/guislice/XRamp.h
 create mode 100644 src/guislice/XRingGauge.c
 create mode 100644 src/guislice/XRingGauge.h
 create mode 100644 src/guislice/XSeekbar.c
 create mode 100644 src/guislice/XSeekbar.h
 create mode 100644 src/guislice/XSelNum.c
 create mode 100644 src/guislice/XSelNum.h
 create mode 100644 src/guislice/XSlider.c
 create mode 100644 src/guislice/XSlider.h
 create mode 100644 src/guislice/XSpinner.c
 create mode 100644 src/guislice/XSpinner.h
 create mode 100644 src/guislice/XTemplate.c
 create mode 100644 src/guislice/XTemplate.h
 create mode 100644 src/guislice/XTextbox.c
 create mode 100644 src/guislice/XTextbox.h
 create mode 100644 src/guislice/XTogglebtn.c
 create mode 100644 src/guislice/XTogglebtn.h
 create mode 100644 src/guislice/ard-adagfx-ili9341-notouch.h
 create mode 100644 src/guislice/ard-adagfx-ili9341-stmpe610.h

diff --git a/.gitignore b/.gitignore
index d163863..c326afe 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,3 @@
-build/
\ No newline at end of file
+build/
+serial_debugger*.bak
+gui_backup/
\ No newline at end of file
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..1f5cc00
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,15 @@
+{
+    "files.associations": {
+        "xtemplate.h": "c",
+        "guislice_drv.h": "c",
+        "xradial.h": "c",
+        "*.tpp": "cpp",
+        "array": "cpp",
+        "deque": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "string_view": "cpp",
+        "initializer_list": "cpp"
+    }
+}
\ No newline at end of file
diff --git a/serial_debugger.ino b/serial_debugger.ino
index 1ed617c..3e7a71b 100644
--- a/serial_debugger.ino
+++ b/serial_debugger.ino
@@ -1,3 +1,18 @@
+//<App !Start!>
+// FILE: [serial_debugger.ino]
+// Created by GUIslice Builder version: [0.15.b004]
+//
+// GUIslice Builder Generated File
+//
+// For the latest guides, updates and support view:
+// https://github.com/ImpulseAdventure/GUIslice
+//
+//<App !End!>
+
+// ------------------------------------------------
+// Headers to include
+// ------------------------------------------------
+//<Includes !Start!>
 // Varous system includes
 #include <Arduino.h>
 
@@ -8,22 +23,29 @@
 #include <BBQ10Keyboard.h>
 #include <CircularBuffer.h>
 
-// Debugging via serial monitor (don't turn this on unless you're hacking on the firmware code)
-#define DEBUG true
+// Various local includes
+#include "serial_debugger_GSLC.h"
+
+//<Includes !End!>
+
+// ------------------------------------------------
+// Program Globals
+// ------------------------------------------------
 
 // Battery level measurement
 #define VBATPIN A6
 float measuredVBat;
-float batteryPercent;
+int batteryPercent;
 
 // TFT Setup
 #define TFT_CS 9
 #define TFT_DC 10
 Adafruit_ILI9341 tft(TFT_CS, TFT_DC);
 #include <Fonts/FreeMono9pt7b.h>
-#define CHARS_HORIZONTAL 28
-#define CHARS_ROWS 13
-CircularBuffer<char,364> textBuffer;
+#define CHARS_HORIZONTAL 29
+#define CHARS_ROWS 11
+#define CHARS_TOTAL CHARS_HORIZONTAL * CHARS_ROWS
+CircularBuffer<char,CHARS_TOTAL> textBuffer;
 
 // Keyboard
 BBQ10Keyboard keyboard;
@@ -44,20 +66,48 @@ BBQ10Keyboard keyboard;
 Adafruit_NeoPixel pixels_board(PIXELS_NUM_BOARD, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800);
 Adafruit_NeoPixel pixels_wing(PIXELS_NUM_WING, PIXELS_WING_PIN, NEO_GRB + NEO_KHZ800);
 
+// GUI state globals
+bool textChanged = false;
+
 // Various loop handlers
 void handlerKeyboard();
 void handlerBatteryLevel();
+void processRingBuffer();
 
-// UI screens
-void screenClear();
+// Save some element references for direct access
+//<Save_References !Start!>
+gslc_tsElemRef* m_pElemBatteryLevel= NULL;
+gslc_tsElemRef* m_pElemStatusText = NULL;
+gslc_tsElemRef* m_pElemText       = NULL;
+//<Save_References !End!>
 
-// Color conversion (RGB888 -> RGB565 used by Adafruit GFX)
-uint16_t RGB565(uint8_t r, uint8_t g, uint8_t b) {
-  return ((r & 0b11111000) << 8) | ((g & 0b11111100) << 3) | (b >> 3);
-}
+// Define debug message function
+static int16_t DebugOut(char ch) { if (ch == (char)'\n') Serial.println(""); else Serial.write(ch); return 0; }
+
+// ------------------------------------------------
+// Callback Methods
+// ------------------------------------------------
+//<Button Callback !Start!>
+//<Button Callback !End!>
+//<Checkbox Callback !Start!>
+//<Checkbox Callback !End!>
+//<Keypad Callback !Start!>
+//<Keypad Callback !End!>
+//<Spinner Callback !Start!>
+//<Spinner Callback !End!>
+//<Listbox Callback !Start!>
+//<Listbox Callback !End!>
+//<Draw Callback !Start!>
+//<Draw Callback !End!>
+//<Slider Enums !Start!>
+//<Slider Enums !End!>
+//<Tick Callback !Start!>
+//<Tick Callback !End!>
 
-// Various things that need to be setup via the Arduino standard methods
 void setup() {
+
+  Serial.begin(115200);
+
   // Setup red LED to indicate device is on (in case we disable NeoPixel battery level later)
   pinMode(3, OUTPUT);
   digitalWrite(3, HIGH);
@@ -80,50 +130,68 @@ void setup() {
   pixels_board.setPixelColor(0, pixels_board.Color(0, 0, 255));
   pixels_board.show();
 
-  // Setup TFT
-  tft.begin();
-  tft.setRotation(1);
-  screenClear();
-  tft.println("");
-  tft.setFont(&FreeMono9pt7b);
-
   // Setup BBQ10Keyboard
   Wire.begin();
   keyboard.begin();
   keyboard.setBacklight(0.5f);
+
+  // GUI Slice (TFT is setup through GUI Slice)
+  gslc_InitDebug(&DebugOut);
+  InitGUIslice_gen();
 }
 
-// Main program via the Arduino standard methods
+// -----------------------------------
+// Main event loop
+// -----------------------------------
 void loop() {
+  // Reset text changed state (processing methods will update if needed)
+  textChanged = false;
+
   // Handle keyboard events
   handlerKeyboard();
 
   // Update battery level as appropriate
   handlerBatteryLevel();
+
+  // Update UI
+  if (textChanged) {
+    processRingBuffer();
+  }
+  gslc_Update(&m_gui);
 }
 
+// Move text from buffer -> text box on screen
+void processRingBuffer() {
+      // Add keycodes to text box
+    char* textForDisplay = (char*) calloc(textBuffer.size(), sizeof(char));
+    for (int i=0; i<textBuffer.size(); i++) {
+      textForDisplay[i] = textBuffer[i];
+    }
+    gslc_ElemXTextboxAdd(&m_gui, m_pElemText, textForDisplay);
+}
+
+// Keyboard handler
 void handlerKeyboard() {
   // Check if keys were pressed
   if (keyboard.keyCount()) {
     // Get keyboard event
     const BBQ10Keyboard::KeyEvent key = keyboard.keyEvent();
 
-    char output[28];
-    snprintf(output, 28, "key: '%c' (dec %d, hex %02x)", key.key, key.key, key.key);
-    for (int i=0; i<sizeof(output); i++) {
-      char toPush = output[i];
-      if (toPush != '\0') {
-        textBuffer.push(toPush);
+    // Add key code to display ring buffer *if* it's pressed ; no need for other events presently
+    if (key.state == BBQ10Keyboard::StatePress) {
+      char output[28];
+      snprintf(output, 28, "key: '%c' (dec %d, hex %02x)", key.key, key.key, key.key);
+      textChanged = true;
+      for (int i=0; i<sizeof(output); i++) {
+        char toPush = output[i];
+        if (toPush != '\0') {
+          textBuffer.push(toPush);
+        }
+        else if (toPush == '\0') {
+          textBuffer.push('\n');
+          break;
+        }
       }
-      else if (toPush == '\0') {
-        textBuffer.push('\n');
-        break;
-      }
-    }
-    
-    screenClear();
-    for (int i=0; i<textBuffer.size(); i++) {
-      tft.print(textBuffer[i]);
     }
 
     // Pick color for signaling a key was pressed (short or long press)
@@ -131,7 +199,7 @@ void handlerKeyboard() {
     if (key.state == BBQ10Keyboard::StateLongPress) {
       keyboard_pixel_color = pixels_wing.Color(0, 255, 255);
     }
-  
+
     // Display indicator accordingly
     if (key.state == BBQ10Keyboard::StatePress || key.state == BBQ10Keyboard::StateLongPress) {
       pixels_wing.setPixelColor(0, keyboard_pixel_color);
@@ -150,24 +218,32 @@ void handlerBatteryLevel() {
   measuredVBat *= 2;    // we divided by 2, so multiply back
   measuredVBat *= 3.3;  // Multiply by 3.3V, our reference voltage
   measuredVBat /= 1024; // convert to voltage
-  batteryPercent = measuredVBat / 3.3;
-  if (batteryPercent >= 0.75) {
+  batteryPercent = (measuredVBat / 3.3) * 100;
+
+  gslc_tsColor colorForHeaderElements;
+  if (batteryPercent >= 75) {
     pixels_board.setPixelColor(0, pixels_board.Color(0, 255, 0));
+    colorForHeaderElements = GSLC_COL_GREEN;
   }
-  else if (batteryPercent >= 0.50) {
+  else if (batteryPercent >= 50) {
+    colorForHeaderElements = GSLC_COL_YELLOW;
     pixels_board.setPixelColor(0, pixels_board.Color(255, 255, 0));
   }
-  else if (batteryPercent >= 0.25) {
+  else if (batteryPercent >= 25) {
+    colorForHeaderElements = GSLC_COL_ORANGE;
     pixels_board.setPixelColor(0, pixels_board.Color(255, 128, 0));
   }
   else {
+    colorForHeaderElements = GSLC_COL_RED;
     pixels_board.setPixelColor(0, pixels_board.Color(255, 0, 0));
   }
+
+  gslc_ElemXProgressSetVal(&m_gui, m_pElemBatteryLevel, batteryPercent);
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(&m_gui,m_pElemBatteryLevel,GSLC_TYPEX_PROGRESS,__LINE__);
+  pGauge->colGauge = colorForHeaderElements;
+  gslc_ElemSetTxtCol(&m_gui, m_pElemBatteryLevel, colorForHeaderElements);
+  gslc_ElemSetTxtCol(&m_gui, m_pElemStatusText, colorForHeaderElements);
+
+  // Update GUI and NeoPixel with battery status information
   pixels_board.show();
 }
-
-// Clear the screen
-void screenClear() {
-  tft.setCursor(0, 0);
-  tft.fillScreen(RGB565(0, 0, 0));
-}
\ No newline at end of file
diff --git a/serial_debugger.ino.beta b/serial_debugger.ino.beta
new file mode 100644
index 0000000..0bb8c95
--- /dev/null
+++ b/serial_debugger.ino.beta
@@ -0,0 +1,203 @@
+// Varous system includes
+#include <Arduino.h>
+
+// Various library includes
+#include <Adafruit_NeoPixel.h>
+#include <Adafruit_GFX.h>
+#include <Adafruit_ILI9341.h>
+#include <BBQ10Keyboard.h>
+#include <CircularBuffer.h>
+
+// Various local includes
+#include "serial_debugger_GSLC.h"
+
+// Battery level measurement
+#define VBATPIN A6
+float measuredVBat;
+int batteryPercent;
+
+// TFT Setup
+#define TFT_CS 9
+#define TFT_DC 10
+Adafruit_ILI9341 tft(TFT_CS, TFT_DC);
+#include <Fonts/FreeMono9pt7b.h>
+#define CHARS_HORIZONTAL 28
+#define CHARS_ROWS 13
+CircularBuffer<char,364> textBuffer;
+
+// Keyboard
+BBQ10Keyboard keyboard;
+#define KBD_BTN_1 0x06
+#define KBD_BTN_2 0x11
+#define KBD_BTN_3 0x07
+#define KBD_BTN_4 0x12
+#define KBD_SW_UP 0x01
+#define KBD_SW_DN 0x02
+#define KBD_SW_LF 0x03
+#define KBD_SW_RT 0x04
+#define KBD_SW_OK 0x05
+// NeoPixels
+#define PIXELS_NUM_BOARD 1
+#define PIXELS_NUM_WING 1
+#define PIXELS_WING_PIN 11
+Adafruit_NeoPixel pixels_board(PIXELS_NUM_BOARD, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800);
+Adafruit_NeoPixel pixels_wing(PIXELS_NUM_WING, PIXELS_WING_PIN, NEO_GRB + NEO_KHZ800);
+
+// Various loop handlers
+void handlerKeyboard();
+void handlerBatteryLevel();
+
+// GUI Slice
+gslc_tsElemRef* m_pElemBatteryLevel= NULL;
+gslc_tsElemRef* m_pElemStatusText = NULL;
+gslc_tsElemRef* m_pElemText       = NULL;
+gslc_tsElemRef* m_pTextSlider     = NULL;
+static int16_t DebugOut(char ch) { if (ch == (char)'\n') Serial.println(""); else Serial.write(ch); return 0; }
+bool CbSlidePos(void* pvGui,void* pvElemRef,int16_t nPos);
+
+void setup() {
+  Serial.begin(115200);
+
+  // Setup red LED to indicate device is on (in case we disable NeoPixel battery level later)
+  pinMode(3, OUTPUT);
+  digitalWrite(3, HIGH);
+
+  // Setup NeoPixels
+  pixels_board.begin();
+  pixels_wing.begin();
+  pixels_board.clear();
+  pixels_wing.clear();
+  pixels_board.setBrightness(10);
+  pixels_wing.setBrightness(5);
+
+  // Start with blank wing indicator
+  pixels_wing.show();
+
+  // Green : pixels.Color(0, 255, 0)
+  // Yellow : pixels.Color(255, 255, 0)
+  // Orange : pixels.Color(255, 128, 0)
+  // Red : pixels.Color(255, 0, 0)
+  pixels_board.setPixelColor(0, pixels_board.Color(0, 0, 255));
+  pixels_board.show();
+
+  // Setup BBQ10Keyboard
+  Wire.begin();
+  keyboard.begin();
+  keyboard.setBacklight(0.5f);
+
+  // GUI Slice (TFT is setup through GUI Slice)
+  gslc_InitDebug(&DebugOut);
+  InitGUIslice_gen();
+}
+
+ // Main program via the Arduino standard methods 
+void loop() {
+  // Handle keyboard events
+  handlerKeyboard();
+
+  // Update battery level as appropriate
+  handlerBatteryLevel();
+
+  // Update UI
+  gslc_Update(&m_gui);
+}
+
+// Keyboard handler
+void handlerKeyboard() {
+  // Check if keys were pressed
+  if (keyboard.keyCount()) {
+    // Get keyboard event
+    const BBQ10Keyboard::KeyEvent key = keyboard.keyEvent();
+
+    char output[28];
+    snprintf(output, 28, "key: '%c' (dec %d, hex %02x)", key.key, key.key, key.key);
+    for (int i=0; i<sizeof(output); i++) {
+      char toPush = output[i];
+      if (toPush != '\0') {
+        textBuffer.push(toPush);
+      }
+      else if (toPush == '\0') {
+        textBuffer.push('\n');
+        break;
+      }
+    }
+    
+    // Add keycodes to text box
+    for (int i=0; i<textBuffer.size(); i++) {
+      //tft.print(textBuffer[i]);
+    }
+
+    // Pick color for signaling a key was pressed (short or long press)
+    uint32_t keyboard_pixel_color = pixels_wing.Color(0, 0, 255);
+    if (key.state == BBQ10Keyboard::StateLongPress) {
+      keyboard_pixel_color = pixels_wing.Color(0, 255, 255);
+    }
+  
+    // Display indicator accordingly
+    if (key.state == BBQ10Keyboard::StatePress || key.state == BBQ10Keyboard::StateLongPress) {
+      pixels_wing.setPixelColor(0, keyboard_pixel_color);
+      pixels_wing.show(); 
+    } 
+    else {
+      pixels_wing.clear();
+      pixels_wing.show();
+    }
+  }
+}
+
+// Measure battery level and change NeoPixel accordingly
+void handlerBatteryLevel() {
+  measuredVBat = analogRead(VBATPIN);
+  measuredVBat *= 2;    // we divided by 2, so multiply back
+  measuredVBat *= 3.3;  // Multiply by 3.3V, our reference voltage
+  measuredVBat /= 1024; // convert to voltage
+  batteryPercent = (measuredVBat / 3.3) * 100;
+
+  gslc_tsColor colorForHeaderElements;
+  if (batteryPercent >= 75) {
+    pixels_board.setPixelColor(0, pixels_board.Color(0, 255, 0));
+    colorForHeaderElements = GSLC_COL_GREEN;
+  }
+  else if (batteryPercent >= 50) {
+    colorForHeaderElements = GSLC_COL_YELLOW;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 255, 0));
+  }
+  else if (batteryPercent >= 25) {
+    colorForHeaderElements = GSLC_COL_ORANGE;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 128, 0));
+  }
+  else {
+    colorForHeaderElements = GSLC_COL_RED;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 0, 0));
+  }
+
+  gslc_ElemXProgressSetVal(&m_gui, m_pElemBatteryLevel, batteryPercent);
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(&m_gui,m_pElemBatteryLevel,GSLC_TYPEX_PROGRESS,__LINE__);
+  pGauge->colGauge = colorForHeaderElements;
+  gslc_ElemSetTxtCol(&m_gui, m_pElemBatteryLevel, colorForHeaderElements);
+  gslc_ElemSetTxtCol(&m_gui, m_pElemStatusText, colorForHeaderElements);
+
+  // Update GUI and NeoPixel with battery status information
+  gslc_Update(&m_gui);
+  pixels_board.show();
+}
+
+// Slider callback function
+bool CbSlidePos(void* pvGui,void* pvElemRef,int16_t nPos) {
+  gslc_tsGui*     pGui     = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*    pElem    = gslc_GetElemFromRef(pGui,pElemRef);
+  int16_t         nVal;
+
+  // From the element's ID we can determine which slider was updated.
+  switch (pElem->nId) {
+    case E_TXTSCROLL:
+      // Fetch the slider position
+      nVal = gslc_ElemXSliderGetPos(pGui,m_pTextSlider);
+      break;
+    default:
+      break;
+  }
+
+  return true;
+}
diff --git a/serial_debugger.ino.orig b/serial_debugger.ino.orig
new file mode 100644
index 0000000..f302a0a
--- /dev/null
+++ b/serial_debugger.ino.orig
@@ -0,0 +1,218 @@
+//<File !Start!>
+// Varous system includes
+#include <Arduino.h>
+//<File !End!>
+
+// Various library includes
+#include <Adafruit_NeoPixel.h>
+#include <Adafruit_GFX.h>
+
+//<Includes !Start!>
+//<Includes !End!>
+
+#include <Adafruit_ILI9341.h>
+#include <BBQ10Keyboard.h>
+#include <CircularBuffer.h>
+
+// Various local includes
+#include "serial_debugger_GSLC.h"
+
+// Battery level measurement
+#define VBATPIN A6
+float measuredVBat;
+int batteryPercent;
+
+// TFT Setup
+#define TFT_CS 9
+#define TFT_DC 10
+Adafruit_ILI9341 tft(TFT_CS, TFT_DC);
+#include <Fonts/FreeMono9pt7b.h>
+#define CHARS_HORIZONTAL 28
+#define CHARS_ROWS 13
+CircularBuffer<char,364> textBuffer;
+
+// Keyboard
+BBQ10Keyboard keyboard;
+#define KBD_BTN_1 0x06
+#define KBD_BTN_2 0x11
+#define KBD_BTN_3 0x07
+#define KBD_BTN_4 0x12
+#define KBD_SW_UP 0x01
+#define KBD_SW_DN 0x02
+#define KBD_SW_LF 0x03
+#define KBD_SW_RT 0x04
+#define KBD_SW_OK 0x05
+// NeoPixels
+#define PIXELS_NUM_BOARD 1
+#define PIXELS_NUM_WING 1
+#define PIXELS_WING_PIN 11
+Adafruit_NeoPixel pixels_board(PIXELS_NUM_BOARD, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800);
+Adafruit_NeoPixel pixels_wing(PIXELS_NUM_WING, PIXELS_WING_PIN, NEO_GRB + NEO_KHZ800);
+
+// Various loop handlers
+void handlerKeyboard();
+void handlerBatteryLevel();
+
+// GUI Slice
+gslc_tsElemRef* m_pElemBatteryLevel= NULL;
+gslc_tsElemRef* m_pElemStatusText = NULL;
+gslc_tsElemRef* m_pElemText       = NULL;
+gslc_tsElemRef* m_pTextSlider     = NULL;
+static int16_t DebugOut(char ch) { if (ch == (char)'\n') Serial.println(""); else Serial.write(ch); return 0; }
+bool CbSlidePos(void* pvGui,void* pvElemRef,int16_t nPos);
+
+void setup() {
+  Serial.begin(115200);
+
+  // Setup red LED to indicate device is on (in case we disable NeoPixel battery level later)
+  pinMode(3, OUTPUT);
+  digitalWrite(3, HIGH);
+
+  // Setup NeoPixels
+  pixels_board.begin();
+  pixels_wing.begin();
+  pixels_board.clear();
+  pixels_wing.clear();
+  pixels_board.setBrightness(10);
+  pixels_wing.setBrightness(5);
+
+  // Start with blank wing indicator
+  pixels_wing.show();
+
+  // Green : pixels.Color(0, 255, 0)
+  // Yellow : pixels.Color(255, 255, 0)
+  // Orange : pixels.Color(255, 128, 0)
+  // Red : pixels.Color(255, 0, 0)
+  pixels_board.setPixelColor(0, pixels_board.Color(0, 0, 255));
+  pixels_board.show();
+
+  // Setup BBQ10Keyboard
+  Wire.begin();
+  keyboard.begin();
+  keyboard.setBacklight(0.5f);
+
+  // GUI Slice (TFT is setup through GUI Slice)
+  gslc_InitDebug(&DebugOut);
+  InitGUIslice_gen();
+}
+
+ // Main program via the Arduino standard methods 
+void loop() {
+  // Handle keyboard events
+  handlerKeyboard();
+
+  // Update battery level as appropriate
+  handlerBatteryLevel();
+
+  // Update UI
+  gslc_Update(&m_gui);
+}
+
+// Keyboard handler
+void handlerKeyboard() {
+  // Check if keys were pressed
+  if (keyboard.keyCount()) {
+    // Get keyboard event
+    const BBQ10Keyboard::KeyEvent key = keyboard.keyEvent();
+
+    char output[28];
+    snprintf(output, 28, "key: '%c' (dec %d, hex %02x)", key.key, key.key, key.key);
+    for (int i=0; i<sizeof(output); i++) {
+      char toPush = output[i];
+      if (toPush != '\0') {
+        textBuffer.push(toPush);
+      }
+      else if (toPush == '\0') {
+        textBuffer.push('\n');
+        break;
+      }
+    }
+    
+    // Add keycodes to text box
+    for (int i=0; i<textBuffer.size(); i++) {
+      //tft.print(textBuffer[i]);
+    }
+
+    // Pick color for signaling a key was pressed (short or long press)
+    uint32_t keyboard_pixel_color = pixels_wing.Color(0, 0, 255);
+    if (key.state == BBQ10Keyboard::StateLongPress) {
+      keyboard_pixel_color = pixels_wing.Color(0, 255, 255);
+    }
+  
+    // Display indicator accordingly
+    if (key.state == BBQ10Keyboard::StatePress || key.state == BBQ10Keyboard::StateLongPress) {
+      pixels_wing.setPixelColor(0, keyboard_pixel_color);
+      pixels_wing.show(); 
+    } 
+    else {
+      pixels_wing.clear();
+      pixels_wing.show();
+    }
+  }
+}
+
+// Measure battery level and change NeoPixel accordingly
+void handlerBatteryLevel() {
+  measuredVBat = analogRead(VBATPIN);
+  measuredVBat *= 2;    // we divided by 2, so multiply back
+  measuredVBat *= 3.3;  // Multiply by 3.3V, our reference voltage
+  measuredVBat /= 1024; // convert to voltage
+  batteryPercent = (measuredVBat / 3.3) * 100;
+
+  gslc_tsColor colorForHeaderElements;
+  if (batteryPercent >= 75) {
+    pixels_board.setPixelColor(0, pixels_board.Color(0, 255, 0));
+    colorForHeaderElements = GSLC_COL_GREEN;
+  }
+  else if (batteryPercent >= 50) {
+    colorForHeaderElements = GSLC_COL_YELLOW;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 255, 0));
+  }
+  else if (batteryPercent >= 25) {
+    colorForHeaderElements = GSLC_COL_ORANGE;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 128, 0));
+  }
+  else {
+    colorForHeaderElements = GSLC_COL_RED;
+    pixels_board.setPixelColor(0, pixels_board.Color(255, 0, 0));
+  }
+
+  gslc_ElemXProgressSetVal(&m_gui, m_pElemBatteryLevel, batteryPercent);
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(&m_gui,m_pElemBatteryLevel,GSLC_TYPEX_PROGRESS,__LINE__);
+  pGauge->colGauge = colorForHeaderElements;
+  gslc_ElemSetTxtCol(&m_gui, m_pElemBatteryLevel, colorForHeaderElements);
+  gslc_ElemSetTxtCol(&m_gui, m_pElemStatusText, colorForHeaderElements);
+
+  // Update GUI and NeoPixel with battery status information
+  gslc_Update(&m_gui);
+  pixels_board.show();
+}
+
+// Slider callback function
+bool CbSlidePos(void* pvGui,void* pvElemRef,int16_t nPos) {
+  gslc_tsGui*     pGui     = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*    pElem    = gslc_GetElemFromRef(pGui,pElemRef);
+  int16_t         nVal;
+
+  // From the element's ID we can determine which slider was updated.
+  switch (pElem->nId) {
+    case E_TXTSCROLL:
+      // Fetch the slider position
+      nVal = gslc_ElemXSliderGetPos(pGui,m_pTextSlider);
+      break;
+    default:
+      break;
+  }
+
+  return true;
+}
+
+//<Checkbox Callback !Start!>
+//<Checkbox Callback !End!>
+//<Keypad Callback !Start!>
+//<Keypad Callback !End!>
+//<Spinner Callback !Start!>
+//<Spinner Callback !End!>
+//<Listbox Callback !Start!>
+//<Listbox Callback !End!>
diff --git a/serial_debugger.prj b/serial_debugger.prj
new file mode 100644
index 0000000000000000000000000000000000000000..3a4a042a61256b523986c7312f5fc7350ffc97b4
GIT binary patch
literal 2487
zcmZ8iyN}~U822vs6apQG5CuAk;=0rB+DZ0qqti-^-_FHO;@FPkEl!D@wX<;^=QwL;
zkq`(83JMzNC@7#i{uCM{dPIXLKy*k5>G)>G$vU`LWxkpD&F}He?8`rxn<;aPs~)nI
zWBAb?grkRCc5{zmnENSnTWIMAEX$?L-F7m+82RZ#_+3;hDf5=}ylu7`l3+b=wJoh>
zbYWJJi~|nuxjjgN)p#~fnLACbYeDg3l`wCgH7^F2gTr_*3lF<#GM<G`fB4Dy?e_;C
zD*FtRFW~6Clwr0=m1V-bb-hKKrK50^-2e64@BaSe^OJpMPh)Og4&v1)Pndhx>x|WO
zI7&Wy`SpX>zxw5i0(tL)Eo^o9g87Jf15W!3YC@}dP~})S>P-SM$kIb$9?z4#@8A9O
z-j~(YK66uMZk-R}MKstP*ktzoWy-uq1RcSaBOh-$A{)Dlfj@eB#@szm!Xe?8GW%!p
z8Gw)xKK&h{mU#sv7K;VYXq$}#j(fbTn4iz%(O~xD`^m>YfAi0upxE0eUR>MsIA!*Z
zwh&LKgPN}3Ebv(mV2%#!yTi(6NP~N_^#xKW!aUj5pj(O>L3y|tf^`@M+Zk+Y6<T`*
zUv>j#_VJR}@E;6QbX3aROIj@AU0*`vJ3YlK;PAW9UCMJEX-3N2z@3@i`gdn(wSxqX
zUk@w6+H;Mo&Qx9pSs$Se;P5<)P#{_?o9ZIU1B47)ZCrZQM(kG&q3>!F-R&TrHQH8}
z&2+H=9Aw#L9o@9K^Ug%J9l5TXjwf4cd7W|PhsYdE<x0PMyzKXmXU$2x3KVDNxmvgO
zLYUNRirPXNLiPk?dC^dH;*qK$Nm)d}R9X!cdF8E-TS1Q-d+swOY1n~qY=z?t_NY-t
z*n_rfZswKW;U6Ic+7OaKi`rr9M$<x>;TkzoYlshF25Y$1T=A<CIuDV8H;H9DD+aAb
z>Q;Gqs5mM3#sdHK$j;+n>MRNVMD8{%DbrPB4ZghSgO27jkA_o!)tS~WVP7;{vY|g0
zomo3sp%C%C5V%d{WzchKKClNaLdVfk-9qa!7hn&w4c;EJxh{gATW$QLe72zy{!XD+
zZ(4fR!hFzi!AGuwapJI&U;3dE%Qd}oab<A8MK(dV2V8t5in^UGFCC%Ag%4gRY)&yM
z7^8kcFvfL?6&qQ<XT&XTiG-fF_9~4^zn60!^b3kprI!KrjOI$X^Ev1xE+3)x3G!7w
zD`m9SsSc~GL!Z&y6r39pk3vl-?;~3E>h2o6vV=|66dsKMTXGbq7N|btO>UA!eU%{x
z&-UDiZHO}I6$JW4+c`JwT(+FL<w(%$PSHo@enJhhUT{ecGm4j%@)94@8ds_zht}%&
zK5cu<u9{JxI#-k<<j<LXM_|{wi2H<V4Xfs*)vK?DS5X#-0oJ2Ba%49xEyMRz<Q(3P
zJDDb&gt{ehI<DhB+Tu|D67KVD%_00{e9t#E%fP*_+H5YmtgLtKpyje$!^C&p_Uuw_
zxn6i7h1kQ*TOwsdA5YIyXT+P`Y>R!HY&ShY_tmLa{2a%Lj%or5p<jI3BN166P~SCr
zf2kKZTd8q5y3V)o8FPzCzHl#V<%|V(o3U*=kxg@P%2|oD7ME)yS}W%)9n)GlXYm=W
zLCz@M=1lV?o+M;m$gy{JPwu4p1*#SAKo^xW5qHivOWEh}{*>Og2xAp*inMuCx;yU)
z&KIS!i}RKZ(Vo<G`hFMhjb*|-hxroE>`K1y;O!&1(>E_SXurFJzv%7e^+*hB*Lj^6
xdIluS_9GN(I7^;z)+o-H`apGPGw8+5+h_d`d)o`;H37v6PfxQu@IRD%{{c!M;0OQ!

literal 0
HcmV?d00001

diff --git a/serial_debugger_GSLC.h b/serial_debugger_GSLC.h
new file mode 100644
index 0000000..2a290d6
--- /dev/null
+++ b/serial_debugger_GSLC.h
@@ -0,0 +1,172 @@
+//<File !Start!>
+// FILE: [serial_debugger_GSLC.h]
+// Created by GUIslice Builder version: [0.15.b004]
+//
+// GUIslice Builder Generated GUI Framework File
+//
+// For the latest guides, updates and support view:
+// https://github.com/ImpulseAdventure/GUIslice
+//
+//<File !End!>
+
+#ifndef _GUISLICE_GEN_H
+#define _GUISLICE_GEN_H
+
+// ------------------------------------------------
+// Headers to include
+// ------------------------------------------------
+#include "src/guislice/GUIslice.h"
+#include "src/guislice/GUIslice_drv.h"
+
+// Include any extended elements
+//<Includes !Start!>
+// Include extended elements
+#include "src/guislice/XProgress.h"
+#include "src/guislice/XTextbox.h"
+//<Includes !End!>
+
+// ------------------------------------------------
+// Headers and Defines for fonts
+// Note that font files are located within the Adafruit-GFX library folder:
+// ------------------------------------------------
+//<Fonts !Start!>
+#if defined(DRV_DISP_TFT_ESPI)
+  #error Project tab->Target Platform should be tft_espi
+#endif
+#include <Adafruit_GFX.h>
+#include "src/guislice/NotoMono8pt7b.h"
+//<Fonts !End!>
+
+// ------------------------------------------------
+// Defines for resources
+// ------------------------------------------------
+//<Resources !Start!>
+//<Resources !End!>
+
+// ------------------------------------------------
+// Enumerations for pages, elements, fonts, images
+// ------------------------------------------------
+//<Enum !Start!>
+enum {E_PG_MAIN};
+enum {E_ELEM_BATT_LEVEL,E_ELEM_STATUS,E_ELEM_TEXT};
+// Must use separate enum for fonts with MAX_FONT at end to use gslc_FontSet.
+enum {E_AO_NOTOMONO8PT7B,MAX_FONT};
+//<Enum !End!>
+
+// ------------------------------------------------
+// Instantiate the GUI
+// ------------------------------------------------
+
+// ------------------------------------------------
+// Define the maximum number of elements and pages
+// ------------------------------------------------
+//<ElementDefines !Start!>
+#define MAX_PAGE                1
+
+#define MAX_ELEM_PG_MAIN 3 // # Elems total on page
+#define MAX_ELEM_PG_MAIN_RAM MAX_ELEM_PG_MAIN // # Elems in RAM
+//<ElementDefines !End!>
+
+// ------------------------------------------------
+// Create element storage
+// ------------------------------------------------
+gslc_tsGui                      m_gui;
+gslc_tsDriver                   m_drv;
+gslc_tsFont                     m_asFont[MAX_FONT];
+gslc_tsPage                     m_asPage[MAX_PAGE];
+
+//<GUI_Extra_Elements !Start!>
+gslc_tsElem                     m_asPage1Elem[MAX_ELEM_PG_MAIN_RAM];
+gslc_tsElemRef                  m_asPage1ElemRef[MAX_ELEM_PG_MAIN];
+gslc_tsXProgress                m_sXBarGauge1;
+gslc_tsXTextbox                 m_sTextbox1;
+char                            m_acTextboxBuf1[952]; // NRows=17 NCols=56
+
+#define MAX_STR                 100
+
+//<GUI_Extra_Elements !End!>
+
+// ------------------------------------------------
+// Program Globals
+// ------------------------------------------------
+
+// Element References for direct access
+//<Extern_References !Start!>
+extern gslc_tsElemRef* m_pElemBatteryLevel;
+extern gslc_tsElemRef* m_pElemStatusText;
+extern gslc_tsElemRef* m_pElemText;
+extern gslc_tsElemRef* m_pTextSlider;
+//<Extern_References !End!>
+
+// Define debug message function
+static int16_t DebugOut(char ch);
+
+// ------------------------------------------------
+// Callback Methods
+// ------------------------------------------------
+bool CbBtnCommon(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);
+bool CbCheckbox(void* pvGui, void* pvElemRef, int16_t nSelId, bool bState);
+bool CbDrawScanner(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+bool CbKeypad(void* pvGui, void *pvElemRef, int16_t nState, void* pvData);
+bool CbListbox(void* pvGui, void* pvElemRef, int16_t nSelId);
+bool CbSlidePos(void* pvGui,void* pvElemRef,int16_t nPos);
+bool CbSpinner(void* pvGui, void *pvElemRef, int16_t nState, void* pvData);
+bool CbTickScanner(void* pvGui,void* pvScope);
+
+// ------------------------------------------------
+// Create page elements
+// ------------------------------------------------
+void InitGUIslice_gen()
+{
+  gslc_tsElemRef* pElemRef = NULL;
+
+  if (!gslc_Init(&m_gui,&m_drv,m_asPage,MAX_PAGE,m_asFont,MAX_FONT)) { return; }
+
+  // ------------------------------------------------
+  // Load Fonts
+  // ------------------------------------------------
+//<Load_Fonts !Start!>
+    if (!gslc_FontSet(&m_gui,E_AO_NOTOMONO8PT7B,GSLC_FONTREF_PTR,&NotoMono8pt7b,1)) { return; }
+//<Load_Fonts !End!>
+
+//<InitGUI !Start!>
+  gslc_PageAdd(&m_gui,E_PG_MAIN,m_asPage1Elem,MAX_ELEM_PG_MAIN_RAM,m_asPage1ElemRef,MAX_ELEM_PG_MAIN);
+
+  // NOTE: The current page defaults to the first page added. Here we explicitly
+  //       ensure that the main page is the correct page no matter the add order.
+  gslc_SetPageCur(&m_gui,E_PG_MAIN);
+  
+  // Set Background to a flat color
+  gslc_SetBkgndColor(&m_gui,GSLC_COL_BLACK);
+
+  // -----------------------------------
+  // PAGE: E_PG_MAIN
+  
+
+  // Create progress bar E_ELEM_BATT_LEVEL 
+  pElemRef = gslc_ElemXProgressCreate(&m_gui,E_ELEM_BATT_LEVEL,E_PG_MAIN,&m_sXBarGauge1,
+    (gslc_tsRect){263,5,50,15},0,100,0,GSLC_COL_GREEN,false);
+  m_pElemBatteryLevel = pElemRef;
+  
+  // Create E_ELEM_STATUS text label
+  pElemRef = gslc_ElemCreateTxt(&m_gui,E_ELEM_STATUS,E_PG_MAIN,(gslc_tsRect){2,2,250,21},
+    (char*)"UART0 / 1151200",0,E_AO_NOTOMONO8PT7B);
+  gslc_ElemSetTxtCol(&m_gui,pElemRef,GSLC_COL_GREEN);
+  m_pElemStatusText = pElemRef;
+   
+  // Create textbox
+  pElemRef = gslc_ElemXTextboxCreate(&m_gui,E_ELEM_TEXT,E_PG_MAIN,&m_sTextbox1,
+    (gslc_tsRect){3,30,313,202},E_AO_NOTOMONO8PT7B,
+    (char*)&m_acTextboxBuf1,17,56);
+  gslc_ElemXTextboxWrapSet(&m_gui,pElemRef,true);
+  gslc_ElemSetTxtCol(&m_gui,pElemRef,GSLC_COL_GRAY_LT3);
+  gslc_ElemSetCol(&m_gui,pElemRef,GSLC_COL_GRAY,GSLC_COL_BLACK,GSLC_COL_BLACK);
+  m_pElemText = pElemRef;
+//<InitGUI !End!>
+
+//<Startup !Start!>
+//<Startup !End!>
+
+}
+
+#endif // end _GUISLICE_GEN_H
diff --git a/src/guislice/GUIslice.c b/src/guislice/GUIslice.c
new file mode 100644
index 0000000..6080833
--- /dev/null
+++ b/src/guislice/GUIslice.c
@@ -0,0 +1,5140 @@
+// =======================================================================
+// 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.c
+
+
+// GUIslice library
+
+// Import configuration ( which will import a sub-config depending on device type)
+#include "GUIslice_config.h"
+
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include <stdio.h>
+
+#if defined(DBG_REDRAW)
+  #include <Arduino.h> // For delay()
+#endif // DBG_REDRAW
+
+#ifdef DBG_FRAME_RATE
+  #include <time.h> // for FrameRate reporting
+#endif
+
+#if (GSLC_USE_FLOAT)
+  #include <math.h>
+#endif
+
+#if (GSLC_USE_PROGMEM)
+  #include <avr/pgmspace.h>   // For memcpy_P()
+#endif
+
+#include <stdarg.h>         // For va_*
+
+// Version tracking
+#include "GUIslice_version.h"
+
+
+// ========================================================================
+
+/// Global debug output function
+/// - The user assigns this function via gslc_InitDebug()
+GSLC_CB_DEBUG_OUT g_pfDebugOut = NULL;
+
+// Forward declaration for trigonometric lookup table
+extern uint16_t  m_nLUTSinF0X16[257];
+
+
+// ------------------------------------------------------------------------
+// Error Strings
+// - These strings are generally stored in FLASH memory if possible
+// ------------------------------------------------------------------------
+
+const char GSLC_PMEM ERRSTR_NULL[]      = "ERROR: %z() called with NULL ptr\n";
+const char GSLC_PMEM ERRSTR_PXD_NULL[]  = "ERROR: %z() pXData NULL\n";
+
+
+// ------------------------------------------------------------------------
+// General Functions
+// ------------------------------------------------------------------------
+
+char* gslc_GetVer(gslc_tsGui* pGui)
+{
+  return (char*)GUISLICE_VER;
+}
+
+const char* gslc_GetNameDisp(gslc_tsGui* pGui)
+{
+  return gslc_DrvGetNameDisp(pGui);
+}
+
+const char* gslc_GetNameTouch(gslc_tsGui* pGui)
+{
+  return gslc_DrvGetNameTouch(pGui);
+}
+
+void* gslc_GetDriverDisp(gslc_tsGui* pGui)
+{
+  return gslc_DrvGetDriverDisp(pGui);
+}
+
+void* gslc_GetDriverTouch(gslc_tsGui* pGui)
+{
+  return gslc_DrvGetDriverTouch(pGui);
+}
+
+
+bool gslc_Init(gslc_tsGui* pGui,void* pvDriver,gslc_tsPage* asPage,uint8_t nMaxPage,gslc_tsFont* asFont,uint8_t nMaxFont)
+{
+  unsigned  nInd;
+  bool      bOk = true;
+
+  // Provide indication that debug messaging is active
+  #if !defined(INIT_MSG_DISABLE)
+  GSLC_DEBUG_PRINT("GUIslice version [%s]:\n", gslc_GetVer(pGui));
+  #endif
+
+  pGui->eInitStatTouch = GSLC_INITSTAT_UNDEF;
+
+  // Initialize state
+  pGui->nDisp0W         = 0;
+  pGui->nDisp0H         = 0;
+  pGui->nDispW          = 0;
+  pGui->nDispH          = 0;
+  pGui->nDispDepth      = 0;
+
+  #if defined(DRV_DISP_ADAGFX) || defined(DRV_DISP_ADAGFX_AS) || defined(DRV_DISP_TFT_ESPI) || defined(DRV_DISP_M5STACK)
+
+    // Assign default orientation
+    pGui->nRotation     = GSLC_ROTATE;
+
+    #if !defined(DRV_TOUCH_NONE)
+      // Assign arbitrary defaults
+      // These will be overwritten during DrvInit()
+      pGui->nSwapXY = 0;
+      pGui->nFlipX = 0;
+      pGui->nFlipY = 0;
+      pGui->nTouchCalXMin = 100;
+      pGui->nTouchCalXMax = 1000;
+      pGui->nTouchCalYMin = 100;
+      pGui->nTouchCalYMax = 1000;
+      pGui->bTouchRemapYX = false;
+    #endif // !DRV_TOUCH_NONE
+
+  #endif
+
+  // Default to remapping enabled
+  pGui->bTouchRemapEn = true;
+
+
+  pGui->nPageMax        = nMaxPage;
+  pGui->nPageCnt        = 0;
+  pGui->asPage          = asPage;
+
+  for (nInd = 0; nInd < GSLC_STACK__MAX; nInd++) {
+    pGui->apPageStack[nInd] = NULL;
+    pGui->abPageStackActive[nInd] = true;
+    pGui->abPageStackDoDraw[nInd] = true;
+  }
+  pGui->bScreenNeedRedraw  = true;
+  pGui->bScreenNeedFlip    = false;
+
+  gslc_InvalidateRgnReset(pGui);
+
+  // Default global element characteristics
+  pGui->nRoundRadius = 4;
+
+  // Default image transparency setting
+  // - Used when GSLC_BMP_TRANS_EN=1
+  // - Defined by config file GSLC_BMP_TRANS_RGB
+  // - Can be overridden by user with SetTransparentColor()
+  #if defined(GSLC_BMP_TRANS_RGB)
+    pGui->sTransCol = (gslc_tsColor){ GSLC_BMP_TRANS_RGB };
+  #else
+    // Provide a default if not defined in config
+    // - The following is equivalent to GSLC_COL_MAGENTA
+    pGui->sTransCol = (gslc_tsColor) { 0xFF, 0x00, 0xFF };
+  #endif
+
+  // Initialize collection of fonts with user-supplied pointer
+  pGui->asFont      = asFont;
+  pGui->nFontMax    = nMaxFont;
+  pGui->nFontCnt    = 0;
+  for (nInd=0;nInd<(pGui->nFontMax);nInd++) {
+    gslc_ResetFont(&(pGui->asFont[nInd]));
+  }
+
+  // Initialize temporary element
+#if (GSLC_FEATURE_COMPOUND)
+  gslc_ResetElem(&(pGui->sElemTmp));
+#endif
+
+
+  // Last touch event
+  pGui->nTouchLastX           = 0;
+  pGui->nTouchLastY           = 0;
+  pGui->nTouchLastPress       = 0;
+
+  //pGui->pfuncXEvent           = NULL; // UNUSED
+  pGui->pfuncPinPoll          = NULL;
+
+  pGui->asInputMap            = NULL;
+  pGui->nInputMapMax          = 0;
+  pGui->nInputMapCnt          = 0;
+
+
+  pGui->sImgRefBkgnd = gslc_ResetImage();
+
+  // Save a link to the driver
+  pGui->pvDriver = pvDriver;
+
+  // Default to no support for partial redraw
+  // - This may be overridden by the driver-specific init
+  pGui->bRedrawPartialEn = false;
+
+
+  #ifdef DBG_FRAME_RATE
+  pGui->nFrameRateCnt = 0;
+  pGui->nFrameRateStart = time(NULL);
+  #endif
+
+  // Initialize the display and touch drivers
+  if (bOk) {
+    bOk &= gslc_DrvInit(pGui);
+    if (bOk) {
+      #if !defined(INIT_MSG_DISABLE)
+      GSLC_DEBUG_PRINT("- Init display handler [%s] OK\n", gslc_GetNameDisp(pGui));
+      #endif
+    } else {
+      GSLC_DEBUG_PRINT("- Init display handler [%s] FAIL\n", gslc_GetNameDisp(pGui));
+    }
+  }
+  #if defined(DRV_TOUCH_NONE)
+    pGui->eInitStatTouch = GSLC_INITSTAT_INACTIVE;
+    GSLC_DEBUG_PRINT("- No touch handler enabled\n", "");
+  #else
+    if (bOk) {
+      // Touch initialization is not made to be a fatal error
+      // Instead, a flag is set that can be used to alert the
+      // user on their display (in case the debug messaging was
+      // not enabled)
+      bool bTouchOk = gslc_InitTouch(pGui,GSLC_DEV_TOUCH);
+      if (bTouchOk) {
+        #if !defined(INIT_MSG_DISABLE)
+        GSLC_DEBUG_PRINT("- Init touch handler [%s] OK\n", gslc_GetNameTouch(pGui));
+        #endif
+        pGui->eInitStatTouch = GSLC_INITSTAT_ACTIVE;
+      } else {
+        GSLC_DEBUG_PRINT("- Init touch handler [%s] FAIL\n", gslc_GetNameTouch(pGui));
+        pGui->eInitStatTouch = GSLC_INITSTAT_FAIL;
+      }
+    }
+  #endif
+
+  // Initialize the entire display as being invalidated
+  gslc_InvalidateRgnScreen(pGui);
+
+  // If the display didn't initialize properly, then return
+  // false which should mark it as a fatal error. Note that
+  // touch handler errors are not included as fatal errors.
+  if (!bOk) { GSLC_DEBUG_PRINT("ERROR: Init(%s) failed\n",""); }
+  return bOk;
+}
+
+void gslc_SetPinPollFunc(gslc_tsGui* pGui,GSLC_CB_PIN_POLL pfunc)
+{
+  pGui->pfuncPinPoll = pfunc;
+}
+
+
+void gslc_InitInputMap(gslc_tsGui* pGui,gslc_tsInputMap* asInputMap,uint8_t nInputMapMax)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return;
+#else
+  pGui->asInputMap    = asInputMap;
+  pGui->nInputMapMax  = nInputMapMax;
+  pGui->nInputMapCnt  = 0;
+#endif
+}
+
+void gslc_InputMapAdd(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction eAction,int16_t nActionVal)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return;
+#else
+  if (pGui->nInputMapCnt >= pGui->nInputMapMax) {
+    GSLC_DEBUG2_PRINT("ERROR: InputMapAdd() too many mappings. Max=%u\n",pGui->nInputMapMax);
+    return;
+  }
+  gslc_tsInputMap sInputMap;
+  sInputMap.eEvent      = eInputEvent;
+  sInputMap.nVal        = nInputVal;
+  sInputMap.eAction     = eAction;
+  sInputMap.nActionVal  = nActionVal;
+  pGui->asInputMap[pGui->nInputMapCnt] = sInputMap;
+  pGui->nInputMapCnt++;
+#endif
+}
+
+bool gslc_InputMapLookup(gslc_tsGui* pGui,gslc_teInputRawEvent eInputEvent,int16_t nInputVal,gslc_teAction* peAction,int16_t* pnActionVal)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return false;
+#else
+  uint8_t         nInputInd;
+  uint8_t         nInputMax = pGui->nInputMapCnt;
+  bool            bFound = false;
+  gslc_tsInputMap sMapEntry;
+  // Assign defaults
+  *peAction     = GSLC_ACTION_UNDEF;
+  *pnActionVal  = 0;
+  // Search
+  for (nInputInd=0;((nInputInd<nInputMax)&&(!bFound));nInputInd++) {
+    sMapEntry = pGui->asInputMap[nInputInd];
+    if ((sMapEntry.eEvent == eInputEvent) && (sMapEntry.nVal == nInputVal)) {
+      bFound = true;
+      *peAction = pGui->asInputMap[nInputInd].eAction;
+      *pnActionVal = sMapEntry.nActionVal;
+    }
+  }
+  return bFound;
+#endif
+}
+
+
+void gslc_InitDebug(GSLC_CB_DEBUG_OUT pfunc)
+{
+  g_pfDebugOut = pfunc;
+}
+
+
+// Internal enumerations for printf() parser state machine
+typedef enum {
+  GSLC_S_DEBUG_PRINT_NORM,
+  GSLC_S_DEBUG_PRINT_TOKEN,
+  GSLC_S_DEBUG_PRINT_UINT16,
+  GSLC_S_DEBUG_PRINT_CHAR,
+  GSLC_S_DEBUG_PRINT_STR,
+  GSLC_S_DEBUG_PRINT_STR_P
+} gslc_teDebugPrintState;
+
+// A lightweight printf() routine that calls user function for
+// character output (enabling redirection to Serial). Only
+// supports the following tokens:
+// - %u (16-bit unsigned int in RAM) [see NOTE]
+// - %d (16-bit signed int in RAM)
+// - %c (character)
+// - %s (null-terminated string in RAM)
+// - %z (null-terminated string in FLASH)
+// Format strings are expected to be in FLASH if GSLC_USE_PROGMEM enabled
+// NOTE:
+// - Due to the way variadic arguments are passed, we can't pass uint16_t on Arduino
+//   as the parameters are promoted to "int" (ie. int16_t). Passing a value over 32767
+//   appears to be promoted to int32_t which involves pushing two more bytes onto
+//   the stack, causing the remainder of the va_args() to be offset.
+// PRE:
+// - g_pfDebugOut defined
+void gslc_DebugPrintf(const char* pFmt, ...)
+{
+  if (g_pfDebugOut) {
+
+    char*    pStr=NULL;
+    unsigned nMaxDivisor;
+    unsigned nNumRemain=0;
+    bool     bNumStart=false,bNumNeg=false;
+    unsigned nNumDivisor=1;
+    uint16_t nFmtInd=0;
+    char     cFmt,cOut;
+
+    va_list  vlist;
+    va_start(vlist,pFmt);
+
+    gslc_teDebugPrintState  nState = GSLC_S_DEBUG_PRINT_NORM;
+
+    // Determine maximum number digit size
+    #if defined(__AVR__)
+      nMaxDivisor = 10000;      // ~2^16
+    #else
+      nMaxDivisor = 1000000000; // ~2^32
+    #endif
+
+    #if (GSLC_USE_PROGMEM)
+    cFmt = pgm_read_byte(&pFmt[nFmtInd]);
+    #else
+    cFmt = pFmt[nFmtInd];
+    #endif
+
+    while (cFmt != 0) {
+
+      if (nState == GSLC_S_DEBUG_PRINT_NORM) {
+
+        if (cFmt == '%') {
+          nState = GSLC_S_DEBUG_PRINT_TOKEN;
+        } else {
+          // Normal char
+          (g_pfDebugOut)(cFmt);
+        }
+        nFmtInd++; // Advance format index
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_TOKEN) {
+
+        // Get token
+        if (cFmt == 'd') {
+          nState = GSLC_S_DEBUG_PRINT_UINT16;
+          // Detect negative value and convert to unsigned value
+          // with negation flag. This enables us to reuse the same
+          // decoding logic.
+          int nNumInt = va_arg(vlist,int);
+          if (nNumInt < 0) {
+            bNumNeg = true;
+            nNumRemain = -nNumInt;
+          } else {
+            bNumNeg = false;
+            nNumRemain = nNumInt;
+          }
+          bNumStart = false;
+          nNumDivisor = nMaxDivisor;
+
+        } else if (cFmt == 'u') {
+          nState = GSLC_S_DEBUG_PRINT_UINT16;
+          nNumRemain = va_arg(vlist,unsigned);
+          bNumNeg = false;
+          bNumStart = false;
+          nNumDivisor = nMaxDivisor;
+
+        } else if (cFmt == 'c') {
+          nState = GSLC_S_DEBUG_PRINT_CHAR;
+          cOut = (char)va_arg(vlist,unsigned);
+
+        } else if (cFmt == 's') {
+          nState = GSLC_S_DEBUG_PRINT_STR;
+          pStr = va_arg(vlist,char*);
+
+        } else if (cFmt == 'z') {
+          nState = GSLC_S_DEBUG_PRINT_STR_P;
+          pStr = va_arg(vlist,char*);
+        } else {
+          // ERROR
+        }
+        nFmtInd++; // Advance format index
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_STR) {
+        while (*pStr != 0) {
+          cOut = *pStr;
+          (g_pfDebugOut)(cOut);
+          pStr++;
+        }
+        nState = GSLC_S_DEBUG_PRINT_NORM;
+        // Don't advance format string index
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_STR_P) {
+        do {
+          #if (GSLC_USE_PROGMEM)
+          cOut = pgm_read_byte(pStr);
+          #else
+          cOut = *pStr;
+          #endif
+          if (cOut != 0) {
+            (g_pfDebugOut)(cOut);
+            pStr++;
+          }
+        } while (cOut != 0);
+        nState = GSLC_S_DEBUG_PRINT_NORM;
+        // Don't advance format string index
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_CHAR) {
+        (g_pfDebugOut)(cOut);
+        nState = GSLC_S_DEBUG_PRINT_NORM;
+
+      } else if (nState == GSLC_S_DEBUG_PRINT_UINT16) {
+
+        // Handle the negation flag if required
+        if (bNumNeg) {
+          cOut = '-';
+          (g_pfDebugOut)(cOut);
+          bNumNeg = false;  // Clear the negation flag
+        }
+
+        // We remain in this state until we have consumed all of the digits
+        // in the original number (starting with the most significant).
+        // Each time we process a digit, the parser doesn't advance its input.
+        if (nNumRemain < nNumDivisor) {
+          if (bNumStart) {
+            cOut = '0';
+            (g_pfDebugOut)(cOut);
+          } else {
+            // We haven't started outputting a number yet
+            // Check for special case of zero
+            if (nNumRemain == 0) {
+              cOut = '0';
+              (g_pfDebugOut)(cOut);
+              // Now fall through to done state
+              nNumDivisor = 1;
+            }
+          }
+        } else {
+          bNumStart = true;
+          unsigned nValDigit = nNumRemain / nNumDivisor;
+          cOut = nValDigit+'0';
+          nNumRemain -= nNumDivisor*nValDigit;
+          (g_pfDebugOut)(cOut);
+        }
+
+        // Detect end of digit decode (ie. 1's)
+        if (nNumDivisor == 1) {
+          // Done
+          nState = GSLC_S_DEBUG_PRINT_NORM;
+        } else {
+          // Shift the divisor by an order of magnitude
+          nNumDivisor /= 10;
+        }
+        // Don't advance format string index
+
+      }
+
+      // Read the format string (usually the next character)
+      #if (GSLC_USE_PROGMEM)
+      cFmt = pgm_read_byte(&pFmt[nFmtInd]);
+      #else
+      cFmt = pFmt[nFmtInd];
+      #endif
+
+    }
+    va_end(vlist);
+
+  } // g_pfDebugOut
+
+
+}
+
+// ------------------------------------------------------------------------
+// Error strings
+// ------------------------------------------------------------------------
+extern const char ERRSTR_NULL[];
+
+// ------------------------------------------------------------------------
+
+
+void gslc_Quit(gslc_tsGui* pGui)
+{
+  // Close all elements and fonts
+  gslc_GuiDestruct(pGui);
+}
+
+
+// Main polling loop for GUIslice
+void gslc_Update(gslc_tsGui* pGui)
+{
+  // The touch handling logic is used by both the touchscreen
+  // handler as well as the GPIO/pin/keyboard input controller
+  #if !defined(DRV_TOUCH_NONE)
+
+  // Check to see if we had a touch initialization error
+  // if so, mark this on the display.
+  if (pGui->eInitStatTouch == GSLC_INITSTAT_FAIL) {
+    gslc_DrvDrawTxt(pGui,5,5,NULL,(char*)"ERROR: InitTouch",
+      GSLC_TXT_DEFAULT, GSLC_COL_RED, GSLC_COL_BLACK);
+  }
+
+  // ---------------------------------------------
+  // Touch handling
+  // ---------------------------------------------
+
+  // TODO: Move the physical button / GPIO handling (pfuncPinPoll)
+  //       outside of !defined(DRV_TOUCH_NONE) check so that we can
+  //       enable physical button handling without requiring
+  //       all of the other touch driver logic.
+  //       Consider creating a define that indicates whether the
+  //       touch coordinate handling should be compiled or not
+  //       (eg. if !DRV_TOUCH_NONE && !DRV_TOUCH_INPUT)
+
+  int16_t               nTouchX = 0;
+  int16_t               nTouchY = 0;
+  uint16_t              nTouchPress = 0;
+  bool                  bEvent = false;
+  gslc_teInputRawEvent  eInputEvent = GSLC_INPUT_NONE;
+  int16_t               nInputVal = 0;
+
+  // Handle touchscreen presses
+  // - We clear the event queue here so that we don't fall behind
+  // - In the time it takes to update the display, several mouse /
+  //   finger events may have occurred. If we only handle a single
+  //   motion event per display update, then we may experience very
+  //   lagging responsiveness from the controls.
+  // - Instead, we drain the event queue before proceeding on to the
+  //   display update, giving rise to a much more responsive GUI.
+  //   The maximum number of touch events that can be handled per
+  //   main loop is defined by the GSLC_TOUCH_MAX_EVT config param.
+  // - Note that SDL2 may synchronize the RenderPresent call to
+  //   the VSYNC, which will effectively insert a delay into the
+  //   gslc_PageRedrawGo() call below. It might be possible to
+  //   adjust this blocking behavior via SDL_RENDERER_PRESENTVSYNC.
+
+  // In case we are flooded with events, limit the maximum number
+  // that we handle in one gslc_Update() call.
+  bool      bDoneEvts = false;
+  uint16_t  nNumEvts  = 0;
+  do {
+    bEvent = false;
+
+    // --------------------------------------------------------------
+    // First check physical pin inputs
+    // --------------------------------------------------------------
+
+    #if (GSLC_FEATURE_INPUT)
+    int16_t  nPinNum = -1;
+    int16_t  nPinState = 0;
+    GSLC_CB_PIN_POLL  pfuncPinPoll = pGui->pfuncPinPoll;
+
+    if (pfuncPinPoll != NULL) {
+      bEvent = (*pfuncPinPoll)(pGui,&nPinNum,&nPinState);
+      if (bEvent) {
+        eInputEvent = GSLC_INPUT_PIN_ASSERT;
+        nInputVal = nPinNum;
+      }
+    } 
+    #endif // GSLC_FEATURE_INPUT
+
+    // --------------------------------------------------------------
+    // If no event found yet, check touch / keyboard
+    // --------------------------------------------------------------
+    if (!bEvent) {
+      // Fetch input event, which could include touch / mouse / keyboard / pin
+      bEvent = gslc_GetTouch(pGui, &nTouchX, &nTouchY, &nTouchPress, &eInputEvent, &nInputVal);
+    }
+
+    // --------------------------------------------------------------
+    // If event found, handle it
+    // --------------------------------------------------------------
+    if (bEvent) {
+      // Track and handle the input events
+      // - Handle the events on the current page
+      switch (eInputEvent) {
+        case GSLC_INPUT_KEY_DOWN:
+          gslc_TrackInput(pGui,NULL,eInputEvent,nInputVal);
+          break;
+        case GSLC_INPUT_KEY_UP:
+          // NOTE: For now, only handling key-down events
+          // TODO: gslc_TrackInput(pGui,NULL,eInputEvent,nInputVal);
+          break;
+
+        case GSLC_INPUT_PIN_ASSERT:
+          gslc_TrackInput(pGui,NULL,eInputEvent,nInputVal);
+          break;
+        case GSLC_INPUT_PIN_DEASSERT:
+          // TODO: gslc_TrackInput(pGui,NULL,eInputEvent,nInputVal);
+          break;
+
+        case GSLC_INPUT_TOUCH:
+          // Track and handle the touch events
+          // - Handle the events on the current page
+          gslc_TrackTouch(pGui,NULL,nTouchX,nTouchY,nTouchPress);
+
+          #ifdef DBG_TOUCH
+          // Highlight current touch for coordinate debug
+          gslc_tsRect rMark = gslc_ExpandRect((gslc_tsRect){(int16_t)nTouchX,(int16_t)nTouchY,1,1},1,1);
+          gslc_DrawFrameRect(pGui,rMark,GSLC_COL_YELLOW);
+          #endif
+          break;
+
+        case GSLC_INPUT_NONE:
+        default:
+          break;
+
+      }
+
+      nNumEvts++;
+    }
+
+    // Should we stop handling events?
+    if ((!bEvent) || (nNumEvts >= GSLC_TOUCH_MAX_EVT)) {
+      bDoneEvts = true;
+    }
+  } while (!bDoneEvts);
+
+  #endif // !DRV_TOUCH_NONE
+
+  // ---------------------------------------------
+
+  // Issue a timer tick to all pages
+  // - This is independent of the pages in the stack
+  uint8_t nPageInd;
+  gslc_tsPage* pPage = NULL;
+  for (nPageInd=0;nPageInd<pGui->nPageCnt;nPageInd++) {
+    pPage = &pGui->asPage[nPageInd];
+    gslc_tsEvent sEvent = gslc_EventCreate(pGui,GSLC_EVT_TICK,0,(void*)pPage,NULL);
+    gslc_PageEvent(pGui,sEvent);
+  }
+
+  // Perform any redraw required for current page
+  gslc_PageRedrawGo(pGui);
+
+  // Simple "frame" rate reporting
+  // - Note that the rate is based on the number of calls to gslc_Update()
+  //   per second, which may or may not redraw the frame
+  #ifdef DBG_FRAME_RATE
+  pGui->nFrameRateCnt++;
+  uint32_t  nElapsed = (time(NULL) - pGui->nFrameRateStart);
+  if (nElapsed > 0) {
+    GSLC_DEBUG_PRINT("Update rate: %6u / sec\n",pGui->nFrameRateCnt);
+    pGui->nFrameRateStart = time(NULL);
+    pGui->nFrameRateCnt = 0;
+  }
+  #endif
+
+  // Provide periodic yield
+  // - This instruction is important for some devices such as ESP8266
+  #if defined(ESP8266)
+    yield();
+  #endif
+
+}
+
+gslc_tsEvent  gslc_EventCreate(gslc_tsGui* pGui,gslc_teEventType eType,uint8_t nSubType,void* pvScope,void* pvData)
+{
+  gslc_tsEvent      sEvent;
+  sEvent.eType      = eType;
+  sEvent.nSubType   = nSubType;
+  sEvent.pvScope    = pvScope;
+  sEvent.pvData     = pvData;
+  return sEvent;
+}
+
+
+// ------------------------------------------------------------------------
+// Graphics General Functions
+// ------------------------------------------------------------------------
+
+
+bool gslc_IsInRect(int16_t nSelX,int16_t nSelY,gslc_tsRect rRect)
+{
+  if ( (nSelX >= rRect.x) && (nSelX <= rRect.x+rRect.w) &&
+     (nSelY >= rRect.y) && (nSelY <= rRect.y+rRect.h) ) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+bool gslc_IsInWH(int16_t nSelX,int16_t nSelY,uint16_t nWidth,uint16_t nHeight)
+{
+  if ( (nSelX >= 0) && (nSelX <= nWidth-1) &&
+     (nSelY >= 0) && (nSelY <= nHeight-1) ) {
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// Ensure the coordinates are increasing from nX0->nX1 and nY0->nY1
+// NOTE: UNUSED
+void gslc_OrderCoord(int16_t* pnX0,int16_t* pnY0,int16_t* pnX1,int16_t* pnY1)
+{
+  int16_t  nTmp;
+  if ((*pnX1) < (*pnX0)) {
+    nTmp = (*pnX0);
+    (*pnX0) = (*pnX1);
+    (*pnX1) = nTmp;
+  }
+  if ((*pnY1) < (*pnY0)) {
+    nTmp = (*pnY0);
+    (*pnY0) = (*pnY1);
+    (*pnY1) = nTmp;
+  }
+}
+
+
+bool gslc_ClipPt(gslc_tsRect* pClipRect,int16_t nX,int16_t nY)
+{
+  int16_t nCX0 = pClipRect->x;
+  int16_t nCY0 = pClipRect->y;
+  int16_t nCX1 = pClipRect->x + pClipRect->w - 1;
+  int16_t nCY1 = pClipRect->y + pClipRect->h - 1;
+  if ( (nX < nCX0) || (nX > nCX1) ) { return false; }
+  if ( (nY < nCY0) || (nY > nCY1) ) { return false; }
+  return true;
+}
+
+
+// This routine implements a basic Cohen-Sutherland line-clipping algorithm
+// TODO: Optimize the code further
+bool gslc_ClipLine(gslc_tsRect* pClipRect,int16_t* pnX0,int16_t* pnY0,int16_t* pnX1,int16_t* pnY1)
+{
+  int16_t nTmpX,nTmpY;
+  int16_t nCXMin,nCXMax,nCYMin,nCYMax;
+  uint8_t nRegion0,nRegion1,nRegionSel;
+  int16_t nLX0,nLY0,nLX1,nLY1;
+
+  int16_t nCX0 = pClipRect->x;
+  int16_t nCY0 = pClipRect->y;
+  int16_t nCX1 = pClipRect->x + pClipRect->w - 1;
+  int16_t nCY1 = pClipRect->y + pClipRect->h - 1;
+
+  if (nCX0 > nCX1) {
+    nCXMin = nCX1;
+    nCXMax = nCX0;
+  } else {
+    nCXMin = nCX0;
+    nCXMax = nCX1;
+  }
+  if (nCY0 > nCY1) {
+    nCYMin = nCY1;
+    nCYMax = nCY0;
+  } else {
+    nCYMin = nCY0;
+    nCYMax = nCY1;
+  }
+
+  nTmpX = 0;
+  nTmpY = 0;
+  while (1) {
+    nLX0 = *pnX0;
+    nLY0 = *pnY0;
+    nLX1 = *pnX1;
+    nLY1 = *pnY1;
+
+    // Step 1: Assign a region code to each endpoint
+    nRegion0 = 0;
+    nRegion1 = 0;
+    if      (nLX0 < nCX0) { nRegion0 |= 1; }
+    else if (nLX0 > nCX1) { nRegion0 |= 2; }
+    if      (nLY0 < nCY0) { nRegion0 |= 4; }
+    else if (nLY0 > nCY1) { nRegion0 |= 8; }
+    if      (nLX1 < nCX0) { nRegion1 |= 1; }
+    else if (nLX1 > nCX1) { nRegion1 |= 2; }
+    if      (nLY1 < nCY0) { nRegion1 |= 4; }
+    else if (nLY1 > nCY1) { nRegion1 |= 8; }
+
+    // Step 2: Check for complete inclusion
+    if ((nRegion0 == 0) && (nRegion1 == 0)) {
+      return true;
+    }
+
+    // Step 3: Check for complete exclusion
+    if ((nRegion0 & nRegion1) != 0) {
+      return false;
+    }
+
+    // Step 4: Clipping
+    nRegionSel = nRegion0 ? nRegion0 : nRegion1;
+    if (nRegionSel & 8) {
+      nTmpX = nLX0 + (nLX1 - nLX0) * (nCYMax - nLY0) / (nLY1 - nLY0);
+      nTmpY = nCYMax;
+    } else if (nRegionSel & 4) {
+      nTmpX = nLX0 + (nLX1 - nLX0) * (nCYMin - nLY0) / (nLY1 - nLY0);
+      nTmpY = nCYMin;
+    } else if (nRegionSel & 2) {
+      nTmpY = nLY0 + (nLY1 - nLY0) * (nCXMax - nLX0) / (nLX1 - nLX0);
+      nTmpX = nCXMax;
+    } else if (nRegionSel & 1) {
+      nTmpY = nLY0 + (nLY1 - nLY0) * (nCXMin - nLX0) / (nLX1 - nLX0);
+      nTmpX = nCXMin;
+    }
+
+    // Update endpoint
+    if (nRegionSel == nRegion0) {
+      *pnX0 = nTmpX;
+      *pnY0 = nTmpY;
+    } else {
+      *pnX1 = nTmpX;
+      *pnY1 = nTmpY;
+    }
+  } // while(1)
+
+  return true;
+}
+
+
+bool gslc_ClipRect(gslc_tsRect* pClipRect,gslc_tsRect* pRect)
+{
+  int16_t nCX0 = pClipRect->x;
+  int16_t nCY0 = pClipRect->y;
+  int16_t nCX1 = pClipRect->x + pClipRect->w - 1;
+  int16_t nCY1 = pClipRect->y + pClipRect->h - 1;
+  int16_t nRX0 = pRect->x;
+  int16_t nRY0 = pRect->y;
+  int16_t nRX1 = pRect->x + pRect->w - 1;
+  int16_t nRY1 = pRect->y + pRect->h - 1;
+  // Check for completely out of clip view
+  if ( (nRX1 < nCX0) || (nRX0 > nCX1) ) { return false; }
+  if ( (nRY1 < nCY0) || (nRY0 > nCY1) ) { return false; }
+  // Reduce rect as required to fit view
+  nRX0 = (nRX0<nCX0)? nCX0 : nRX0;
+  nRY0 = (nRY0<nCY0)? nCY0 : nRY0;
+  nRX1 = (nRX1>nCX1)? nCX1 : nRX1;
+  nRY1 = (nRY1>nCY1)? nCY1 : nRY1;
+  pRect->x = nRX0;
+  pRect->y = nRY0;
+  pRect->w = nRX1-nRX0+1;
+  pRect->h = nRY1-nRY0+1;
+  return true;
+}
+
+
+
+gslc_tsImgRef gslc_ResetImage()
+{
+  gslc_tsImgRef sImgRef;
+  sImgRef.eImgFlags = GSLC_IMGREF_NONE;
+  sImgRef.pFname    = NULL;
+  sImgRef.pImgBuf   = NULL;
+  sImgRef.pvImgRaw  = NULL;
+  return sImgRef;
+}
+
+gslc_tsImgRef gslc_GetImageFromFile(const char* pFname,gslc_teImgRefFlags eFmt)
+{
+  gslc_tsImgRef sImgRef;
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_FILE | (GSLC_IMGREF_FMT & eFmt);
+  sImgRef.pFname    = pFname;
+  sImgRef.pImgBuf   = NULL;
+  sImgRef.pvImgRaw  = NULL;
+  return sImgRef;
+}
+
+gslc_tsImgRef gslc_GetImageFromSD(const char* pFname,gslc_teImgRefFlags eFmt)
+{
+  gslc_tsImgRef sImgRef;
+#if (GSLC_SD_EN)
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_SD | (GSLC_IMGREF_FMT & eFmt);
+  sImgRef.pFname    = pFname;
+  sImgRef.pImgBuf   = NULL;
+  sImgRef.pvImgRaw  = NULL;
+#else
+  // TODO: Change message to also handle non-Arduino output
+  GSLC_DEBUG2_PRINT("ERROR: GetImageFromSD(%s) not supported as Config:GSLC_SD_EN=0\n","");
+  sImgRef.eImgFlags = GSLC_IMGREF_NONE;
+#endif
+  return sImgRef;
+}
+
+gslc_tsImgRef gslc_GetImageFromRam(unsigned char* pImgBuf,gslc_teImgRefFlags eFmt)
+{
+  gslc_tsImgRef sImgRef;
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_RAM | (GSLC_IMGREF_FMT & eFmt);
+  sImgRef.pFname    = NULL;
+  sImgRef.pImgBuf   = pImgBuf;
+  sImgRef.pvImgRaw  = NULL;
+  return sImgRef;
+}
+
+
+gslc_tsImgRef gslc_GetImageFromProg(const unsigned char* pImgBuf,gslc_teImgRefFlags eFmt)
+{
+  gslc_tsImgRef sImgRef;
+#if (GSLC_USE_PROGMEM)
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_PROG | (GSLC_IMGREF_FMT & eFmt);
+#else
+  // Fallback to RAM if PROGMEM not implemented
+  sImgRef.eImgFlags = GSLC_IMGREF_SRC_RAM | (GSLC_IMGREF_FMT & eFmt);
+#endif
+  sImgRef.pFname    = NULL;
+  sImgRef.pImgBuf   = pImgBuf;
+  sImgRef.pvImgRaw  = NULL;
+  return sImgRef;
+}
+
+
+// Sine function with optional lookup table
+// - Note that the n64Ang range is limited by 16-bit integers
+//   to an effective degree range of -511 to +511 degrees,
+//   defined by the max integer range: 32767/64.
+int16_t gslc_sinFX(int16_t n64Ang)
+{
+  int16_t   nRetValS;
+
+#if (GSLC_USE_FLOAT)
+  // Use floating-point math library function
+
+  // Calculate angle in radians
+  float fAngRad = n64Ang*GSLC_2PI/(360.0*64.0);
+  // Perform floating point calc
+  float fSin = sin(fAngRad);
+  // Return as fixed point result
+  nRetValS = fSin * 32767.0;
+  return nRetValS;
+
+#else
+  // TODO: Clean up excess integer typecasting
+
+  // Use lookup tables
+  bool bNegate = false;
+
+  // Support multiple waveform periods
+  if (n64Ang >= 360*64) {
+    n64Ang = n64Ang - (360*64);
+  } else if (n64Ang <= -360*64) {
+    n64Ang = n64Ang + (360*64);
+  }
+  // Handle negative range
+  if (n64Ang < 0) {
+    n64Ang = -n64Ang;
+    bNegate = !bNegate;
+  }
+  // Handle 3rd and 4th phase
+  if (n64Ang >= 180*64) {
+    n64Ang -= 180*64;
+    bNegate = !bNegate;
+  }
+  // Handle 2nd phase
+  if (n64Ang >= 90*64) {
+    n64Ang = 180*64 - n64Ang;
+  }
+
+  // n64Ang is quarter-phase range [0 .. 90*64]
+  // suitable for lookup table indexing
+  uint16_t  nLutInd = ((uint32_t)n64Ang * 256)/(90*64);
+  uint16_t  nLutVal = m_nLUTSinF0X16[nLutInd];
+
+  // Leave MSB for the signed bit
+  nLutVal /= 2;
+  if (bNegate) {
+    nRetValS = -nLutVal;
+  } else {
+    nRetValS = nLutVal;
+  }
+  return nRetValS;
+
+#endif
+
+}
+
+// Cosine function with optional lookup table
+// - Note that the n64Ang range is limited by 16-bit integers
+//   to an effective degree range of -511 to +511 degrees,
+//   defined by the max integer range: 32767/64.
+int16_t gslc_cosFX(int16_t n64Ang)
+{
+#if (GSLC_USE_FLOAT)
+int16_t   nRetValS;
+  // Use floating-point math library function
+
+  // Calculate angle in radians
+  float fAngRad = n64Ang * GSLC_2PI / (360.0*64.0);
+  // Perform floating point calc
+  float fCos = cos(fAngRad);
+  // Return as fixed point result
+  nRetValS = fCos * 32767.0;
+  return nRetValS;
+
+#else
+  // Use lookup tables
+  // Cosine function is equivalent to Sine shifted by 90 degrees
+  // - To avoid int16_t overflow, we trap range beyond 360 degrees
+  //   and shift the angle by one rotation (360 degrees).
+  // - This is necessary because otherwise the +90*64 would reduce the
+  //   effective range of cosFX() to +421 degrees.
+  if (n64Ang >= 360 * 64) {
+    return gslc_sinFX((n64Ang - 360*64) + 90*64);
+  } else {
+    return gslc_sinFX(n64Ang+90*64);
+  }
+
+#endif
+
+}
+
+// Convert from polar to cartesian
+void gslc_PolarToXY(uint16_t nRad,int16_t n64Ang,int16_t* nDX,int16_t* nDY)
+{
+  int32_t nTmp;
+  // TODO: Clean up excess integer typecasting
+  nTmp = (int32_t)nRad *  gslc_sinFX(n64Ang);
+  *nDX = nTmp / 32767;
+  nTmp = (int32_t)nRad * -gslc_cosFX(n64Ang);
+  *nDY = nTmp / 32767;
+}
+
+// Call with nMidAmt=500 to create simple linear blend between two colors
+gslc_tsColor gslc_ColorBlend2(gslc_tsColor colStart,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt)
+{
+  gslc_tsColor  colMid;
+  colMid.r = (colEnd.r+colStart.r)/2;
+  colMid.g = (colEnd.g+colStart.g)/2;
+  colMid.b = (colEnd.b+colStart.b)/2;
+  return gslc_ColorBlend3(colStart,colMid,colEnd,nMidAmt,nBlendAmt);
+}
+
+gslc_tsColor gslc_ColorBlend3(gslc_tsColor colStart,gslc_tsColor colMid,gslc_tsColor colEnd,uint16_t nMidAmt,uint16_t nBlendAmt)
+{
+  gslc_tsColor  colNew;
+  nMidAmt   = (nMidAmt  >1000)?1000:nMidAmt;
+  nBlendAmt = (nBlendAmt>1000)?1000:nBlendAmt;
+
+  uint16_t  nRngLow   = nMidAmt;
+  uint16_t  nRngHigh  = 1000-nMidAmt;
+  int32_t   nSubBlendAmt;
+  if (nBlendAmt >= nMidAmt) {
+    nSubBlendAmt = (int32_t)(nBlendAmt - nMidAmt)*1000/nRngHigh;
+    colNew.r = nSubBlendAmt*(colEnd.r - colMid.r)/1000 + colMid.r;
+    colNew.g = nSubBlendAmt*(colEnd.g - colMid.g)/1000 + colMid.g;
+    colNew.b = nSubBlendAmt*(colEnd.b - colMid.b)/1000 + colMid.b;
+  } else {
+    nSubBlendAmt = (int32_t)(nBlendAmt - 0)*1000/nRngLow;
+    colNew.r = nSubBlendAmt*(colMid.r - colStart.r)/1000 + colStart.r;
+    colNew.g = nSubBlendAmt*(colMid.g - colStart.g)/1000 + colStart.g;
+    colNew.b = nSubBlendAmt*(colMid.b - colStart.b)/1000 + colStart.b;
+  }
+  return colNew;
+}
+
+bool gslc_ColorEqual(gslc_tsColor a,gslc_tsColor b)
+{
+  return a.r == b.r && a.g == b.g && a.b == b.b;
+}
+
+// ------------------------------------------------------------------------
+// Graphics Primitive Functions
+// ------------------------------------------------------------------------
+
+void gslc_DrawSetPixel(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+
+#if (DRV_HAS_DRAW_POINT)
+  // Call optimized driver point drawing
+  gslc_DrvDrawPoint(pGui,nX,nY,nCol);
+#else
+  GSLC_DEBUG2_PRINT("ERROR: Mandatory DrvDrawPoint() is not defined in driver\n");
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+// Draw an arbitrary line using Bresenham's algorithm
+// - Algorithm reference: https://rosettacode.org/wiki/Bitmap/Bresenham's_line_algorithm#C
+void gslc_DrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+
+#if (DRV_HAS_DRAW_LINE)
+  // Call optimized driver line drawing
+  gslc_DrvDrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+#else
+  // Perform Bresenham's line algorithm
+  int16_t nDX = abs(nX1-nX0);
+  int16_t nDY = abs(nY1-nY0);
+
+  int16_t nSX = (nX0 < nX1)? 1 : -1;
+  int16_t nSY = (nY0 < nY1)? 1 : -1;
+  int16_t nErr = ( (nDX>nDY)? nDX : -nDY )/2;
+  int16_t nE2;
+
+  // Check for degenerate cases
+  // TODO: Need to test these optimizations
+  bool bDone = false;
+  if (nDX == 0) {
+    if (nDY == 0) {
+      return;
+    } else if (nY1-nY0 >= 0) {
+      gslc_DrawLineV(pGui,nX0,nY0,nDY+1,nCol);
+      bDone = true;
+    } else {
+      gslc_DrawLineV(pGui,nX1,nY1,nDY+1,nCol);
+      bDone = true;
+    }
+  } else if (nDY == 0) {
+    if (nX1-nX0 >= 0) {
+      gslc_DrawLineH(pGui,nX0,nY0,nDX+1,nCol);
+      bDone = true;
+    } else {
+      gslc_DrawLineH(pGui,nX1,nY1,nDX+1,nCol);
+      bDone = true;
+    }
+  }
+
+  if (!bDone) {
+    for (;;) {
+      // Set the pixel
+      gslc_DrvDrawPoint(pGui,nX0,nY0,nCol);
+
+      // Calculate next coordinates
+      if ( (nX0 == nX1) && (nY0 == nY1) ) break;
+      nE2 = nErr;
+      if (nE2 > -nDX) { nErr -= nDY; nX0 += nSX; }
+      if (nE2 <  nDY) { nErr += nDX; nY0 += nSY; }
+    }
+  }
+  gslc_PageFlipSet(pGui,true);
+#endif
+
+}
+
+
+void gslc_DrawLineH(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nW,gslc_tsColor nCol)
+{
+  uint16_t nOffset;
+  for (nOffset=0;nOffset<nW;nOffset++) {
+    gslc_DrvDrawPoint(pGui,nX+nOffset,nY,nCol);
+  }
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_DrawLineV(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint16_t nH,gslc_tsColor nCol)
+{
+  uint16_t nOffset;
+  for (nOffset=0;nOffset<nH;nOffset++) {
+    gslc_DrvDrawPoint(pGui,nX,nY+nOffset,nCol);
+  }
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+
+// Note that angle is in degrees * 64
+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 the ray representing the current value
+  int16_t nDxS = (int32_t)nRadStart * gslc_sinFX(n64Ang)/32768;
+  int16_t nDyS = (int32_t)nRadStart * gslc_cosFX(n64Ang)/32768;
+  int16_t nDxE = (int32_t)nRadEnd   * gslc_sinFX(n64Ang)/32768;
+  int16_t nDyE = (int32_t)nRadEnd   * gslc_cosFX(n64Ang)/32768;
+  gslc_DrawLine(pGui,nX+nDxS,nY-nDyS,nX+nDxE,nY-nDyE,nCol);
+}
+
+
+void gslc_DrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  // Ensure dimensions are valid
+  if ((rRect.w == 0) || (rRect.h == 0)) {
+    return;
+  }
+
+#if (DRV_HAS_DRAW_RECT_FRAME)
+  // Call optimized driver implementation
+  gslc_DrvDrawFrameRect(pGui,rRect,nCol);
+#else
+  // Emulate rect frame with four lines
+  int16_t   nX,nY;
+  uint16_t  nH,nW;
+  nX = rRect.x;
+  nY = rRect.y;
+  nW = rRect.w;
+  nH = rRect.h;
+  gslc_DrawLineH(pGui,nX,nY,nW-1,nCol);                 // Top
+  gslc_DrawLineH(pGui,nX,(int16_t)(nY+nH-1),nW-1,nCol); // Bottom
+  gslc_DrawLineV(pGui,nX,nY,nH-1,nCol);                 // Left
+  gslc_DrawLineV(pGui,(int16_t)(nX+nW-1),nY,nH-1,nCol); // Right
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_DrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+  // Ensure dimensions are valid
+  if ((rRect.w == 0) || (rRect.h == 0)) {
+    return;
+  }
+
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  // Call optimized driver implementation
+  gslc_DrvDrawFrameRoundRect(pGui,rRect,nRadius,nCol);
+#else
+  // TODO: Add emulation of rounded rects. For now fallback to square corners
+  gslc_DrvDrawFrameRect(pGui,rRect,nCol);
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+
+void gslc_DrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  // Ensure dimensions are valid
+  if ((rRect.w == 0) || (rRect.h == 0)) {
+    return;
+  }
+
+#if (DRV_HAS_DRAW_RECT_FILL)
+  // Call optimized driver implementation
+  gslc_DrvDrawFillRect(pGui,rRect,nCol);
+#else
+  // Emulate it with individual line draws
+  // TODO: This should be avoided as it will generally be very inefficient
+  int nRow;
+  for (nRow=0;nRow<rRect.h;nRow++) {
+    gslc_DrawLineH(pGui, rRect.x, rRect.y+nRow, rRect.w, nCol);
+  }
+
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_DrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+  // Ensure dimensions are valid
+  if ((rRect.w == 0) || (rRect.h == 0)) {
+    return;
+  }
+
+#if (DRV_HAS_DRAW_RECT_ROUND_FILL)
+  // Call optimized driver implementation
+  gslc_DrvDrawFillRoundRect(pGui,rRect,nRadius,nCol);
+#else
+  // TODO: Add emulation of rounded rects. For now fallback to square corners
+  gslc_DrvDrawFillRect(pGui,rRect,nCol);
+#endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+
+
+// Expand or contract a rectangle in width and/or height (equal
+// amounts on both side), based on the centerpoint of the rectangle.
+gslc_tsRect gslc_ExpandRect(gslc_tsRect rRect,int16_t nExpandW,int16_t nExpandH)
+{
+  gslc_tsRect rNew = {0,0,0,0};
+
+  // Detect error case of contracting region too far
+  if ( ((int16_t)rRect.w < (-2*nExpandW)) || ((int16_t)rRect.h < (-2*nExpandH)) ) {
+    // Return an empty coordinate box (which won't be drawn)
+    //GSLC_DEBUG2_PRINT("ERROR: ExpandRect(%d,%d) contracts too far\n",nExpandW,nExpandH);
+    return rNew;
+  }
+
+  // Adjust the new width/height
+  // Note that the overall width/height changes by a factor of
+  // two since we are applying the adjustment on both sides (ie.
+  // top/bottom or left/right) equally.
+  rNew.w = rRect.w + (2*nExpandW);
+  rNew.h = rRect.h + (2*nExpandH);
+
+  // Adjust the rectangle coordinate to allow for new dimensions
+  // Note that this moves the coordinate in the opposite
+  // direction of the expansion/contraction.
+  rNew.x = rRect.x - nExpandW;
+  rNew.y = rRect.y - nExpandH;
+
+  return rNew;
+}
+
+
+// Expand the current rect (pRect) to enclose the additional rect region (rAddRect)
+void gslc_UnionRect(gslc_tsRect* pRect,gslc_tsRect rAddRect)
+{
+  int16_t nSrcX0, nSrcY0, nSrcX1, nSrcY1;
+  int16_t nAddX0, nAddY0, nAddX1, nAddY1;
+
+  // If the source rect has zero dimensions, then treat as empty
+  if ((pRect->w == 0) || (pRect->h == 0)) {
+    // No source region defined, simply copy add region
+    *pRect = rAddRect;
+    return;
+  }
+
+  // Source region valid, so increase dimensions
+
+  // Calculate the rect boundary coordinates
+  nSrcX0 = pRect->x;
+  nSrcY0 = pRect->y;
+  nSrcX1 = pRect->x + pRect->w - 1;
+  nSrcY1 = pRect->y + pRect->h - 1;
+  nAddX0 = rAddRect.x;
+  nAddY0 = rAddRect.y;
+  nAddX1 = rAddRect.x + rAddRect.w - 1;
+  nAddY1 = rAddRect.y + rAddRect.h - 1;
+
+  // Find the new maximal dimensions
+  nSrcX0 = (nAddX0 < nSrcX0) ? nAddX0 : nSrcX0;
+  nSrcY0 = (nAddY0 < nSrcY0) ? nAddY0 : nSrcY0;
+  nSrcX1 = (nAddX1 > nSrcX1) ? nAddX1 : nSrcX1;
+  nSrcY1 = (nAddY1 > nSrcY1) ? nAddY1 : nSrcY1;
+
+  // Update the original rect region
+  pRect->x = nSrcX0;
+  pRect->y = nSrcY0;
+  pRect->w = nSrcX1 - nSrcX0 + 1;
+  pRect->h = nSrcY1 - nSrcY0 + 1;
+
+}
+
+void gslc_InvalidateRgnReset(gslc_tsGui* pGui)
+{
+#if defined(DBG_REDRAW)
+  GSLC_DEBUG_PRINT("DBG: InvRgnReset\n", "");
+#endif
+  pGui->bInvalidateEn = false;
+  pGui->rInvalidateRect = (gslc_tsRect) { 0, 0, 1, 1 };
+}
+
+void gslc_InvalidateRgnScreen(gslc_tsGui* pGui)
+{
+#if defined(DBG_REDRAW)
+  GSLC_DEBUG_PRINT("DBG: InvRgnScreen\n", "");
+#endif
+  pGui->bInvalidateEn = true;
+  pGui->rInvalidateRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+}
+
+void gslc_InvalidateRgnPage(gslc_tsGui* pGui, gslc_tsPage* pPage)
+{
+  if (pPage == NULL) {
+    return;
+  }
+#if defined(DBG_REDRAW)
+  GSLC_DEBUG_PRINT("DBG: InvRgnPage: Page=%d (%d,%d)-(%d,%d)\n",
+    pPage->nPageId,
+    pPage->rBounds.x, pPage->rBounds.y, pPage->rBounds.x + pPage->rBounds.w - 1, pPage->rBounds.y + pPage->rBounds.h - 1); //xxx
+#endif // DBG_REDRAW
+  gslc_InvalidateRgnAdd(pGui, pPage->rBounds);
+  pGui->bInvalidateEn = true;
+}
+
+
+void gslc_InvalidateRgnAdd(gslc_tsGui* pGui, gslc_tsRect rAddRect)
+{
+  if (pGui->bInvalidateEn) {
+    gslc_UnionRect(&(pGui->rInvalidateRect), rAddRect);
+  } else {
+    pGui->bInvalidateEn = true;
+    pGui->rInvalidateRect = rAddRect;
+  }
+}
+
+
+// Draw a circle using midpoint circle algorithm
+// - Algorithm reference: https://en.wikipedia.org/wiki/Midpoint_circle_algorithm
+void gslc_DrawFrameCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
+  uint16_t nRadius,gslc_tsColor nCol)
+{
+
+  #if (DRV_HAS_DRAW_CIRCLE_FRAME)
+    // Call optimized driver implementation
+    gslc_DrvDrawFrameCircle(pGui,nMidX,nMidY,nRadius,nCol);
+  #else
+    // Emulate circle with point drawing
+
+    int16_t nX    = nRadius;
+    int16_t nY    = 0;
+    int16_t nErr  = 0;
+
+    #if (DRV_HAS_DRAW_POINTS)
+      gslc_tsPt asPt[8];
+      while (nX >= nY)
+      {
+        asPt[0] = (gslc_tsPt){nMidX + nX, nMidY + nY};
+        asPt[1] = (gslc_tsPt){nMidX + nY, nMidY + nX};
+        asPt[2] = (gslc_tsPt){nMidX - nY, nMidY + nX};
+        asPt[3] = (gslc_tsPt){nMidX - nX, nMidY + nY};
+        asPt[4] = (gslc_tsPt){nMidX - nX, nMidY - nY};
+        asPt[5] = (gslc_tsPt){nMidX - nY, nMidY - nX};
+        asPt[6] = (gslc_tsPt){nMidX + nY, nMidY - nX};
+        asPt[7] = (gslc_tsPt){nMidX + nX, nMidY - nY};
+        gslc_DrvDrawPoints(pGui,asPt,8,nCol);
+
+        nY    += 1;
+        nErr  += 1 + 2*nY;
+        if (2*(nErr-nX) + 1 > 0)
+        {
+            nX -= 1;
+            nErr += 1 - 2*nX;
+        }
+      } // while
+
+    #elif (DRV_HAS_DRAW_POINT)
+      while (nX >= nY)
+      {
+        gslc_DrvDrawPoint(pGui,nMidX + nX, nMidY + nY,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX + nY, nMidY + nX,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX - nY, nMidY + nX,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX - nX, nMidY + nY,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX - nX, nMidY - nY,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX - nY, nMidY - nX,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX + nY, nMidY - nX,nCol);
+        gslc_DrvDrawPoint(pGui,nMidX + nX, nMidY - nY,nCol);
+
+        nY    += 1;
+        nErr  += 1 + 2*nY;
+        if (2*(nErr-nX) + 1 > 0)
+        {
+            nX -= 1;
+            nErr += 1 - 2*nX;
+        }
+      } // while
+
+    #else
+      // ERROR
+    #endif
+
+  #endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+// Draw a filled circle using midpoint circle algorithm
+// - Algorithm reference: https://en.wikipedia.org/wiki/Midpoint_circle_algorithm
+// - Adapted for fill by connecting points by lines
+// - No separate frame color is performed
+void gslc_DrawFillCircle(gslc_tsGui* pGui,int16_t nMidX,int16_t nMidY,
+  uint16_t nRadius,gslc_tsColor nCol)
+{
+
+  #if (DRV_HAS_DRAW_CIRCLE_FILL)
+    // Call optimized driver implementation
+    gslc_DrvDrawFillCircle(pGui,nMidX,nMidY,nRadius,nCol);
+  #else
+    // Emulate circle with line drawing
+
+    int16_t nX    = nRadius;  // a
+    int16_t nY    = 0;        // b
+    int16_t nErr  = 0;
+
+    while (nX >= nY)
+    {
+
+      // Connect pairs of the reflected points around the circumference
+
+      //gslc_DrvDrawPoint(pGui,nMidX - nY, nMidY + nX,nCol);  // (-b,+a)
+      //gslc_DrvDrawPoint(pGui,nMidX + nY, nMidY + nX,nCol);  // (+b,+a)
+      gslc_DrawLine(pGui,nMidX-nY,nMidY+nX,nMidX+nY,nMidY+nX,nCol);
+
+      //gslc_DrvDrawPoint(pGui,nMidX - nX, nMidY + nY,nCol);  // (-a,+b)
+      //gslc_DrvDrawPoint(pGui,nMidX + nX, nMidY + nY,nCol);  // (+a,+b)
+      gslc_DrawLine(pGui,nMidX-nX,nMidY+nY,nMidX+nX,nMidY+nY,nCol);
+
+      //gslc_DrvDrawPoint(pGui,nMidX - nX, nMidY - nY,nCol);  // (-a,-b)
+      //gslc_DrvDrawPoint(pGui,nMidX + nX, nMidY - nY,nCol);  // (+a,-b)
+      gslc_DrawLine(pGui,nMidX-nX,nMidY-nY,nMidX+nX,nMidY-nY,nCol);
+
+      //gslc_DrvDrawPoint(pGui,nMidX - nY, nMidY - nX,nCol);  // (-b,-a)
+      //gslc_DrvDrawPoint(pGui,nMidX + nY, nMidY - nX,nCol);  // (+b,-a)
+      gslc_DrawLine(pGui,nMidX-nY,nMidY-nX,nMidX+nY,nMidY-nX,nCol);
+
+
+      nY    += 1;
+      nErr  += 1 + 2*nY;
+      if (2*(nErr-nX) + 1 > 0)
+      {
+          nX -= 1;
+          nErr += 1 - 2*nX;
+      }
+    } // while
+
+
+  #endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+
+// Draw a triangle
+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)
+{
+
+  #if (DRV_HAS_DRAW_TRI_FRAME)
+    // Call optimized driver implementation
+    gslc_DrvDrawFrameTriangle(pGui,nX0,nY0,nX1,nY1,nX2,nY2,nCol);
+  #else
+    // Draw triangle with three lines
+    gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+    gslc_DrawLine(pGui,nX1,nY1,nX2,nY2,nCol);
+    gslc_DrawLine(pGui,nX2,nY2,nX0,nY0,nCol);
+
+  #endif
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_SwapCoords(int16_t* pnXa,int16_t* pnYa,int16_t* pnXb,int16_t* pnYb)
+{
+  int16_t nSwapX,nSwapY;
+  nSwapX = *pnXa;
+  nSwapY = *pnYa;
+  *pnXa = *pnXb;
+  *pnYa = *pnYb;
+  *pnXb = nSwapX;
+  *pnYb = nSwapY;
+}
+
+
+// Draw a filled triangle
+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)
+{
+
+  #if (DRV_HAS_DRAW_TRI_FILL)
+    // Call optimized driver implementation
+    gslc_DrvDrawFillTriangle(pGui,nX0,nY0,nX1,nY1,nX2,nY2,nCol);
+
+  #else
+    // Emulate triangle fill
+
+    // Algorithm:
+    // - An arbitrary triangle is cut into two portions:
+    //   1) a flat bottom triangle
+    //   2) a flat top triangle
+    // - Sort the vertices in descending vertical position.
+    //   This serves two purposes:
+    //   1) ensures that the division between the flat bottom
+    //      and flat top triangles occurs at Y=Y1
+    //   2) ensure that we avoid division-by-zero in the for loops
+    // - Walk each scan line and determine the intersection
+    //   between triangle side A & B (flat bottom triangle)
+    //   and then C and B (flat top triangle) using line slopes.
+
+    // Sort vertices
+    // - Want nY0 >= nY1 >= nY2
+    if (nY2>nY1) { gslc_SwapCoords(&nX2,&nY2,&nX1,&nY1); }
+    if (nY1>nY0) { gslc_SwapCoords(&nX0,&nY0,&nX1,&nY1); }
+    if (nY2>nY1) { gslc_SwapCoords(&nX2,&nY2,&nX1,&nY1); }
+
+    // TODO: It is more efficient to calculate row endpoints
+    // using incremental additions instead of multiplies/divides
+
+    int16_t nXa,nXb,nXc,nYos;
+    int16_t nX01,nX20,nY01,nY20,nX21,nY21;
+    nX01 = nX0-nX1; nY01 = nY0-nY1;
+    nX20 = nX2-nX0; nY20 = nY2-nY0;
+    nX21 = nX2-nX1; nY21 = nY2-nY1;
+
+    // Flat bottom scenario
+    // NOTE: Due to vertex sorting and loop range, it shouldn't
+    // be possible to enter loop when nY0 == nY1 or nY2
+    for (nYos=0;nYos<nY01;nYos++) {
+      // Determine row endpoints (no rounding)
+      //nXa = (nYos          )*(nX0-nX1)/(nY0-nY1);
+      //nXb = (nYos-(nY0-nY1))*(nX2-nX0)/(nY2-nY0);
+
+      // Determine row endpoints (using rounding)
+      nXa  = 2*(nYos)*nX01;
+      nXa += (nXa>=0)?abs(nY01):-abs(nY01);
+      nXa /= 2*nY01;
+
+      nXb = 2*(nYos-nY01)*nX20;
+      nXb += (nXb>=0)?abs(nY20):-abs(nY20);
+      nXb /= 2*nY20;
+
+      // Draw horizontal line between endpoints
+      gslc_DrawLine(pGui,nX1+nXa,nY1+nYos,nX0+nXb,nY1+nYos,nCol);
+    }
+
+    // Flat top scenario
+    // NOTE: Due to vertex sorting and loop range, it shouldn't
+    // be possible to enter loop when nY2 == nY0 or nY1
+    for (nYos=nY21;nYos<0;nYos++) {
+
+      // Determine row endpoints (no rounding)
+      //nXc = (nYos          )*(nX2-nX1)/(nY2-nY1);
+      //nXb = (nYos-(nY0-nY1))*(nX2-nX0)/(nY2-nY0);
+
+      // Determine row endpoints (using rounding)
+      nXc  = 2*(nYos)*nX21;
+      nXc += (nXc>=0)?abs(nY21):-abs(nY21);
+      nXc /= 2*nY21;
+
+      nXb = 2*(nYos-nY01)*nX20;
+      nXb += (nXb>=0)?abs(nY20):-abs(nY20);
+      nXb /= 2*nY20;
+
+      // Draw horizontal line between endpoints
+      gslc_DrawLine(pGui,nX1+nXc,nY1+nYos,nX0+nXb,nY1+nYos,nCol);
+    }
+
+  #endif  // DRV_HAS_DRAW_TRI_FILL
+
+  gslc_PageFlipSet(pGui,true);
+}
+
+void gslc_DrawFrameQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol)
+{
+  int16_t nX0,nY0,nX1,nY1;
+
+  nX0 = psPt[0].x; nY0 = psPt[0].y; nX1 = psPt[1].x; nY1 = psPt[1].y;
+  gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+  nX0 = psPt[1].x; nY0 = psPt[1].y; nX1 = psPt[2].x; nY1 = psPt[2].y;
+  gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+  nX0 = psPt[2].x; nY0 = psPt[2].y; nX1 = psPt[3].x; nY1 = psPt[3].y;
+  gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+  nX0 = psPt[3].x; nY0 = psPt[3].y; nX1 = psPt[0].x; nY1 = psPt[0].y;
+  gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,nCol);
+
+}
+
+// Filling a quadrilateral is done by breaking it down into
+// two filled triangles sharing one side. We have to be careful
+// about the triangle fill routine (ie. using rounding) so that
+// we can avoid leaving a thin seam between the two triangles.
+void gslc_DrawFillQuad(gslc_tsGui* pGui,gslc_tsPt* psPt,gslc_tsColor nCol)
+{
+  int16_t nX0,nY0,nX1,nY1,nX2,nY2;
+
+  // Break down quadrilateral into two triangles
+  nX0 = psPt[0].x; nY0 = psPt[0].y;
+  nX1 = psPt[1].x; nY1 = psPt[1].y;
+  nX2 = psPt[2].x; nY2 = psPt[2].y;
+  gslc_DrawFillTriangle(pGui,nX0,nY0,nX1,nY1,nX2,nY2,nCol);
+
+  nX0 = psPt[2].x; nY0 = psPt[2].y;
+  nX1 = psPt[0].x; nY1 = psPt[0].y;
+  nX2 = psPt[3].x; nY2 = psPt[3].y;
+  gslc_DrawFillTriangle(pGui,nX0,nY0,nX1,nY1,nX2,nY2,nCol);
+
+}
+
+void gslc_DrawFillSectorBase(gslc_tsGui* pGui, int16_t nQuality, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2,
+  gslc_tsColor cArcStart, gslc_tsColor cArcEnd,bool bGradient, int16_t nAngGradStart, int16_t nAngGradRange,int16_t nAngSecStart,int16_t nAngSecEnd)
+{
+  gslc_tsPt anPts[4];
+
+  // Calculate degrees per step (based on quality setting)
+  int16_t nStepAng = 360 / nQuality;
+  int16_t nStep64 = 64 * nStepAng;
+
+  int16_t nAng64;
+  int16_t nX, nY;
+  int16_t nSegStart, nSegEnd;
+  gslc_tsColor colSeg;
+
+  nSegStart = nAngSecStart * (int32_t)nQuality / 360;
+  nSegEnd = nAngSecEnd * (int32_t)nQuality / 360;
+
+  int16_t nSegGradStart, nSegGradRange;
+  nSegGradStart = nAngGradStart * (int32_t)nQuality / 360;
+  nSegGradRange = nAngGradRange * (int32_t)nQuality / 360;
+  nSegGradRange = (nSegGradRange == 0) ? 1 : nSegGradRange; // Guard against div/0
+
+  bool bClockwise;
+  int16_t nSegInd;
+  int16_t nStepCnt;
+  if (nSegEnd >= nSegStart) {
+    nStepCnt = nSegEnd - nSegStart;
+    bClockwise = true;
+  } else {
+    nStepCnt = nSegStart - nSegEnd;
+    bClockwise = false;
+  }
+
+  #if defined(DBG_REDRAW)
+  //GSLC_DEBUG_PRINT("FillSector: AngSecStart=%d AngSecEnd=%d SegStart=%d SegEnd=%d StepCnt=%d CW=%d\n",
+  //  nAngSecStart,nAngSecEnd,nSegStart,nSegEnd,nStepCnt,bClockwise);
+  #endif
+
+  for (int16_t nStepInd = 0; nStepInd < nStepCnt; nStepInd++) {
+    // Remap from the step to the segment index, depending on direction
+    nSegInd = (bClockwise)? (nSegStart + nStepInd) : (nSegStart - nStepInd - 1);
+
+    nAng64 = (int32_t)(nSegInd * nStep64) % (int32_t)(360 * 64);
+	
+    #if defined(DBG_REDRAW)
+    GSLC_DEBUG2_PRINT("FillSector:  StepInd=%d SegInd=%d (%d..%d) Ang64=%d\n", nStepInd, nSegInd, nSegStart, nSegEnd, nAng64);
+    #endif
+
+    gslc_PolarToXY(nRad1, nAng64, &nX, &nY);
+    anPts[0] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad2, nAng64, &nX, &nY);
+    anPts[1] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad2, nAng64 + nStep64, &nX, &nY);
+    anPts[2] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad1, nAng64 + nStep64, &nX, &nY);
+    anPts[3] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+
+    if (bGradient) {
+      // Gradient coloring
+      int16_t nGradPos = 1000 * (int32_t)(nSegInd-nSegGradStart) / nSegGradRange;
+      #if defined(DBG_REDRAW)
+      GSLC_DEBUG2_PRINT("FillSector:   GradPos=%d\n", nGradPos);
+      #endif
+      colSeg = gslc_ColorBlend2(cArcStart, cArcEnd, 500, nGradPos);
+    } else {
+      // Flat coloring
+      colSeg = cArcStart;
+    }
+    
+    gslc_DrawFillQuad(pGui, anPts, colSeg);
+  }
+}
+
+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)
+{
+  gslc_DrawFillSectorBase(pGui, nQuality, nMidX, nMidY, nRad1, nRad2, cArcStart, cArcEnd, true,
+    nAngGradStart, nAngGradRange, nAngSecStart, nAngSecEnd);
+}
+
+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)
+{
+  gslc_DrawFillSectorBase(pGui, nQuality, nMidX, nMidY, nRad1, nRad2, cArc, cArc, false,
+    0, 0, nAngSecStart, nAngSecEnd);
+}
+
+
+// -----------------------------------------------------------------------
+// Font Functions
+// -----------------------------------------------------------------------
+
+bool gslc_FontSetBase(gslc_tsGui* pGui, uint8_t nFontInd, int16_t nFontId, gslc_teFontRefType eFontRefType,
+  const void* pvFontRef, uint16_t nFontSz)
+{
+  if (nFontInd >= pGui->nFontMax) {
+    GSLC_DEBUG2_PRINT("ERROR: FontSetBase() invalid Font index=%d\n",nFontInd);
+    return false;
+  } else {
+    // Fetch a font resource from the driver
+    const void* pvFont = gslc_DrvFontAdd(eFontRefType,pvFontRef,nFontSz);
+    // FIXME: Resolve a means to detect if LINUX font files failed to load
+    //         and then return 'false'. Note that DrvFontAdd() may normally
+    //         return NULL in ADAGFX mode for some font types.
+
+    gslc_ResetFont(&(pGui->asFont[nFontInd]));
+  
+    pGui->asFont[nFontInd].eFontRefType = eFontRefType;
+    // TODO: Support specification of mode via FontAdd() API?
+    pGui->asFont[nFontInd].eFontRefMode = GSLC_FONTREF_MODE_DEFAULT;
+    pGui->asFont[nFontInd].pvFont       = pvFont;
+    pGui->asFont[nFontInd].nId          = nFontId;
+    pGui->asFont[nFontInd].nSize        = nFontSz;
+
+    return true;
+  }
+}
+
+
+// Store font into indexed position in font storage
+// - nFontId must be in range 0..nFontMax-1
+bool gslc_FontSet(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefType eFontRefType,
+  const void* pvFontRef, uint16_t nFontSz)
+{
+  if ((nFontId < 0) || (nFontId >= pGui->nFontMax)) {
+    GSLC_DEBUG2_PRINT("ERROR: FontSet() invalid Font ID=%d\n",nFontId);
+    return false;
+  } else {
+    bool bRet = false;
+
+    // The font index is set to the same as the font enum ID
+    uint8_t nFontInd = nFontId;
+    bRet = gslc_FontSetBase(pGui, nFontInd, nFontId, eFontRefType, pvFontRef, nFontSz);
+
+    // Ensure the total font count is set to max
+    pGui->nFontCnt = pGui->nFontMax;
+
+    return bRet;
+  }
+}
+
+bool gslc_FontAdd(gslc_tsGui* pGui,int16_t nFontId,gslc_teFontRefType eFontRefType,
+    const void* pvFontRef,uint16_t nFontSz)
+{
+  if (pGui->nFontCnt+1 > (pGui->nFontMax)) {
+    GSLC_DEBUG2_PRINT("ERROR: FontAdd(%s) added too many fonts\n","");
+    return false;
+  } else {
+    bool bRet = false;
+
+    // Fetch the next unallocated index
+    uint8_t nFontInd = pGui->nFontCnt;
+    bRet = gslc_FontSetBase(pGui, nFontInd, nFontId, eFontRefType, pvFontRef, nFontSz);
+
+    // Increment the current font index
+    pGui->nFontCnt++;
+
+    return bRet;
+  }
+}
+
+
+gslc_tsFont* gslc_FontGet(gslc_tsGui* pGui,int16_t nFontId)
+{
+  uint8_t  nFontInd;
+  for (nFontInd=0;nFontInd<pGui->nFontCnt;nFontInd++) {
+    if (pGui->asFont[nFontInd].nId == nFontId) {
+      return &(pGui->asFont[nFontInd]);
+    }
+  }
+  return NULL;
+}
+
+bool gslc_FontSetMode(gslc_tsGui* pGui, int16_t nFontId, gslc_teFontRefMode eFontMode)
+{
+  gslc_tsFont* pFont = NULL;
+  pFont = gslc_FontGet(pGui, nFontId);
+  if (!pFont) {
+    // TODO: ERROR
+    return false;
+  }
+  pFont->eFontRefMode = eFontMode;
+  return true;
+}
+
+
+// ------------------------------------------------------------------------
+// Page Functions
+// ------------------------------------------------------------------------
+
+// Common event handler
+bool gslc_PageEvent(void* pvGui,gslc_tsEvent sEvent)
+{
+  if (pvGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "PageEvent";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  //gslc_tsGui*       pGui        = (gslc_tsGui*)(pvGui);
+  //void*             pvData      = sEvent.pvData;
+  gslc_tsPage*        pPage       = (gslc_tsPage*)(sEvent.pvScope);
+  gslc_tsCollect*     pCollect    = NULL;
+
+  if (pPage == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "PageEvent";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+  }
+
+  // Handle any page-level events first
+  // ...
+
+  // A Page only contains one Element Collection, so propagate
+
+  // Handle the event types
+  switch(sEvent.eType) {
+    case GSLC_EVT_DRAW:
+    case GSLC_EVT_TICK:
+    case GSLC_EVT_TOUCH:
+      pCollect  = &pPage->sCollect;
+      // Update scope reference & propagate
+      sEvent.pvScope = (void*)(pCollect);
+      gslc_CollectEvent(pvGui,sEvent);
+      break;
+
+    default:
+      break;
+  } // sEvent.eType
+
+  return true;
+}
+
+
+void gslc_PageAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* psElem,uint16_t nMaxElem,
+        gslc_tsElemRef* psElemRef,uint16_t nMaxElemRef)
+{
+  if (pGui->nPageCnt+1 > (pGui->nPageMax)) {
+    GSLC_DEBUG2_PRINT("ERROR: PageAdd(%s) added too many pages\n","");
+    return;
+  }
+
+  gslc_tsPage*  pPage = &pGui->asPage[pGui->nPageCnt];
+
+  //pPage->pfuncXEvent      = NULL; // UNUSED
+
+  // Initialize pPage->sCollect
+  gslc_CollectReset(&pPage->sCollect,psElem,nMaxElem,psElemRef,nMaxElemRef);
+
+  // Assign the requested Page ID
+  pPage->nPageId = nPageId;
+
+  // Initialize the page elements bounds to empty
+  pPage->rBounds = (gslc_tsRect) { 0, 0, 0, 0 };
+
+  // Increment the page count
+  pGui->nPageCnt++;
+
+  // Assign the first page added to be the current layer
+  // in the page stack. This can be overridden later
+  // with SetPageCur()
+  if (gslc_GetPageCur(pGui) == GSLC_PAGE_NONE) {
+    gslc_SetPageCur(pGui,nPageId);
+  }
+  // ------------------------------------------------------
+
+  // Force the page to redraw
+  // TODO: Should this mark the page or the screen?
+  gslc_PageRedrawSet(pGui,true);
+
+}
+
+int gslc_GetPageCur(gslc_tsGui* pGui)
+{
+  gslc_tsPage* pStackPage = pGui->apPageStack[GSLC_STACK_CUR];
+  if (pStackPage == NULL) {
+    return GSLC_PAGE_NONE;
+  }
+  return pStackPage->nPageId;
+}
+
+void gslc_SetStackPage(gslc_tsGui* pGui, uint8_t nStackPos, int16_t nPageId)
+{
+  int16_t nPageSaved = GSLC_PAGE_NONE;
+  gslc_tsPage* pPageSaved = pGui->apPageStack[nStackPos];
+  if (pPageSaved != NULL) {
+    nPageSaved = pPageSaved->nPageId;
+  }
+
+  gslc_tsPage* pPage = NULL;
+  if (nPageId == GSLC_PAGE_NONE) {
+    // Disable the page
+    #if defined(DEBUG_LOG)
+    GSLC_DEBUG_PRINT("INFO: Disabled PageStack[%u]\n",nStackPos);
+    #endif
+    pPage = NULL;
+  } else {
+
+    // Find the page
+    pPage = gslc_PageFindById(pGui, nPageId);
+    if (pPage == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: SetStackPage() can't find page (ID=%d)\n", nPageId);
+      return;
+    }
+  }
+
+  // Save a reference to the selected page
+  pGui->apPageStack[nStackPos] = pPage;
+
+  #if defined(DEBUG_LOG)
+  GSLC_DEBUG_PRINT("INFO: Changed PageStack[%u] to page %u\n",nStackPos,nPageId);
+  #endif
+
+  // A change of page should always force a future redraw
+  // TODO: Consider that showing a popup could potentially optimize out
+  // the forced redraw step.
+  if (nPageSaved != nPageId) {
+    gslc_PageRedrawSet(pGui,true);
+  }
+
+  // Invalidate the old page in the stack
+  if (pPageSaved != NULL) {
+    gslc_InvalidateRgnPage(pGui, pPageSaved);
+  }
+
+  // Invalidate the new page in the stack and any above
+  for (uint8_t nStackPage = nStackPos; nStackPage < GSLC_STACK__MAX; nStackPage++) {
+    // Select the page collection to process
+    pPage = pGui->apPageStack[nStackPage];
+    if (pPage != NULL) {
+      gslc_InvalidateRgnPage(pGui, pPage);
+    }
+  }
+}
+
+
+void gslc_SetStackState(gslc_tsGui* pGui, uint8_t nStackPos, bool bActive, bool bDoDraw)
+{
+  gslc_tsPage* pStackPage = pGui->apPageStack[nStackPos];
+  if (pStackPage == NULL) {
+    // TODO: Error
+    return;
+  }
+  pGui->abPageStackActive[nStackPos] = bActive;
+  pGui->abPageStackDoDraw[nStackPos] = bDoDraw;
+}
+
+void gslc_SetPageBase(gslc_tsGui* pGui, int16_t nPageId)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_BASE, nPageId);
+}
+
+void gslc_SetPageCur(gslc_tsGui* pGui,int16_t nPageId)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_CUR, nPageId);
+}
+
+void gslc_SetPageOverlay(gslc_tsGui* pGui,int16_t nPageId)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_OVERLAY, nPageId);
+}
+
+void gslc_PopupShow(gslc_tsGui* pGui, int16_t nPageId, bool bModal)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_OVERLAY, nPageId);
+  // If modal dialog selected, then deactivate other pages in stack
+  // If modeless dialog selected, then don't deactivate other pages in stack
+  if (bModal) {
+    // Modal: deactive other pages and disable redraw
+    gslc_SetStackState(pGui, GSLC_STACK_CUR, false, false);
+    gslc_SetStackState(pGui, GSLC_STACK_BASE, false, false);
+  }
+  else {
+    // Modeless: activate other pages and enable background redraw
+    // NOTE: If a popup overlaps controls that continue to be updated
+    //       in the background, then extra redraws will occur. In that
+    //       case, it may be preferrable to set redraw to false.
+    gslc_SetStackState(pGui, GSLC_STACK_CUR, true, true);
+    gslc_SetStackState(pGui, GSLC_STACK_BASE, true, true);
+  }
+}
+
+void gslc_PopupHide(gslc_tsGui* pGui)
+{
+  gslc_SetStackPage(pGui, GSLC_STACK_OVERLAY, GSLC_PAGE_NONE);
+  // Ensure other pages in stack are activated
+  // - This is done in case they were deactivated due to a modal popup
+  gslc_SetStackState(pGui, GSLC_STACK_CUR, true, true);
+  gslc_SetStackState(pGui, GSLC_STACK_BASE, true, true);
+}
+
+
+// Adjust the flag that indicates whether the entire page
+// requires a redraw.
+void gslc_PageRedrawSet(gslc_tsGui* pGui,bool bRedraw)
+{
+  if (pGui == NULL) {
+    return;
+  }
+
+  pGui->bScreenNeedRedraw = bRedraw;
+}
+
+bool gslc_PageRedrawGet(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    return false;
+  }
+
+  return pGui->bScreenNeedRedraw;
+}
+
+// Check the redraw flag on all elements on the current page and update
+// the redraw status if additional redraws are required (or the
+// entire page should be marked as requiring redraw).
+// - The typical case for this being required is when an element
+//   requires redraw but it is marked as being transparent. Therefore,
+//   the lower level elements should be redrawn.
+// - For now, just mark the entire page as requiring redraw.
+// TODO: Determine which elements underneath should be redrawn based
+//       on the region exposed by the transparent element.
+void gslc_PageRedrawCalc(gslc_tsGui* pGui)
+{
+  int               nInd;
+  int               nStackPage;
+  gslc_tsElem*      pElem = NULL;
+  gslc_tsElemRef*   pElemRef = NULL;
+  gslc_tsCollect*   pCollect = NULL;
+
+  bool  bRedrawFullPage = false;  // Does entire page require redraw?
+  gslc_tsPage*  pPage = NULL;
+
+  // Work on each enabled page in the stack
+  for (nStackPage=0;nStackPage<GSLC_STACK__MAX;nStackPage++) {
+    // Select the page collection to process
+    pPage = pGui->apPageStack[nStackPage];
+    if (!pPage) {
+      // If this stack page is not enabled, skip to next stack page
+      continue;
+    }
+    if (!pGui->abPageStackDoDraw[nStackPage]) {
+      // If this stack page has redraw disabled, skip full-page redraw check
+      continue;
+    }
+    pCollect = &pPage->sCollect;
+
+    for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+      pElemRef = &pCollect->asElemRef[nInd];
+      gslc_teElemRefFlags eFlags = pElemRef->eElemFlags;
+      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+      //GSLC_DEBUG2_PRINT("PageRedrawCalc: Ind=%u ID=%u redraw=%u flags_old=%u fea=%u\n",nInd,pElem->nId,
+      //        (eFlags & GSLC_ELEMREF_REDRAW_MASK),eFlags,pElem->nFeatures);
+      if ((eFlags & GSLC_ELEMREF_REDRAW_MASK) != GSLC_ELEMREF_REDRAW_NONE) {
+
+        // If partial redraw is supported, then we
+        // look out for transparent elements which may
+        // still warrant full page redraw.
+        if (pGui->bRedrawPartialEn) {
+          // Is the element transparent?
+          // FIXME: Instead of forcing full page redraw, consider
+          // using clipping region for partial redraw
+          if (!(pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN)) {
+            bRedrawFullPage = true;
+          }
+        } else {
+          bRedrawFullPage = true;
+        }
+
+        if (bRedrawFullPage) {
+          // Determined that full page needs redraw
+          // so no need to check any more elements
+          break;
+        }
+
+      }
+    }
+
+  } // nStackPage
+
+  if (bRedrawFullPage) {
+    // Mark the entire screen as requiring redraw
+    gslc_PageRedrawSet(pGui,true);
+  }
+
+}
+
+// Redraw the active page
+// - If the page has been marked as needing redraw, then all
+//   elements are rendered
+// - If the page has not been marked as needing redraw then only
+//   the elements that have been marked as needing redraw
+//   are rendered.
+void gslc_PageRedrawGo(gslc_tsGui* pGui)
+{
+  // Update any page redraw status that may be required
+  // - Note that this routine handles cases where an element
+  //   marked as requiring update is semi-transparent which can
+  //   cause other elements to be redrawn as well.
+  gslc_PageRedrawCalc(pGui);
+
+  // Determine final state of full-screen redraw
+  bool  bPageRedraw = gslc_PageRedrawGet(pGui);
+
+  // Set the clipping based on the current invalidated region
+  if (pGui->bInvalidateEn) {
+    #if defined(DBG_REDRAW)
+    // Note that this will still outline the invalidation region
+    // even if we later discover that the changed element is on
+    // a page in the stack that has been disabled through
+    // abPageStackDoDraw[] = false.
+    GSLC_DEBUG_PRINT("DBG: PageRedrawGo() InvRgn: En=%d (%d,%u)-(%d,%d) PageRedraw=%d\n",
+      pGui->bInvalidateEn, pGui->rInvalidateRect.x, pGui->rInvalidateRect.y,
+      pGui->rInvalidateRect.x + pGui->rInvalidateRect.w - 1,
+      pGui->rInvalidateRect.y + pGui->rInvalidateRect.h - 1, bPageRedraw);
+
+    // Mark the invalidation region
+    gslc_DrvDrawFrameRect(pGui, pGui->rInvalidateRect, GSLC_COL_RED);
+
+    // Slow down rendering
+    delay(1000);
+    #endif // DBG_REDRAW
+
+    gslc_SetClipRect(pGui, &(pGui->rInvalidateRect));
+  }
+  else {
+    // No invalidation region defined, so default the
+    // clipping region to the entire display
+    gslc_SetClipRect(pGui, NULL);
+  }
+
+  // If a full page redraw is required, then start by
+  // redrawing the background.
+  // NOTE:
+  // - It would be cleaner if we could treat the background
+  //   layer like any other element (and hence check for its
+  //   need-redraw status).
+  // - For now, assume background doesn't need update except
+  //   if the entire page is to be redrawn
+  //   TODO: Fix this assumption (either add specific flag
+  //         for bBkgndNeedRedraw or make the background just
+  //         another element).
+  if (bPageRedraw) {
+    gslc_DrvDrawBkgnd(pGui);
+    gslc_PageFlipSet(pGui,true);
+  }
+
+  // Draw other elements (as needed, unless forced page redraw)
+  // TODO: Handle GSLC_EVTSUB_DRAW_NEEDED
+  uint32_t nSubType = (bPageRedraw)?GSLC_EVTSUB_DRAW_FORCE:GSLC_EVTSUB_DRAW_NEEDED;
+  void*    pvData = NULL;
+
+  // TODO: Consider creating a flag that indicates whether any elements
+  // on the page have requested redraw. This would enable us to skip
+  // over this exhaustive search every time we call Update()
+
+  // Issue page redraw events to all pages in stack
+  // - Start from bottom page in stack first
+  for (int nStackPage = 0; nStackPage < GSLC_STACK__MAX; nStackPage++) {
+    gslc_tsPage* pStackPage = pGui->apPageStack[nStackPage];
+    if (!pStackPage) {
+      continue;
+    }
+    if (!bPageRedraw && !pGui->abPageStackDoDraw[nStackPage]) {
+      // When doing a full page redraw, proceed as normal
+      // When only doing a parital page redraw, check to see if
+      // the page has been marked as redraw-disabled. If so, skip
+      // updating the elements on the page.
+      //
+      // The redraw-disabled mode is useful to prevent "show-through"
+      // from dynamically-updating elements in lower layers of the
+      // page stack (this may occur with popup dialogs). If the overlay
+      // page does not overlap dynamically-updating elements, then
+      // DoDraw can be set to true, enabling background updates to occur.
+      continue;
+    }
+    pvData = (void*)(pStackPage);
+    gslc_tsEvent sEvent = gslc_EventCreate(pGui,GSLC_EVT_DRAW,nSubType,pvData,NULL);
+    gslc_PageEvent(pGui,sEvent);
+  }
+
+
+  // Clear the page redraw flag
+  gslc_PageRedrawSet(pGui,false);
+
+  // Reset the invalidated regions
+  gslc_InvalidateRgnReset(pGui);
+ 
+  // Restore the clipping region to the entire display
+  gslc_SetClipRect(pGui, NULL);
+
+  // Page flip the entire screen
+  // - TODO: We could also call Update instead of Flip as that would
+  //         limit the region to refresh.
+  gslc_PageFlipGo(pGui);
+
+}
+
+
+void gslc_PageFlipSet(gslc_tsGui* pGui,bool bNeeded)
+{
+  if (pGui == NULL) {
+    return;
+  }
+
+  pGui->bScreenNeedFlip = bNeeded;
+
+  // To assist in debug of drawing primitives, support immediate
+  // rendering of the current display. Note that this only works
+  // for display drivers that don't invalidate the double-buffer (eg. SDL1.2)
+#ifdef DBG_DRAW_IMM
+  gslc_DrvPageFlipNow(pGui);
+#endif
+}
+
+bool gslc_PageFlipGet(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    return false;
+  }
+
+  return pGui->bScreenNeedFlip;
+}
+
+void gslc_PageFlipGo(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    return;
+  }
+
+  if (pGui->bScreenNeedFlip) {
+    gslc_DrvPageFlipNow(pGui);
+
+    // Indicate that page flip is no longer required
+    gslc_PageFlipSet(pGui,false);
+  }
+}
+
+
+gslc_tsPage* gslc_PageFindById(gslc_tsGui* pGui,int16_t nPageId)
+{
+  int8_t nInd;
+
+  // Loop through list of pages
+  // Return pointer to page
+  gslc_tsPage*  pFoundPage = NULL;
+  for (nInd=0;nInd<pGui->nPageMax;nInd++) {
+    if (pGui->asPage[nInd].nPageId == nPageId) {
+      pFoundPage = &pGui->asPage[nInd];
+      break;
+    }
+  }
+
+  // Error handling: if not found, make this a fatal error
+  // as it shows a serious config error and continued operation
+  // is not viable.
+  if (pFoundPage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: PageFindById() can't find page (ID=%d)\n",nPageId);
+    return NULL;
+  }
+
+  return pFoundPage;
+}
+
+gslc_tsElemRef* gslc_PageFindElemById(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId)
+{
+  gslc_tsPage*    pPage = NULL;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Get the page
+  pPage = gslc_PageFindById(pGui,nPageId);
+  if (pPage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: PageFindElemById() can't find page (ID=%d)\n",nPageId);
+    return NULL;
+  }
+  // Find the element reference in the page's element collection
+  pElemRef = gslc_CollectFindElemById(pGui,&pPage->sCollect,nElemId);
+  return pElemRef;
+}
+
+/* UNUSED
+void gslc_PageSetEventFunc(gslc_tsGui* pGui,gslc_tsPage* pPage,GSLC_CB_EVENT funcCb)
+{
+  if ((pPage == NULL) || (funcCb == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "PageSetEventFunc";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pPage->pfuncXEvent       = funcCb;
+}
+*/
+
+
+// TODO: Create a PageStackFocusStep()
+// - The functionality would track which page is currently focused
+//   and instead of looping around on the page, the next enabled
+//   page in the stack would be traversed.
+// - Wrapping at the bottom of the stack would create the GSLC_IND_NONE
+//   state.
+// - Without this enhancement, GPIO / keyboard controls will only
+//   operate on the top-most page in the stack, which prevents the
+//   ability to navigate tab select controls if they are provided
+//   by a lower layer in the stack.
+
+
+int16_t gslc_PageFocusStep(gslc_tsGui* pGui, gslc_tsPage* pPage, bool bNext)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return GSLC_IND_NONE;
+#else
+  bool              bWrapped = false;
+  bool              bFound = false;
+  int16_t           nInd = GSLC_IND_NONE;
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+
+  bFound = gslc_CollectFindFocusStep(pGui, pCollect, bNext, &bWrapped, &nInd);
+  if (!bFound) {
+    nInd = GSLC_IND_NONE;
+  } else {
+    if (bWrapped) {
+      // Optionally pause here
+      // If we wrap, then disable current focus for this particular step
+      nInd = GSLC_IND_NONE;
+    }
+  }
+  gslc_CollectSetFocus(pGui,pCollect,nInd);
+  return nInd;
+#endif
+}
+
+
+// ------------------------------------------------------------------------
+// Element General Functions
+// ------------------------------------------------------------------------
+
+
+int gslc_ElemGetId(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return GSLC_ID_NONE;
+  return pElem->nId;
+}
+
+
+// Get a flag from an element reference
+// Note that the flag remains aligned to the position within the flags bitfield
+uint8_t gslc_GetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask)
+{
+  if (!pElemRef) {
+    static const char GSLC_PMEM FUNCSTR[] = "GetElemRefFlag";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  return pElemRef->eElemFlags & nFlagMask;
+}
+
+// Set a flag in an element reference
+// Note that the nFlagVal must be aligned to the nFlagMask
+void gslc_SetElemRefFlag(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nFlagMask,uint8_t nFlagVal)
+{
+  if (!pElemRef) {
+    static const char GSLC_PMEM FUNCSTR[] = "SetElemRefFlag";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  uint8_t nCurFlags = pElemRef->eElemFlags;
+  uint8_t nNewFlags = (nCurFlags & ~nFlagMask) | nFlagVal;
+  pElemRef->eElemFlags = nNewFlags;
+}
+
+// Returns a pointer to an element from an element reference
+// - Handle caching from FLASH if element is accessed via PROGMEM
+gslc_tsElem* gslc_GetElemFromRef(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (!pElemRef) {
+    static const char GSLC_PMEM FUNCSTR[] = "GetElemFromRef";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_teElemRefFlags eFlags  = pElemRef->eElemFlags;
+  gslc_tsElem*        pElem   = pElemRef->pElem; // NOTE below
+
+  // NOTE: The pElem assignment above is not applicable for
+  //       PROGMEM-based elements. For these elements, we
+  //       need to access the structure through the FLASH APIs,
+  //       hence the default assignment above will be overwritten
+  //       below.
+
+  // If the element is in FLASH and requires PROGMEM to access
+  // then cache it locally and return a pointer to the global
+  // temporary element instead so that further accesses can
+  // be direct.
+  if ((eFlags & GSLC_ELEMREF_SRC) == GSLC_ELEMREF_SRC_PROG) {
+    // TODO: Optimize by checking to see if we already cached this element
+    // - Can probably do this by comparing the bValid and nId
+    #if (GSLC_USE_PROGMEM)
+    memcpy_P(&pGui->sElemTmpProg,pElem,sizeof(gslc_tsElem));
+    pElem = &pGui->sElemTmpProg;
+    #endif
+  } else if ((eFlags & GSLC_ELEMREF_SRC) == GSLC_ELEMREF_SRC_CONST) {
+    // We are running on device that may support FLASH storage
+    // simply by using a const declaration. No special
+    // PROGMEM access mechanism is required, therefore it is
+    // not necessary to copy to the temporary RAM element.
+    // An example device using this mode is Cortex-M0.
+    // No explicit copy from FLASH is required.
+  } else {
+    // SRC_ELEMREF_SRC_RAM
+    // No copy required
+  }
+  return pElem;
+}
+
+// Fetch element from reference, with debug
+gslc_tsElem* gslc_GetElemFromRefD(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nLineNum)
+{
+  if (pElemRef == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: GetElemFromRefD(Line %d) pElemRef is NULL\n", nLineNum);
+    return NULL;
+  }
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui, pElemRef);
+  if (pElem == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: GetElemFromRefD(Line %d) pElem is NULL\n", nLineNum);
+    return NULL;
+  }
+  return pElem;
+}
+
+// For extended elements, fetch the extended data structure
+void* gslc_GetXDataFromRef(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nType, int16_t nLineNum)
+{
+  if (pElemRef == NULL) {
+    GSLC_DEBUG_PRINT("ERROR: GetXDataFromRef(Type %d, Line %d) pElemRef is NULL\n", nType, nLineNum);
+    return NULL;
+  }
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui, pElemRef);
+  if (pElem == NULL) {
+    GSLC_DEBUG_PRINT("ERROR: GetXDataFromRef(Type %d, Line %d) pElem is NULL\n", nType, nLineNum);
+    return NULL;
+  }
+  if (pElem->nType != nType) {
+    GSLC_DEBUG_PRINT("ERROR: GetXDataFromRef(Type %d, Line %d) Elem type mismatch\n", nType, nLineNum);
+    return NULL;
+  }
+  void* pXData = pElem->pXData;
+  if (pXData == NULL) {
+    GSLC_DEBUG_PRINT("ERROR: GetXDataFromRef(Type %d, Line %d) pXData is NULL\n", nType, nLineNum);
+    return NULL;
+  }
+  return pXData;
+}
+
+// ------------------------------------------------------------------------
+// Element Global Functions
+// ------------------------------------------------------------------------
+
+
+// Set the global rounded radius for rounded rectangles
+void gslc_SetRoundRadius(gslc_tsGui* pGui,uint8_t nRadius)
+{
+  pGui->nRoundRadius = (int16_t)nRadius;
+  // Update redraw flag
+  gslc_PageRedrawSet(pGui,true);
+}
+
+
+// ------------------------------------------------------------------------
+// Element Creation Functions
+// ------------------------------------------------------------------------
+
+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_tsElem       sElem;
+  gslc_tsElemRef*   pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_TXT,rElem,pStrBuf,nStrBufMax,nFontId);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  sElem.colElemText       = GSLC_COL_YELLOW;
+  sElem.colElemTextGlow   = GSLC_COL_YELLOW;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.eTxtAlign         = GSLC_ALIGN_MID_LEFT;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+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_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Ensure the Font has been defined
+  if (gslc_FontGet(pGui,nFontId) == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemCreateBtnTxt(ID=%d): Font(ID=%d) not loaded\n",nElemId,nFontId);
+    return NULL;
+  }
+
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_BTN,rElem,pStrBuf,nStrBufMax,nFontId);
+  sElem.colElemFill       = GSLC_COL_BLUE_DK4;
+  sElem.colElemFillGlow   = GSLC_COL_BLUE_DK1;
+  sElem.colElemFrame      = GSLC_COL_BLUE_DK2;
+  sElem.colElemFrameGlow  = GSLC_COL_BLUE_DK2;
+  sElem.colElemText       = GSLC_COL_WHITE;
+  sElem.colElemTextGlow   = GSLC_COL_WHITE;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+  sElem.pfuncXTouch       = cbTouch;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+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_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_BTN,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_BLUE_DK2;
+  sElem.colElemFrameGlow  = GSLC_COL_BLUE_DK2;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+  sElem.pfuncXTouch       = cbTouch;
+  // Update the normal and glowing images
+  gslc_DrvSetElemImageNorm(pGui,&sElem,sImgRef);
+  gslc_DrvSetElemImageGlow(pGui,&sElem,sImgRefSel);
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+gslc_tsElemRef* gslc_ElemCreateBox(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,gslc_tsRect rElem)
+{
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_BOX,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+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_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  gslc_tsRect     rRect;
+  rRect.x = nX0;
+  rRect.y = nY0;
+  rRect.w = nX1 - nX0 + 1;
+  rRect.h = nY1 - nY0 + 1;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_LINE,rRect,NULL,0,GSLC_FONT_NONE);
+  // For line elements, we will draw it with the "fill" color
+  sElem.colElemFill       = GSLC_COL_GRAY;
+  sElem.colElemFillGlow   = GSLC_COL_GRAY;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FILL_EN;   // Disable boundary box fill
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;  // Disable boundary box frame
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+gslc_tsElemRef* gslc_ElemCreateImg(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsRect rElem,gslc_tsImgRef sImgRef)
+{
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPE_BOX,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures      &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures      |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures      &= ~GSLC_ELEM_FEA_CLICK_EN;
+  // Update the normal and glowing images
+  gslc_DrvSetElemImageNorm(pGui,&sElem,sImgRef);
+  gslc_DrvSetElemImageGlow(pGui,&sElem,sImgRef);
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// ------------------------------------------------------------------------
+// Element Event Handlers
+// ------------------------------------------------------------------------
+
+// Common event handler
+bool gslc_ElemEvent(void* pvGui,gslc_tsEvent sEvent)
+{
+  if (pvGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemEvent";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*         pGui              = (gslc_tsGui*)(pvGui);
+  void*               pvData            = sEvent.pvData;
+  void*               pvScope           = sEvent.pvScope;
+  gslc_tsElemRef*     pElemRef          = NULL;
+  gslc_tsElemRef*     pElemRefTracked   = NULL;
+  gslc_tsElem*        pElem             = NULL;
+  gslc_tsElem*        pElemTracked      = NULL;
+  gslc_tsEventTouch*  pTouchRec         = NULL;
+  int                 nRelX,nRelY;
+  gslc_teTouch        eTouch;
+  GSLC_CB_TOUCH       pfuncXTouch       = NULL;
+  GSLC_CB_TICK        pfuncXTick        = NULL;
+
+  switch(sEvent.eType) {
+    case GSLC_EVT_DRAW:
+      // Fetch the parameters
+      pElemRef = (gslc_tsElemRef*)(pvScope);
+      pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+
+      // Determine if redraw is needed
+      gslc_teRedrawType eRedraw = gslc_ElemGetRedraw(pGui,pElemRef);
+
+      if (sEvent.nSubType == GSLC_EVTSUB_DRAW_FORCE) {
+        // Despite the current pending redraw state of the element,
+        // we will force a full redraw as requested.
+        //GSLC_DEBUG_PRINT("DBG: ElemEvent(Draw) nId=%d eRedraw=%d: force to FULL\n",pElem->nId,eRedraw);
+        return gslc_ElemDrawByRef(pGui,pElemRef,GSLC_REDRAW_FULL);
+      } else if (eRedraw != GSLC_REDRAW_NONE) {
+        // There is a pending redraw for the element. It may
+        // either be an incremental or full redraw.
+        //GSLC_DEBUG_PRINT("DBG: ElemEvent(Draw) nId=%d eRedraw=%d\n",pElem->nId,eRedraw);
+        return gslc_ElemDrawByRef(pGui,pElemRef,eRedraw);
+      } else {
+        // No redraw needed pending
+        return true;
+      }
+      break;
+
+    case GSLC_EVT_TOUCH:
+      #if defined(DRV_TOUCH_NONE)
+      // Hide warnings about unused variables when TOUCH is not enabled
+      (void)pvData;
+      (void)pElemRefTracked;
+      (void)pElemTracked;
+      (void)pTouchRec;
+      (void)nRelX;
+      (void)nRelY;
+      (void)eTouch;
+      (void)pfuncXTouch;
+      #else
+      // Fetch the parameters
+      pElemRef = (gslc_tsElemRef*)(pvScope);
+      pTouchRec = (gslc_tsEventTouch*)(pvData);
+      pElemRefTracked = pElemRef;
+      pElemTracked = gslc_GetElemFromRef(pGui,pElemRefTracked);
+      eTouch = pTouchRec->eTouch;
+      if ((eTouch & GSLC_TOUCH_TYPE_MASK) == GSLC_TOUCH_DIRECT) {
+        // Pass parameters directly (they are not coordinates)
+        nRelX = pTouchRec->nX;
+        nRelY = pTouchRec->nY;
+      } else {
+        // Generate relative coordinates
+        nRelX = pTouchRec->nX - pElemTracked->rElem.x;
+        nRelY = pTouchRec->nY - pElemTracked->rElem.y;
+      }
+
+      // Since we are going to use the callback within the element
+      // we need to ensure it is cached in RAM first
+      pElemTracked = gslc_GetElemFromRef(pGui,pElemRefTracked);
+      pfuncXTouch = pElemTracked->pfuncXTouch;
+
+      // Invoke the callback function
+      if (pfuncXTouch != NULL) {
+        // Pass in the relative position from corner of element region
+        (*pfuncXTouch)(pvGui,(void*)(pElemRefTracked),eTouch,nRelX,nRelY);
+      }
+      #endif // DRV_TOUCH_NONE
+      break;
+
+    case GSLC_EVT_TICK:
+      // Fetch the parameters
+      pElemRef = (gslc_tsElemRef*)(pvScope);
+
+      // Since we are going to use the callback within the element
+      // we need to ensure it is cached in RAM first
+      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+      pfuncXTick = pElem->pfuncXTick;
+
+      // Invoke the callback function
+      if (pfuncXTick != NULL) {
+        // TODO: Confirm that tick functions want pvScope
+        (*pfuncXTick)(pvGui,(void*)(pElemRef));
+        return true;
+      }
+      break;
+
+    default:
+      break;
+  }
+  return true;
+}
+
+// ------------------------------------------------------------------------
+// Element Drawing Functions
+// ------------------------------------------------------------------------
+
+
+// Draw an element to the active display
+// - Element is referenced by page ID and element ID
+// - Tnis routine triggers an immediate redraw of an element, and may be useful
+//   for user code in creating custom drawing callbacks
+void gslc_ElemDraw(gslc_tsGui* pGui,int16_t nPageId,int16_t nElemId)
+{
+  gslc_tsElemRef* pElemRef = gslc_PageFindElemById(pGui,nPageId,nElemId);
+  gslc_tsEvent sEvent = gslc_EventCreate(pGui,GSLC_EVT_DRAW,GSLC_EVTSUB_DRAW_FORCE,(void*)pElemRef,NULL);
+  gslc_ElemEvent(pGui,sEvent);
+}
+
+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)
+{
+  int16_t   nElemX,nElemY;
+  uint16_t  nElemW,nElemH;
+
+  nElemX    = rTxt.x;
+  nElemY    = rTxt.y;
+  nElemW    = rTxt.w;
+  nElemH    = rTxt.h;
+
+  // Overlay the text
+  bool bRenderTxt = true;
+  // Skip text render if buffer pointer not allocated
+  if ((bRenderTxt) && (pStrBuf == NULL)) { bRenderTxt = false; }
+  // Skip text render if string is not set
+  if ((bRenderTxt) && ((eTxtFlags & GSLC_TXT_ALLOC) == GSLC_TXT_ALLOC_NONE)) { bRenderTxt = false; }
+
+  // Do we still want to render?
+  if (bRenderTxt) {
+#if (DRV_HAS_DRAW_TEXT)
+
+    // Determine if GUIslice or driver should perform text alignment
+    // - Generally, GUIslice provides the text alignment functionality
+    //   by querying the display driver for the dimensions of the text
+    //   to be rendered.
+    // - Some drivers (such as TFT_eSPI) perform more complex logic
+    //   associated with the text alignment and hence GUIslice will
+    //   defer to the driver to handle the positioning. In that case
+    //   the bounding box and alignment mode is provided to the driver.
+#if (DRV_OVERRIDE_TXT_ALIGN)
+
+    // GUIslice will allow the driver to perform the text alignment
+    // calculations.
+
+    // Provide bounding box and alignment flag to driver to calculate
+    int16_t nX0 = nElemX + nMarginW;
+    int16_t nY0 = nElemY + nMarginH;
+    int16_t nX1 = nX0 + nElemW - 2*nMarginW;
+    int16_t nY1 = nY0 + nElemH - 2*nMarginH;
+
+    gslc_DrvDrawTxtAlign(pGui,nX0,nY0,nX1,nY1,eTxtAlign,pTxtFont,
+            pStrBuf,eTxtFlags,colTxt,colBg);
+
+#else // DRV_OVERRIDE_TXT_ALIGN
+
+    // GUIslice will ask the driver for the text dimensions and calculate
+    // the appropriate positioning to support the requested text
+    // alignment mode.
+
+    // Fetch the size of the text to allow for justification
+    // NOTE: For multi-line text strings, the following call will
+    //       return the maximum dimensions of the entire block of
+    //       text, thus alignment will be based on the outer dimensions
+    //       not individual rows of text. As a result, the overall
+    //       text block will be rendered with the requested alignment
+    //       but individual rows will render like GSLC_ALIGNH_LEFT
+    //       within the aligned text block. In order to support per-line
+    //       horizontal justification, a pre-scan and alignment calculation
+    //       for each text row would need to be performed.
+    int16_t       nTxtOffsetX=0;
+    int16_t       nTxtOffsetY=0;
+    uint16_t      nTxtSzW=0;
+    uint16_t      nTxtSzH=0;
+    gslc_DrvGetTxtSize(pGui,pTxtFont,pStrBuf,eTxtFlags,&nTxtOffsetX,&nTxtOffsetY,&nTxtSzW,&nTxtSzH);
+
+    // Calculate the text alignment
+    int16_t       nTxtX,nTxtY;
+
+    // Check for ALIGNH_LEFT & ALIGNH_RIGHT. Default to ALIGNH_MID
+    if      (eTxtAlign & GSLC_ALIGNH_LEFT)     { nTxtX = nElemX+nMarginW; }
+    else if (eTxtAlign & GSLC_ALIGNH_RIGHT)    { nTxtX = nElemX+nElemW-nMarginW-nTxtSzW; }
+    else                                       { nTxtX = nElemX+(nElemW/2)-(nTxtSzW/2); }
+
+    // Check for ALIGNV_TOP & ALIGNV_BOT. Default to ALIGNV_MID
+    if      (eTxtAlign & GSLC_ALIGNV_TOP)      { nTxtY = nElemY+nMarginH; }
+    else if (eTxtAlign & GSLC_ALIGNV_BOT)      { nTxtY = nElemY+nElemH-nMarginH-nTxtSzH; }
+    else                                       { nTxtY = nElemY+(nElemH/2)-(nTxtSzH/2); }
+
+    // Now correct for offset from text bounds
+    // - This is used by the driver (such as Adafruit-GFX) to provide an
+    //   adjustment for baseline height, etc.
+    nTxtX += nTxtOffsetX;
+    nTxtY -= nTxtOffsetY;
+
+    // Call the driver text rendering routine
+    gslc_DrvDrawTxt(pGui,nTxtX,nTxtY,pTxtFont,pStrBuf,eTxtFlags,colTxt,colBg);
+
+#endif // DRV_OVERRIDE_TXT_ALIGN
+
+#else // DRV_HAS_DRAW_TEXT
+    // No text support in driver, so skip
+#endif // DRV_HAS_DRAW_TEXT
+  }
+}
+
+// Draw an element to the active display
+// - Element is referenced by an element pointer
+// - TODO: Handle GSLC_TYPE_BKGND
+bool gslc_ElemDrawByRef(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  if (eRedraw == GSLC_REDRAW_NONE) {
+    // No redraw to do
+    return true;
+  }
+
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  // --------------------------------------------------------------------------
+  // Handle visibility
+  // --------------------------------------------------------------------------
+  bool bVisible = gslc_ElemGetVisible(pGui, pElemRef);
+  if (!bVisible) {
+    // The element is hidden, so no drawing required.
+    // Clear the redraw-pending flag.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+    return true;
+  }
+
+  // --------------------------------------------------------------------------
+  // Custom drawing
+  // --------------------------------------------------------------------------
+
+  // Handle any extended element types
+  // - If the pfuncXDraw callback is defined, then let the callback
+  //   function supersede all default handling here
+  // - Note that the end of the callback function is expected
+  //   to clear the redraw flag
+  if (pElem->pfuncXDraw != NULL) {
+    (*pElem->pfuncXDraw)((void*)(pGui),(void*)(pElemRef),eRedraw);
+    return true;
+  }
+
+  // --------------------------------------------------------------------------
+  // Init for default drawing
+  // --------------------------------------------------------------------------
+
+  bool      bGlowEn,bGlowing,bGlowNow;
+  int16_t   nElemX,nElemY;
+  uint16_t  nElemW,nElemH;
+
+  nElemX    = pElem->rElem.x;
+  nElemY    = pElem->rElem.y;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+  bGlowEn   = pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN; // Does the element support glow state?
+  bGlowing  = gslc_ElemGetGlow(pGui,pElemRef); // Element should be glowing (if enabled)
+  bGlowNow  = bGlowEn & bGlowing; // Element is currently glowing
+  gslc_tsColor colBg = GSLC_COL_BLACK;
+
+  // --------------------------------------------------------------------------
+  // Background
+  // --------------------------------------------------------------------------
+
+  // Fill in the background
+  gslc_tsRect rElemInner = pElem->rElem;
+  // - If both fill and frame are enabled then contract
+  //   the fill region slightly so that we don't overdraw
+  //   the frame (prevent unnecessary flicker).
+  if ((pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN) && (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN)) {
+    // NOTE: If the region is already too small to shrink (eg. w=1 or h=1)
+    // then a zero dimension box will be returned by ExpandRect() and not drawn
+    rElemInner = gslc_ExpandRect(rElemInner,-1,-1);
+  }
+  // - This also changes the fill color if selected and glow state is enabled
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN) {
+    if (bGlowEn && bGlowing) {
+      colBg = pElem->colElemFillGlow;
+    } else {
+      colBg = pElem->colElemFill;
+    }
+    if (pElem->nFeatures & GSLC_ELEM_FEA_ROUND_EN) {
+      gslc_DrawFillRoundRect(pGui, rElemInner, pGui->nRoundRadius, colBg);
+    } else {
+      gslc_DrawFillRect(pGui, rElemInner, colBg);
+    }
+  } else {
+    // TODO: If unfilled, then we might need
+    // to redraw the background layer(s)
+  }
+
+  // --------------------------------------------------------------------------
+  // Frame
+  // --------------------------------------------------------------------------
+
+  // Frame the region
+  #ifdef DBG_FRAME
+  // For debug purposes, draw a frame around every element
+  gslc_DrawFrameRect(pGui,pElem->rElem,GSLC_COL_GRAY_DK1);
+  #else
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN) {
+    if (pElem->nFeatures & GSLC_ELEM_FEA_ROUND_EN) {
+      gslc_DrawFrameRoundRect(pGui, pElem->rElem, pGui->nRoundRadius, pElem->colElemFrame);
+    } else {
+      gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+    }
+  }
+  #endif
+
+
+  // --------------------------------------------------------------------------
+  // Handle special element types
+  // --------------------------------------------------------------------------
+  if (pElem->nType == GSLC_TYPE_LINE) {
+    gslc_DrawLine(pGui,nElemX,nElemY,nElemX+nElemW-1,nElemY+nElemH-1,pElem->colElemFill);
+  }
+
+
+  // --------------------------------------------------------------------------
+  // Image overlays
+  // --------------------------------------------------------------------------
+
+  // Draw any images associated with element
+  if (pElem->sImgRefNorm.eImgFlags != GSLC_IMGREF_NONE) {
+    if ((bGlowEn && bGlowing) && (pElem->sImgRefGlow.eImgFlags != GSLC_IMGREF_NONE)) {
+      gslc_DrvDrawImage(pGui,nElemX,nElemY,pElem->sImgRefGlow);
+    } else {
+      gslc_DrvDrawImage(pGui,nElemX,nElemY,pElem->sImgRefNorm);
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Text overlays
+  // --------------------------------------------------------------------------
+
+  // Draw text string if defined
+  if (pElem->pStrBuf) {
+    gslc_tsColor  colTxt    = (bGlowNow)? pElem->colElemTextGlow : pElem->colElemText;
+    int8_t        nMarginX  = pElem->nTxtMarginX;
+    int8_t        nMarginY  = pElem->nTxtMarginY;
+
+    gslc_DrawTxtBase(pGui, pElem->pStrBuf, pElem->rElem, pElem->pTxtFont, pElem->eTxtFlags,
+      pElem->eTxtAlign, colTxt, colBg, nMarginX, nMarginY);
+  }
+
+  // --------------------------------------------------------------------------
+
+  // Mark the element as no longer requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+// ------------------------------------------------------------------------
+// Element Update Functions
+// ------------------------------------------------------------------------
+
+void gslc_ElemSetFillEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFillEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bFillEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_FILL_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_FILL_EN;
+  }
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemSetFrameEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFrameEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bFrameEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_FRAME_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_FRAME_EN;
+  }
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetRoundEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bRoundEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bRoundEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_ROUND_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_ROUND_EN;
+  }
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemSetCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrame,gslc_tsColor colFill,gslc_tsColor colFillGlow)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (!gslc_ColorEqual(pElem->colElemFrame, colFrame) ||
+      !gslc_ColorEqual(pElem->colElemFill, colFill) ||
+      !gslc_ColorEqual(pElem->colElemFillGlow, colFillGlow)) {
+    pElem->colElemFrame     = colFrame;
+    pElem->colElemFill      = colFill;
+    pElem->colElemFillGlow  = colFillGlow;
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+}
+
+void gslc_ElemSetGlowCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colFrameGlow,gslc_tsColor colFillGlow,gslc_tsColor colTxtGlow)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (!gslc_ColorEqual(pElem->colElemFrameGlow, colFrameGlow) ||
+      !gslc_ColorEqual(pElem->colElemFillGlow, colFillGlow) ||
+      !gslc_ColorEqual(pElem->colElemTextGlow, colTxtGlow)) {
+    pElem->colElemFrameGlow   = colFrameGlow;
+    pElem->colElemFillGlow    = colFillGlow;
+    pElem->colElemTextGlow    = colTxtGlow;
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+}
+
+void gslc_ElemSetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nGroupId)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->nGroup           = nGroupId;
+}
+
+int gslc_ElemGetGroup(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return GSLC_GROUP_ID_NONE;
+
+  return pElem->nGroup;
+}
+
+void gslc_ElemSetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsRect rElem)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  // Invalidate region including both rects from before & after
+  gslc_InvalidateRgnAdd(pGui, pElem->rElem); // Old region
+  gslc_InvalidateRgnAdd(pGui, rElem); // New region
+  // Force a page redraw within the scope defined by the invalidation region
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  gslc_PageRedrawSet(pGui,true);
+
+  // Update element
+  pElem->rElem           = rElem;
+
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+gslc_tsRect gslc_ElemGetRect(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return (gslc_tsRect){0,0,0,0};
+
+  return pElem->rElem;
+}
+
+
+void gslc_ElemSetTxtAlign(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nAlign)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->eTxtAlign        = nAlign;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetTxtMargin(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned nMargin)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->nTxtMarginX       = nMargin;
+  pElem->nTxtMarginY       = nMargin;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetTxtMarginXY(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int8_t nMarginX,int8_t nMarginY)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->nTxtMarginX       = nMarginX;
+  pElem->nTxtMarginY       = nMarginY;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetTxtStr(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,const char* pStr)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  // Check for read-only status (in case the string was
+  // defined in Flash/PROGMEM)
+  if (pElem->nStrBufMax == 0) {
+    // String was read-only, so abort now
+    return;
+  }
+
+  // To avoid unnecessary redraw / flicker, only a change in
+  // the text content will drive a redraw
+
+  if (strncmp(pElem->pStrBuf,pStr,pElem->nStrBufMax-1)) {
+    strncpy(pElem->pStrBuf,pStr,pElem->nStrBufMax-1);
+    pElem->pStrBuf[pElem->nStrBufMax-1] = '\0';  // Force termination
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+}
+
+char* gslc_ElemGetTxtStr(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return NULL;
+  return pElem->pStrBuf;
+}
+
+void gslc_ElemSetTxtCol(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colVal)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (!gslc_ColorEqual(pElem->colElemText, colVal) ||
+      !gslc_ColorEqual(pElem->colElemTextGlow, colVal)) {
+    pElem->colElemText      = colVal;
+    pElem->colElemTextGlow  = colVal; // Default to same color for glowing state
+    // TODO: Might want to change to GSLC_REDRAW_INC
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+}
+
+void gslc_ElemSetTxtMem(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (GSLC_LOCAL_STR) {
+    if ((eFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+      // ERROR: Unsupported mode
+      // - We don't support internal buffer mode with initialization
+      //   from flash (PROGMEM)
+      GSLC_DEBUG2_PRINT("ERROR: ElemSetTxtMem(%s) GSLC_LOCAL_STR can't be used with GSLC_TXT_MEM_PROG\n","");
+      return;
+    }
+  }
+  gslc_teTxtFlags eFlagsCur = pElem->eTxtFlags;
+  pElem->eTxtFlags = (eFlagsCur & ~GSLC_TXT_MEM) | (eFlags & GSLC_TXT_MEM);
+}
+
+void gslc_ElemSetTxtEnc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teTxtFlags eFlags)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  gslc_teTxtFlags eFlagsCur = pElem->eTxtFlags;
+  pElem->eTxtFlags = (eFlagsCur & ~GSLC_TXT_ENC) | (eFlags & GSLC_TXT_ENC);
+}
+
+void gslc_ElemUpdateFont(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int nFontId)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pTxtFont = gslc_FontGet(pGui,nFontId);
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemSetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemSetRedraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Update the redraw flag
+  gslc_teElemRefFlags eFlags = pElemRef->eElemFlags;
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  switch (eRedraw) {
+    case GSLC_REDRAW_NONE:
+      eFlags = (eFlags & ~GSLC_ELEMREF_REDRAW_MASK) | GSLC_ELEMREF_REDRAW_NONE;
+      break;
+    case GSLC_REDRAW_FULL:
+      eFlags = (eFlags & ~GSLC_ELEMREF_REDRAW_MASK) | GSLC_ELEMREF_REDRAW_FULL;
+      // Mark the region as invalidated
+      // - Only invalidate if the element is visible on the screen
+      if (gslc_ElemGetOnScreen(pGui,pElemRef)) {
+        gslc_InvalidateRgnAdd(pGui, pElem->rElem);
+      }
+      break;
+    case GSLC_REDRAW_INC:
+      eFlags = (eFlags & ~GSLC_ELEMREF_REDRAW_MASK) | GSLC_ELEMREF_REDRAW_INC;
+      // Mark the region as invalidated
+      // - Only invalidate if the element is visible on the screen
+      if (gslc_ElemGetOnScreen(pGui,pElemRef)) {
+        gslc_InvalidateRgnAdd(pGui, pElem->rElem);
+      }
+      break;
+  }
+
+  // Handle request for update of redraw state
+  // - We permit the new state to be assigned except in the
+  //   case wherein we are currently pending a full redraw
+  //   but an incremental redraw has been requested. In that
+  //   case we leave the full redraw request pending.
+  if (eRedraw == GSLC_REDRAW_INC) {
+    if ((eFlags & GSLC_ELEMREF_REDRAW_MASK) == GSLC_ELEMREF_REDRAW_FULL) {
+      // Don't update redraw state; leave it as full redraw pending
+    } else {
+      pElemRef->eElemFlags = eFlags;
+    }
+  } else {
+    pElemRef->eElemFlags = eFlags;
+  }
+
+#if (GSLC_FEATURE_COMPOUND)
+  // In the case of compound elements, optionally propagate the
+  // redraw status up the hierarchy (ie. to the parent element).
+  // - This may be useful in scenarios wherein a sub-element has
+  //   been marked for redraw, but because it has transparency,
+  //   the parent element may need to be redrawn first.
+  // - For now, assume no need to trigger a parent redraw.
+  // - TODO: Consider detecting scenarios in which we should
+  //   propagate the redraw to the parent.
+  if (pElem->pElemRefParent != NULL) {
+    gslc_ElemSetRedraw(pGui,pElem->pElemRefParent,eRedraw);
+  }
+#endif
+}
+
+gslc_teRedrawType gslc_ElemGetRedraw(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemGetRedraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return GSLC_REDRAW_NONE;
+  }
+  gslc_teElemRefFlags eFlags = pElemRef->eElemFlags;
+  switch (eFlags & GSLC_ELEMREF_REDRAW_MASK) {
+    case GSLC_ELEMREF_REDRAW_NONE:
+      return GSLC_REDRAW_NONE;
+    case GSLC_ELEMREF_REDRAW_FULL:
+      return GSLC_REDRAW_FULL;
+    case GSLC_ELEMREF_REDRAW_INC:
+      return GSLC_REDRAW_INC;
+  }
+  // Should not reach here
+  return GSLC_REDRAW_NONE;
+}
+
+void gslc_ElemSetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowing)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemSetGlow";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  // Only change glow state if enabled
+  if (gslc_ElemGetGlowEn(pGui, pElemRef)) {
+    bool bGlowingOld = gslc_ElemGetGlow(pGui, pElemRef);
+    gslc_SetElemRefFlag(pGui, pElemRef, GSLC_ELEMREF_GLOWING, (bGlowing) ? GSLC_ELEMREF_GLOWING : 0);
+
+    if (bGlowing != bGlowingOld) {
+      gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_INC);
+    }
+  }
+}
+
+bool gslc_ElemGetGlow(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemGetGlow";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  return gslc_GetElemRefFlag(pGui,pElemRef,GSLC_ELEMREF_GLOWING);
+}
+
+void gslc_ElemSetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bVisible)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  bool bVisibleOld = gslc_ElemGetVisible(pGui,pElemRef);
+  gslc_SetElemRefFlag(pGui,pElemRef,GSLC_ELEMREF_VISIBLE,(bVisible)?GSLC_ELEMREF_VISIBLE:0);
+
+  // Mark the element as needing redraw if its visibility status changed
+  if (bVisible != bVisibleOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+    if (bVisible == false) {
+      // Since we are hiding an element, we need to invalidate
+      // the region underneath the element, so that it can
+      // be redrawn.
+      gslc_InvalidateRgnAdd(pGui, pElem->rElem);
+      // Mark the page as having a redraw pending
+      gslc_PageRedrawSet(pGui,true);
+     }
+  }
+
+}
+
+bool gslc_ElemGetVisible(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemGetVisible";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  return gslc_GetElemRefFlag(pGui,pElemRef,GSLC_ELEMREF_VISIBLE);
+}
+
+bool gslc_ElemGetOnScreen(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  int16_t nElemId = gslc_ElemGetId(pGui, pElemRef);
+  for (int8_t nStackPage = 0; nStackPage < GSLC_STACK__MAX; nStackPage++) {
+    gslc_tsPage* pStackPage = pGui->apPageStack[nStackPage];
+    if (!pStackPage) {
+      continue;
+    }
+    gslc_tsCollect* pCollect = &pStackPage->sCollect;
+    pElemRef = gslc_CollectFindElemById(pGui, pCollect, nElemId);
+    if (pElemRef) {
+      return gslc_ElemGetVisible(pGui, pElemRef);
+    }
+  }
+  return false;
+}
+
+void gslc_ElemSetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bGlowEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bGlowEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_GLOW_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_GLOW_EN;
+  }
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+bool gslc_ElemGetGlowEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  return pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN;
+}
+
+void gslc_ElemSetClickEn(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bClickEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  if (bClickEn) {
+    pElem->nFeatures |= GSLC_ELEM_FEA_CLICK_EN;
+  } else {
+    pElem->nFeatures &= ~GSLC_ELEM_FEA_CLICK_EN;
+  }
+  // No need to call ElemSetRedraw() as we aren't changing a visual characteristic
+}
+
+void gslc_ElemSetTouchFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_TOUCH funcCb)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pfuncXTouch = funcCb;
+}
+
+
+void gslc_ElemSetStyleFrom(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefSrc,gslc_tsElemRef* pElemRefDest)
+{
+  gslc_tsElem* pElemSrc = gslc_GetElemFromRefD(pGui, pElemRefSrc, __LINE__);
+  gslc_tsElem* pElemDest = gslc_GetElemFromRefD(pGui, pElemRefDest, __LINE__);
+  if ((!pElemSrc) || (!pElemDest)) return;
+
+  // TODO: Check ElemRef SRC type for compatibility
+
+  // nId
+  // nType
+  // rElem
+  pElemDest->nGroup           = pElemSrc->nGroup;
+  pElemDest->nFeatures        = pElemSrc->nFeatures;
+  pElemDest->sImgRefNorm      = pElemSrc->sImgRefNorm;
+  pElemDest->sImgRefGlow      = pElemSrc->sImgRefGlow;
+
+  pElemDest->colElemFill      = pElemSrc->colElemFill;
+  pElemDest->colElemFillGlow  = pElemSrc->colElemFillGlow;
+  pElemDest->colElemFrame     = pElemSrc->colElemFrame;
+  pElemDest->colElemFrameGlow = pElemSrc->colElemFrameGlow;
+
+  // eRedraw
+#ifdef GLSC_COMPOUND
+  pElemDest->pElemRefParent   = pElemSrc->pElemRefParent;
+#endif
+
+  // Don't copy over the text strings
+  //  pStrBuf[GSLC_LOCAL_STR_LEN]
+  //  pStr
+  //  nStrMax
+  //  eTxtFlags
+
+  pElemDest->colElemText      = pElemSrc->colElemText;
+  pElemDest->colElemTextGlow  = pElemSrc->colElemTextGlow;
+  pElemDest->eTxtAlign        = pElemSrc->eTxtAlign;
+  pElemDest->nTxtMarginX      = pElemSrc->nTxtMarginX;
+  pElemDest->nTxtMarginY      = pElemSrc->nTxtMarginY;
+  pElemDest->pTxtFont         = pElemSrc->pTxtFont;
+
+  // pXData
+
+  //pElemDest->pfuncXEvent      = pElemSrc->pfuncXEvent; // UNUSED
+  pElemDest->pfuncXDraw       = pElemSrc->pfuncXDraw;
+  pElemDest->pfuncXTouch      = pElemSrc->pfuncXTouch;
+  pElemDest->pfuncXTick       = pElemSrc->pfuncXTick;
+
+  gslc_ElemSetRedraw(pGui,pElemRefDest,GSLC_REDRAW_FULL);
+}
+
+/* UNUSED
+void gslc_ElemSetEventFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_EVENT funcCb)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pfuncXEvent       = funcCb;
+}
+*/
+
+
+void gslc_ElemSetDrawFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_DRAW funcCb)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pfuncXDraw     = funcCb;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemSetTickFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_TICK funcCb)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  pElem->pfuncXTick       = funcCb;
+}
+
+bool gslc_ElemOwnsCoord(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nX,int16_t nY,bool bOnlyClickEn)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  if (bOnlyClickEn && !(pElem->nFeatures & GSLC_ELEM_FEA_CLICK_EN) ) {
+    return false;
+  }
+  return gslc_IsInRect(nX,nY,pElem->rElem);
+}
+
+#if !defined(DRV_TOUCH_NONE)
+
+// ------------------------------------------------------------------------
+// Tracking Functions
+// ------------------------------------------------------------------------
+
+
+void gslc_CollectInput(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return;
+#else
+  // Fetch the data members of the touch event
+  gslc_teTouch      eTouch    = pEventTouch->eTouch;
+  int16_t           nInputInd = pEventTouch->nX;      // nX overloaded as element index
+  int16_t           nInputVal = pEventTouch->nY;      // nY overloaded as action value
+  gslc_tsElemRef*   pElemIndRef;
+
+  if ((nInputInd >= 0) && (nInputInd < pCollect->nElemRefMax)) {
+    pElemIndRef = &(pCollect->asElemRef[nInputInd]);
+  } else {
+    pElemIndRef = NULL;
+  }
+
+  gslc_tsElemRef*   pTrackedRefOld = NULL;
+  gslc_tsElemRef*   pTrackedRefNew = NULL;
+
+  // Pass zero to callbacks since no actual position
+  int16_t           nX = 0;
+  int16_t           nY = 0;
+
+  // Fetch the item currently being tracked (if any)
+  pTrackedRefOld = gslc_CollectGetElemRefTracked(pGui,pCollect);
+
+  // Reset the in-tracked flag
+  bool  bInTracked = false;
+
+  // For direct input events, eTouch will already be fully defined with DOWN/UP + IN/OUT
+  if (eTouch == GSLC_TOUCH_FOCUS_ON) {
+    // ---------------------------------
+    // Touch Down Event
+    // ---------------------------------
+
+    // End glow on previously tracked element (if any)
+    // - We shouldn't really enter a "Touch Down" event
+    //   with an element still marked as being tracked
+    if (pTrackedRefOld != NULL) {
+      gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+    }
+
+    // Determine the new element to start tracking
+    pTrackedRefNew = pElemIndRef;
+
+    if (pTrackedRefNew == NULL) {
+      // Didn't find an element, so clear the tracking reference
+
+      gslc_CollectSetElemTracked(pGui,pCollect,NULL);
+    } else {
+      // Found an element, so mark it as being the tracked element
+
+      // Set the new tracked element reference
+      gslc_CollectSetElemTracked(pGui,pCollect,pTrackedRefNew);
+      if (pTrackedRefNew->pElem == NULL) {
+        return;
+      }
+
+      // Start glow on new element
+      gslc_ElemSetGlow(pGui,pTrackedRefNew,true);
+
+      // Notify element for optional custom handling
+      // - We do this after we have determined which element should
+      //   receive the touch tracking
+      eTouch = GSLC_TOUCH_DOWN_IN;
+      //gslc_ElemSendEventTouch(pGui,pTrackedRefNew,eTouch,nX,nY);
+
+    }
+
+  } else if ((eTouch == GSLC_TOUCH_FOCUS_OFF) || (eTouch == GSLC_TOUCH_FOCUS_SELECT)) {
+    // ---------------------------------
+    // Touch Up Event
+    // ---------------------------------
+
+    if (pTrackedRefOld != NULL) {
+      // Are we still over tracked element?
+      if (eTouch == GSLC_TOUCH_FOCUS_OFF) {
+        bInTracked = false;
+      } else if (eTouch == GSLC_TOUCH_FOCUS_SELECT) {
+        bInTracked = true;
+      }
+
+      if (!bInTracked) {
+        // Released not over tracked element
+        eTouch = GSLC_TOUCH_UP_OUT;
+        //gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+      } else {
+        // Notify original tracked element for optional custom handling
+        eTouch = GSLC_TOUCH_UP_IN;
+        // FIXME: Do we really want to change the eTouch type here?
+        // Perhaps this is the best way to reuse the existing touch handler in the element
+        nX = 0; // Arbitrary
+        nY = 0; // Arbitrary
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+      }
+
+      // Clear glow state
+      if (pTrackedRefOld->pElem == NULL) {
+        return;
+      }
+      gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+
+    }
+
+    // Clear the element tracking state
+    gslc_CollectSetElemTracked(pGui,pCollect,NULL);
+
+  } else if ((eTouch == GSLC_TOUCH_SET_REL) || (eTouch == GSLC_TOUCH_SET_ABS)) {
+    // ---------------------------------
+    // Element Value Adjust Event
+    // ---------------------------------
+    nX = 0; // Unused
+    nY = nInputVal; // Relative or Absolute value
+    gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+  }
+#endif // GSLC_FEATURE_INPUT
+}
+
+
+void gslc_CollectTouch(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsEventTouch* pEventTouch)
+{
+  // Fetch the data members of the touch event
+  int16_t       nX        = pEventTouch->nX;
+  int16_t       nY        = pEventTouch->nY;
+  gslc_teTouch  eTouch    = pEventTouch->eTouch;
+
+  gslc_tsElemRef*   pTrackedRefOld = NULL;
+  gslc_tsElemRef*   pTrackedRefNew = NULL;
+
+  // Fetch the item currently being tracked (if any)
+  pTrackedRefOld = gslc_CollectGetElemRefTracked(pGui,pCollect);
+
+  // Reset the in-tracked flag
+  bool  bInTracked = false;
+
+  if (eTouch == GSLC_TOUCH_DOWN) {
+    // ---------------------------------
+    // Touch Down Event
+    // ---------------------------------
+
+    // End glow on previously tracked element (if any)
+    // - We shouldn't really enter a "Touch Down" event
+    //   with an element still marked as being tracked
+    if (pTrackedRefOld != NULL) {
+      gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+    }
+
+    // Determine the new element to start tracking
+    pTrackedRefNew = gslc_CollectFindElemFromCoord(pGui,pCollect,nX,nY);
+
+    if (pTrackedRefNew == NULL) {
+      // Didn't find an element, so clear the tracking reference
+      gslc_CollectSetElemTracked(pGui,pCollect,NULL);
+    } else {
+      // Found an element, so mark it as being the tracked element
+
+      // Set the new tracked element reference
+      gslc_CollectSetElemTracked(pGui,pCollect,pTrackedRefNew);
+
+      // Start glow on new element
+      gslc_ElemSetGlow(pGui,pTrackedRefNew,true);
+
+      // Notify element for optional custom handling
+      // - We do this after we have determined which element should
+      //   receive the touch tracking
+      eTouch = GSLC_TOUCH_DOWN_IN;
+      gslc_ElemSendEventTouch(pGui,pTrackedRefNew,eTouch,nX,nY);
+
+    }
+
+  } else if (eTouch == GSLC_TOUCH_UP) {
+    // ---------------------------------
+    // Touch Up Event
+    // ---------------------------------
+
+    if (pTrackedRefOld != NULL) {
+      // Are we still over tracked element?
+      bInTracked = gslc_ElemOwnsCoord(pGui,pTrackedRefOld,nX,nY,true);
+
+      if (!bInTracked) {
+        // Released not over tracked element
+        eTouch = GSLC_TOUCH_UP_OUT;
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+      } else {
+        // Notify original tracked element for optional custom handling
+        eTouch = GSLC_TOUCH_UP_IN;
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+      }
+
+      // Clear glow state
+      gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+
+    }
+
+    // Clear the element tracking state
+    gslc_CollectSetElemTracked(pGui,pCollect,NULL);
+
+  } else if (eTouch == GSLC_TOUCH_MOVE) {
+    // ---------------------------------
+    // Touch Move Event
+    // ---------------------------------
+
+    // Determine if we are still over tracked element
+    if (pTrackedRefOld != NULL) {
+      bInTracked = gslc_ElemOwnsCoord(pGui,pTrackedRefOld,nX,nY,true);
+
+      if (!bInTracked) {
+
+        // Not currently over tracked element
+        // - Notify tracked element that we moved out of it
+        eTouch = GSLC_TOUCH_MOVE_OUT;
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+
+        // Ensure the tracked element is no longer glowing
+        if (pTrackedRefOld) {
+          gslc_ElemSetGlow(pGui,pTrackedRefOld,false);
+        }
+      } else {
+        // We are still over tracked element
+        // - Notify tracked element
+        eTouch = GSLC_TOUCH_MOVE_IN;
+        gslc_ElemSendEventTouch(pGui,pTrackedRefOld,eTouch,nX,nY);
+
+        // Ensure it is glowing
+        gslc_ElemSetGlow(pGui,pTrackedRefOld,true);
+      }
+
+    }
+
+  }
+
+}
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// Helper function for dispatching touch events to sub-components
+bool gslc_CollectTouchCompound(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY, gslc_tsCollect* pCollect)
+{
+  #if defined(DRV_TOUCH_NONE)
+  return false;
+  #else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  // Reset the in/out status of the touch event since
+  // we are now looking for coordinates of a sub-element
+  // rather than the compound element. gslc_CollectTouch()
+  // is responsible for determining in/out status at the
+  // next level down in the element hierarchy.
+  switch (eTouch) {
+  case GSLC_TOUCH_DOWN_IN:
+  case GSLC_TOUCH_DOWN_OUT:
+    eTouch &= ~GSLC_TOUCH_SUBTYPE_MASK;
+    eTouch |= GSLC_TOUCH_DOWN;
+    break;
+  case GSLC_TOUCH_UP_IN:
+  case GSLC_TOUCH_UP_OUT:
+    eTouch &= ~GSLC_TOUCH_SUBTYPE_MASK;
+    eTouch |= GSLC_TOUCH_UP;
+    break;
+  case GSLC_TOUCH_MOVE_IN:
+  case GSLC_TOUCH_MOVE_OUT:
+    eTouch &= ~GSLC_TOUCH_SUBTYPE_MASK;
+    eTouch |= GSLC_TOUCH_MOVE;
+    break;
+  default:
+    break;
+  }
+
+  // Cascade the touch event to the sub-element collection
+  // - Note that we convert to absolute coordinates
+  gslc_tsEventTouch sEventTouch;
+  sEventTouch.nX = pElem->rElem.x + nRelX;
+  sEventTouch.nY = pElem->rElem.y + nRelY;
+  sEventTouch.eTouch = eTouch;
+  gslc_CollectTouch(pGui, pCollect, &sEventTouch);
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+#endif // GSLC_FEATURE_COMPOUND
+
+
+// FIXME: pPage UNUSED with new PageStack implementation
+void gslc_TrackInput(gslc_tsGui* pGui,gslc_tsPage* pPage,gslc_teInputRawEvent eInputEvent,int16_t nInputVal)
+{
+#if !(GSLC_FEATURE_INPUT)
+  GSLC_DEBUG_PRINT("WARNING: GSLC_FEATURE_INPUT not enabled in GUIslice config%s\n", "");
+  return;
+#else
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "TrackInput";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  gslc_tsEventTouch sEventTouch;
+  void*             pvData = (void*)(&sEventTouch);
+  gslc_tsEvent      sEvent;
+  int16_t           nFocusInd = GSLC_IND_NONE;
+  gslc_tsPage*      pFocusPage = NULL;
+  gslc_tsCollect*   pCollect = NULL;
+
+  gslc_teAction     eAction = GSLC_ACTION_NONE;
+  int16_t           nActionVal;
+
+  // Determine the page to accept focus
+  // - For now, use the top enabled page in the stack
+  for (int nStack = 0; nStack < GSLC_STACK__MAX; nStack++) {
+    if (pGui->apPageStack[nStack]) {
+      // Ensure the page layer is active (receiving touch events)
+      if (pGui->abPageStackActive[nStack]) {
+        pFocusPage = pGui->apPageStack[nStack];
+      }
+    }
+  }
+  if (!pFocusPage) {
+    // No pages enabled in the stack, so exit
+    return;
+  }
+
+  gslc_InputMapLookup(pGui,eInputEvent,nInputVal,&eAction,&nActionVal);
+  switch(eAction) {
+    case GSLC_ACTION_FOCUS_PREV:
+    case GSLC_ACTION_FOCUS_NEXT:
+
+      // Unfocus old element
+      sEventTouch.eTouch = GSLC_TOUCH_FOCUS_OFF;
+      sEventTouch.nX = GSLC_IND_NONE;
+      sEventTouch.nY = 0; // Unused
+
+      sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+      gslc_PageEvent(pGui,sEvent);
+
+      // Focus on new element
+      bool bStepNext = (eAction == GSLC_ACTION_FOCUS_NEXT);
+      nFocusInd = gslc_PageFocusStep(pGui,pFocusPage,bStepNext);
+      if (nFocusInd == GSLC_IND_NONE) {
+        break;
+      }
+      sEventTouch.eTouch = GSLC_TOUCH_FOCUS_ON;
+      sEventTouch.nX = nFocusInd;
+      sEventTouch.nY = 0; // Unused
+
+      sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+      gslc_PageEvent(pGui,sEvent);
+
+      break;
+
+    case GSLC_ACTION_SELECT:
+
+      pCollect = &pFocusPage->sCollect;
+      nFocusInd = gslc_CollectGetFocus(pGui, pCollect);
+
+      // Ensure an element is in focus!
+      if (nFocusInd == GSLC_IND_NONE) {
+        break;
+      } else {
+        // Select currently focused element
+        sEventTouch.eTouch = GSLC_TOUCH_FOCUS_SELECT;
+        sEventTouch.nX = nFocusInd;
+        sEventTouch.nY = 0; // Unused
+        sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+        gslc_PageEvent(pGui,sEvent);
+
+        // Reapply focus to current element
+        sEventTouch.eTouch = GSLC_TOUCH_FOCUS_ON;
+        sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+        gslc_PageEvent(pGui,sEvent);
+      }
+
+      break;
+
+    case GSLC_ACTION_SET_REL:
+    case GSLC_ACTION_SET_ABS:
+
+      pCollect = &pFocusPage->sCollect;
+      nFocusInd = gslc_CollectGetFocus(pGui, pCollect);
+
+      // Ensure an element is in focus!
+      if (nFocusInd == GSLC_IND_NONE) {
+        break;
+      } else {
+        // Change current element
+        if (eAction == GSLC_ACTION_SET_REL) {
+          sEventTouch.eTouch = GSLC_TOUCH_SET_REL;
+          sEventTouch.nX = 0; // Unused
+          sEventTouch.nY = nActionVal;
+        } else {
+          sEventTouch.eTouch = GSLC_TOUCH_SET_ABS;
+          sEventTouch.nX = 0; // Unused
+          sEventTouch.nY = nActionVal;
+        }
+
+        sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pFocusPage,pvData);
+        gslc_PageEvent(pGui,sEvent);
+      }
+      break;
+
+    case GSLC_ACTION_UNDEF:
+      // ERROR: unknown action
+      break;
+
+    default:
+      // No action mapped
+      break;
+  }
+#endif // GSLC_FEATURE_INPUT
+}
+
+// This routine is responsible for the GUI-level touch event state machine
+// and dispatching to the touch event handler for the page
+// FIXME: pPage UNUSED with new PageStack implementation
+void gslc_TrackTouch(gslc_tsGui* pGui,gslc_tsPage* pPage,int16_t nX,int16_t nY,uint16_t nPress)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "TrackTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Determine the transitions in the touch events based
+  // on the previous touch pressure state
+  // TODO: Provide hysteresis thresholds for the touch
+  //       pressure levels in case a display outputs a
+  //       variable range (eg. 15..200) that doesn't
+  //       go to zero when touch is removed.
+  gslc_teTouch  eTouch = GSLC_TOUCH_NONE;
+  if ((pGui->nTouchLastPress == 0) && (nPress > 0)) {
+    eTouch = GSLC_TOUCH_DOWN;
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("Trk: (%3d,%3d) P=%3u : TouchDown\n\n",nX,nY,nPress);
+    #endif
+  } else if ((pGui->nTouchLastPress > 0) && (nPress == 0)) {
+    eTouch = GSLC_TOUCH_UP;
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("Trk: (%3d,%3d) P=%3u : TouchUp\n\n",nX,nY,nPress);
+    #endif
+
+  } else if ((pGui->nTouchLastX != nX) || (pGui->nTouchLastY != nY)) {
+    // We only track movement if touch is "down"
+    if (nPress > 0) {
+      eTouch = GSLC_TOUCH_MOVE;
+      #ifdef DBG_TOUCH
+      GSLC_DEBUG_PRINT("Trk: (%3d,%3d) P=%3u : TouchMove\n\n",nX,nY,nPress);
+      #endif
+    }
+  }
+
+  gslc_tsEventTouch sEventTouch;
+  sEventTouch.eTouch        = eTouch;
+
+  // Save the coordinates from the touch driver
+  // NOTE: Many display touch drivers return valid coordinates upon a
+  //       TOUCH_UP event, whereas some return zero position coordinates in
+  //       this event (eg. TFT_eSPI with ILI9486). Thus, to ensure that we
+  //       have consistent detection of position when the touch is released,
+  //       we will pass the previous good position in this event (transition
+  //       from TOUCH_DOWN to TOUCH_UP).
+  //
+  //       The position during the TOUCH_UP event is used to determine if a
+  //       touch was released within an element (causing a button selection)
+  //       or outside of it (generally leading to a non-selection).
+  //
+  if (eTouch == GSLC_TOUCH_UP) {
+    // Use previous (good) coordinates from touch driver
+    sEventTouch.nX          = pGui->nTouchLastX;
+    sEventTouch.nY          = pGui->nTouchLastY;
+  } else {
+    // Use most recent coordinate from touch driver
+    sEventTouch.nX          = nX;
+    sEventTouch.nY          = nY;
+  }
+
+  void* pvData = (void*)(&sEventTouch);
+  gslc_tsEvent sEvent;
+
+  // Generate touch page event for any enabled pages in the stack
+  for (unsigned nStack = 0; nStack < GSLC_STACK__MAX; nStack++) {
+    gslc_tsPage* pStackPage = pGui->apPageStack[nStack];
+    if (pStackPage) {
+      // Ensure the page layer is active (receiving touch events)
+      if (pGui->abPageStackActive[nStack]) {
+        sEvent = gslc_EventCreate(pGui, GSLC_EVT_TOUCH, 0, (void*)pStackPage, pvData);
+        gslc_PageEvent(pGui, sEvent);
+      }
+    }
+  }
+
+
+  // Save raw touch status so that we can detect transitions
+  pGui->nTouchLastX      = nX;
+  pGui->nTouchLastY      = nY;
+  pGui->nTouchLastPress  = nPress;
+}
+
+
+
+// ------------------------------------------------------------------------
+// Touchscreen Functions
+// ------------------------------------------------------------------------
+
+bool gslc_InitTouch(gslc_tsGui* pGui,const char* acDev)
+{
+  bool bOk;
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "InitTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Call driver-specific touchscreen init
+  //
+  // Determine if touch events are provided by the display driver
+  // or an external touch driver.
+#if defined(DRV_TOUCH_NONE)
+  // Touch handling disabled
+  bOk = true;
+#elif defined(DRV_TOUCH_IN_DISP)
+  // Touch handling by display driver
+  bOk = gslc_DrvInitTouch(pGui,acDev);
+#else
+  // Touch handling by external touch driver
+  bOk = gslc_TDrvInitTouch(pGui,acDev);
+#endif
+  if (!bOk) {
+    GSLC_DEBUG2_PRINT("ERROR: InitTouch() failed in touch driver init\n",0);
+  }
+  return bOk;
+}
+
+
+bool gslc_GetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "GetTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  *peInputEvent = GSLC_INPUT_NONE;
+  *pnInputVal   = 0;
+
+#if defined(DRV_TOUCH_NONE)
+  // Touch handling disabled
+  return false;
+#elif defined(DRV_TOUCH_IN_DISP)
+  // Use display driver for touch events
+  return gslc_DrvGetTouch(pGui,pnX,pnY,pnPress,peInputEvent,pnInputVal);
+#else
+  // Use external touch driver for touch events
+  return gslc_TDrvGetTouch(pGui,pnX,pnY,pnPress,peInputEvent,pnInputVal);
+#endif
+
+  return false;
+}
+
+
+void gslc_SetTouchRemapEn(gslc_tsGui* pGui, bool bEn)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "SetTouchRemapEn";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return;
+  }
+  pGui->bTouchRemapEn = bEn;
+}
+
+void gslc_SetTouchRemapCal(gslc_tsGui* pGui,uint16_t nXMin, uint16_t nXMax, uint16_t nYMin, uint16_t nYMax)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "SetTouchRemapCal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return;
+  }
+  pGui->nTouchCalXMin = nXMin;
+  pGui->nTouchCalXMax = nXMax;
+  pGui->nTouchCalYMin = nYMin;
+  pGui->nTouchCalYMax = nYMax;
+}
+
+void gslc_SetTouchRemapYX(gslc_tsGui* pGui, bool bSwap)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "SetTouchRemapYX";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return;
+  }
+  pGui->bTouchRemapYX = bSwap;
+}
+
+
+#endif // !DRV_TOUCH_NONE
+
+// ------------------------------------------------------------------------
+// Private Functions
+// ------------------------------------------------------------------------
+
+
+// NOTE: nId is a positive ID specified by the user or
+//       GSLC_ID_AUTO if the user wants an auto-generated ID
+//       (which will be assigned in Element nId)
+#if (GSLC_FEATURE_COMPOUND)
+// NOTE: When we are creating sub-elements within a compound element,
+//       we usually pass nPageId=GSLC_PAGE_NONE. In this mode we
+//       won't add the element to any page, but just create the
+//       element struct. However, in this mode we can't support
+//       auto-generated IDs since we don't know which IDs will
+//       be taken when we finally create the compound element.
+#endif
+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_tsElem sElem;
+  // Assign defaults to the element record
+  gslc_ResetElem(&sElem);
+
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return sElem;
+  }
+
+  gslc_tsPage*    pPage = NULL;
+  gslc_tsCollect* pCollect = NULL;
+
+  // If we are going to be adding the element to a page then we
+  // perform some additional checks
+  if (nPageId == GSLC_PAGE_NONE) {
+#if (GSLC_FEATURE_COMPOUND)
+    // This is a temporary element, so we skip the ID collision checks.
+    // In this mode we don't support auto ID assignment
+    if (nElemId == GSLC_ID_AUTO) {
+      GSLC_DEBUG2_PRINT("ERROR: ElemCreate(%s) doesn't support temp elements with auto ID\n","");
+      return sElem;
+    }
+#endif
+  } else {
+    // Look up the targeted page to ensure that we check its
+    // collection for collision with other IDs (or assign the
+    // next available if auto-incremented)
+    pPage = gslc_PageFindById(pGui,nPageId);
+    if (pPage == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: ElemCreate() can't find page (ID=%d)\n",nPageId);
+      return sElem;
+    }
+    pCollect  = &pPage->sCollect;
+
+    // Validate the user-supplied ID
+    if (nElemId == GSLC_ID_AUTO) {
+      // Get next auto-generated ID
+      nElemId = gslc_CollectGetNextId(pGui,pCollect);
+    } else {
+      // Ensure the ID is positive
+      if (nElemId < 0) {
+        GSLC_DEBUG2_PRINT("ERROR: ElemCreate() called with negative ID (%d)\n",nElemId);
+        return sElem;
+      }
+      // Ensure the ID isn't already taken
+      if (gslc_CollectFindElemById(pGui,pCollect,nElemId) != NULL) {
+        GSLC_DEBUG2_PRINT("ERROR: ElemCreate() called with existing ID (%d)\n",nElemId);
+        return sElem;
+      }
+    }
+  }
+
+
+  // Override defaults with parameterization
+  sElem.nId             = nElemId;
+  sElem.rElem           = rElem;
+  sElem.nType           = nType;
+  sElem.pTxtFont        = gslc_FontGet(pGui,nFontId);
+
+  // Initialize the local string buffer (if enabled via GSLC_LOCAL_STR)
+  // otherwise just save a copy of the external string buffer pointer
+  // and maximum buffer length from the parameters.
+  //
+  // NOTE: GSLC_LOCAL_STR=1 mode does not accept string pointers to
+  //       PROGMEM (Flash). This is because at time of ElemCreate()
+  //       the string location (SRAM vs PROGMEM) won't be known (as
+  //       ElemSetTxtMem() has not been called yet). Therefore, we
+  //       wouldn't know to perform a copy from PROGMEM. This should not
+  //       be a problem since it would be unlikely that a user would
+  //       want to use internal buffers but initialized by content in
+  //       flash.
+  if (pStrBuf == NULL) {
+    // No string enabled, so set the flag accordingly
+    sElem.nStrBufMax = 0;
+    sElem.eTxtFlags  = (sElem.eTxtFlags & ~GSLC_TXT_ALLOC) | GSLC_TXT_ALLOC_NONE;
+  } else {
+    #if (GSLC_LOCAL_STR)
+      // NOTE: Assume the string buffer pointer is located in RAM and not PROGMEM
+      strncpy(sElem.pStrBuf,pStrBuf,GSLC_LOCAL_STR_LEN-1);
+      sElem.pStrBuf[GSLC_LOCAL_STR_LEN-1] = '\0';  // Force termination
+      sElem.nStrBufMax = GSLC_LOCAL_STR_LEN;
+      sElem.eTxtFlags  = (sElem.eTxtFlags & ~GSLC_TXT_ALLOC) | GSLC_TXT_ALLOC_INT;
+    #else
+      // No need to copy locally; instead, we are going to retain
+      // the external string pointer (must be static)
+      sElem.pStrBuf    = pStrBuf;
+      sElem.nStrBufMax = nStrBufMax;
+      sElem.eTxtFlags  = (sElem.eTxtFlags & ~GSLC_TXT_ALLOC) | GSLC_TXT_ALLOC_EXT;
+    #endif
+  }
+
+  // If the element creation was successful, then set the valid flag
+  sElem.nFeatures      |= GSLC_ELEM_FEA_VALID;
+
+  return sElem;
+}
+
+// ------------------------------------------------------------------------
+// Collect Event Handlers
+// ------------------------------------------------------------------------
+
+
+// Common event handler
+bool gslc_CollectEvent(void* pvGui,gslc_tsEvent sEvent)
+{
+  if (pvGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectEvent";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  void*           pvScope   = sEvent.pvScope;
+  gslc_tsCollect* pCollect  = (gslc_tsCollect*)(pvScope);
+
+  unsigned        nInd;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Handle any collection-based events first
+  // ...
+  if (sEvent.eType == GSLC_EVT_TOUCH) {
+
+    #if defined(DRV_TOUCH_NONE)
+    return false;
+    #else
+    gslc_tsGui*     pGui      = (gslc_tsGui*)(pvGui);
+    void*           pvData    = sEvent.pvData;
+    // TOUCH is passed to CollectTouch which determines the element
+    // in the collection that should receive the event
+    gslc_tsEventTouch*  pEventTouch = (gslc_tsEventTouch*)(pvData);
+    gslc_teTouch        eTouch      = pEventTouch->eTouch;
+
+    if ((eTouch & GSLC_TOUCH_TYPE_MASK) == GSLC_TOUCH_COORD) {
+      gslc_CollectTouch(pGui,pCollect,pEventTouch);
+    } else if ((eTouch & GSLC_TOUCH_TYPE_MASK) == GSLC_TOUCH_DIRECT) {
+      gslc_CollectInput(pGui,pCollect,pEventTouch);
+    } else {
+      // FAIL
+    }
+    return true;
+    #endif  // !DRV_TOUCH_NONE
+
+  } else if ( (sEvent.eType == GSLC_EVT_DRAW) || (sEvent.eType == GSLC_EVT_TICK) ) {
+    // DRAW and TICK are propagated down to all elements in collection
+
+    for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+      pElemRef = &(pCollect->asElemRef[nInd]);
+
+      // Copy event so we can modify it in the loop
+      gslc_tsEvent sEventNew = sEvent;
+      sEventNew.pvScope = (void*)(pElemRef);
+
+      // Propagate the event to the element
+      gslc_ElemEvent(pvGui,sEventNew);
+
+    } // nInd
+
+  } // eType
+
+  return true;
+}
+
+
+// NOTE:
+// - When eFlags=GSLC_ELEMREF_SRC_RAM, the contents of pElem are copied into
+//   the internal element array so that the pointer (pElem) can be released
+//   after this call (ie. it can be an automatic variable).
+// - When eFlags=GSLC_ELEMREF_SRC_PROG, the pointer value pElem is saved
+//   into the element reference array so that the element can be fetched
+//   directly from PROGMEM (Flash) at a later time. In this mode, pElem
+//   must be a static variable.
+// - When eFlags=GSLC_ELEMREF_SRC_CONST, the same is done as for
+//   GSLC_ELEMREF_SRC_PROG except that PROGMEM is not required to access.
+gslc_tsElemRef* gslc_CollectElemAdd(gslc_tsGui* pGui,gslc_tsCollect* pCollect,const gslc_tsElem* pElem,gslc_teElemRefFlags eFlags)
+{
+  if ((pCollect == NULL) || (pElem == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectElemAdd";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+
+  if (pCollect->nElemRefCnt+1 > (pCollect->nElemRefMax)) {
+    GSLC_DEBUG2_PRINT("ERROR: CollectElemAdd() too many element references (%d/%d)\n",
+            pCollect->nElemRefCnt+1,pCollect->nElemRefMax);
+    return NULL;
+  }
+
+  // TODO: Determine way of reporting compound elements in debug messages
+
+  // If the element is stored in RAM:
+  // - Copy the element into the internal RAM element array (asElem)
+  // - Create an entry in the element reference array (asElemRef) that points
+  //   to the internal RAM element array.
+  // - Since a copy has been made of the input element, the caller can
+  //   discard/reuse the pointer (pElem) after the call.
+  //
+  // If the element is stored in FLASH:
+  // - Save the element pointer (pElem) into the element reference
+  //   array (asElemRef).
+  // - Since the input pointer (pElem) has been recorded, the caller must
+  //   not discard/reuse the pointer. It should be defined as a static
+  //   variable.
+
+  uint16_t nElemInd;
+  uint16_t nElemRefInd;
+
+  if ((eFlags & GSLC_ELEMREF_SRC) == GSLC_ELEMREF_SRC_RAM) {
+
+    #if defined(DBG_LOG)
+    GSLC_DEBUG_PRINT("INFO:   Add elem to collection: ElemRef=%d/%d, ElemRAM=%d/%d, ElemId=%u (RAM)\n",
+            pCollect->nElemRefCnt+1,pCollect->nElemRefMax,pCollect->nElemCnt+1,pCollect->nElemMax,pElem->nId);
+    #endif
+
+    // Ensure we have enough space in internal element array
+    if (pCollect->nElemCnt+1 > (pCollect->nElemMax)) {
+      GSLC_DEBUG2_PRINT("ERROR: CollectElemAdd() too many RAM elements (%d/%d), ElemID=%d\n",
+              pCollect->nElemCnt+1,pCollect->nElemMax,pElem->nId);
+      // TODO: Implement a function that returns the current page's ID so that
+      //       users can more easily identify the problematic page.
+      return NULL;
+    }
+
+    // Copy the element to the internal array
+    // - This performs a copy so that we can discard the element
+    //   pointer after the call is complete
+    nElemInd = pCollect->nElemCnt;
+    pCollect->asElem[nElemInd] = *pElem;
+    pCollect->nElemCnt++;
+
+    // Add a reference
+    // - Pointer (pElem) links to an item of internal element array
+    nElemRefInd = pCollect->nElemRefCnt;
+    pCollect->asElemRef[nElemRefInd].eElemFlags = eFlags;
+    pCollect->asElemRef[nElemRefInd].pElem = &(pCollect->asElem[nElemInd]);
+    pCollect->nElemRefCnt++;
+
+  } else {
+    // External reference
+    // - Pointer (pElem) links to an element stored in FLASH (must be declared statically)
+
+    // Fetch a RAM copy of the FLASH element
+    #if (GSLC_USE_PROGMEM)
+    memcpy_P(&pGui->sElemTmpProg,pElem,sizeof(gslc_tsElem));
+    #endif
+
+    #if defined(DBG_LOG)
+      const gslc_tsElem* pElemRam = pElem; // Local element in RAM
+      #if (GSLC_USE_PROGMEM)
+        pElemRam = &pGui->sElemTmpProg;
+      #endif
+    GSLC_DEBUG_PRINT("INFO:   Add elem to collection: ElemRef=%d/%d, ElemId=%u (FLASH)\n",
+            pCollect->nElemRefCnt+1,pCollect->nElemRefMax,pElemRam->nId);
+    #endif
+
+    // Add a reference
+    nElemRefInd = pCollect->nElemRefCnt;
+    pCollect->asElemRef[nElemRefInd].eElemFlags = eFlags;
+    pCollect->asElemRef[nElemRefInd].pElem = (gslc_tsElem*)pElem;  // Typecast to drop const modifier
+    pCollect->nElemRefCnt++;
+  }
+
+  // Fetch a pointer to the element reference array entry
+  gslc_tsElemRef* pElemRef = &(pCollect->asElemRef[nElemRefInd]);
+
+  // Mark any newly added element as requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+  // Return the new element reference
+  return pElemRef;
+}
+
+bool gslc_CollectGetRedraw(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  if (pCollect == NULL) {
+    // ERROR
+    return false;
+  }
+  // Determine if any sub-element in collection needs redraw
+  // - This is generally used when deciding whether to redraw
+  //   a compound element
+  uint16_t        nInd;
+  gslc_tsElemRef* pSubElemRef;
+  bool            bCollectRedraw = false;
+
+  for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+    // Fetch the element pointer from the reference array
+    pSubElemRef = &(pCollect->asElemRef[nInd]);
+    if (gslc_ElemGetRedraw(pGui,pSubElemRef) != GSLC_REDRAW_NONE) {
+      bCollectRedraw = true;
+      break;
+    }
+  }
+
+  return bCollectRedraw;
+}
+
+// Add an element to the collection associated with the page
+//
+// - Depending on the GSLC_ELEMREF_SRC_* setting, CollectElemAdd()
+//   may either copy the contents of the element into the internal
+//   RAM array or else just save a copy of the pointer (which
+//   would mean that the pointer must not be invalidated).
+gslc_tsElemRef* gslc_ElemAdd(gslc_tsGui* pGui,int16_t nPageId,gslc_tsElem* pElem,gslc_teElemRefFlags eFlags)
+{
+  if ((pGui == NULL) || (pElem == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemAdd";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+
+  if (nPageId == GSLC_PAGE_NONE) {
+    // No page ID was provided, so skip add
+    GSLC_DEBUG2_PRINT("ERROR: ElemAdd(%s) with PAGE_NONE\n","");
+    return NULL;
+  }
+
+  // Fetch the page containing the item
+  gslc_tsPage* pPage = gslc_PageFindById(pGui,nPageId);
+  if (pPage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemAdd() page (ID=%d) was not found\n",nPageId);
+    return NULL;
+  }
+
+  #if defined(DBG_LOG)
+  // TODO: Determine way of reporting compound elements in debug messages
+  GSLC_DEBUG_PRINT("INFO: Add elem to PageID=%d: ElemID=%d Rect=(X=%d,Y=%d,W=%d,H=%d)\n",
+    nPageId,pElem->nId,pElem->rElem.x,pElem->rElem.y,pElem->rElem.w,pElem->rElem.h);
+  #endif
+
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+  gslc_tsElemRef* pElemRefAdd = gslc_CollectElemAdd(pGui,pCollect,pElem,eFlags);
+
+  // Fetch access to the element from the reference
+  // - This also handles the case with elements in FLASH
+  gslc_tsElem* pElemLocal = NULL;
+  pElemLocal = gslc_GetElemFromRef(pGui,pElemRefAdd);
+
+  // Update the page's bounding rect
+  gslc_UnionRect(&(pPage->rBounds), pElemLocal->rElem);
+
+  return pElemRefAdd;
+}
+
+bool gslc_SetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // Update the drawing clip rectangle
+  if (pRect == NULL) {
+    // Set to full size of screen
+    return gslc_DrvSetClipRect(pGui,NULL);
+  } else {
+    // Set to user-specified region
+    return gslc_DrvSetClipRect(pGui,pRect);
+  }
+}
+
+
+void gslc_ElemSetImage(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsImgRef sImgRef,
+  gslc_tsImgRef sImgRefSel)
+{
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return;
+
+  // Update the normal and glowing images
+  gslc_DrvSetElemImageNorm(pGui,pElem,sImgRef);
+  gslc_DrvSetElemImageGlow(pGui,pElem,sImgRefSel);
+
+  // Mark as needing redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+bool gslc_SetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  if (!gslc_DrvSetBkgndImage(pGui,sImgRef)) {
+    return false;
+  }
+  gslc_PageFlipSet(pGui,true);
+  return true;
+}
+
+bool gslc_SetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (!gslc_DrvSetBkgndColor(pGui,nCol)) {
+    return false;
+  }
+  gslc_PageFlipSet(pGui,true);
+  return true;
+}
+
+bool gslc_SetTransparentColor(gslc_tsGui* pGui, gslc_tsColor nCol)
+{
+  pGui->sTransCol = nCol;
+  return true;
+}
+
+bool gslc_GuiRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  // Simple wrapper for driver-specific rotation
+  bool bOk = gslc_DrvRotate(pGui,nRotation);
+
+  // Invalidate the new screen dimensions
+  gslc_InvalidateRgnScreen(pGui);
+
+  return bOk;
+}
+
+// Trigger a touch event on an element
+bool gslc_ElemSendEventTouch(gslc_tsGui* pGui,gslc_tsElemRef* pElemRefTracked,
+        gslc_teTouch eTouch,int16_t nX,int16_t nY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  gslc_tsEventTouch sEventTouch;
+  sEventTouch.eTouch        = eTouch;
+  sEventTouch.nX            = nX;
+  sEventTouch.nY            = nY;
+  gslc_tsEvent sEvent = gslc_EventCreate(pGui,GSLC_EVT_TOUCH,0,(void*)pElemRefTracked,&sEventTouch);
+  gslc_ElemEvent((void*)pGui,sEvent);
+  return true;
+#endif // !DRV_TOUCH_NONE
+}
+
+// Initialize the element struct to all zeros
+void gslc_ResetElem(gslc_tsElem* pElem)
+{
+  if (pElem == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ResetElem";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pElem->nFeatures        = GSLC_ELEM_FEA_NONE;
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_VALID; // Init with Valid=false
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_CLICK_EN;
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_GLOW_EN;
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_FRAME_EN;
+  pElem->nFeatures       &= ~GSLC_ELEM_FEA_FILL_EN;
+  pElem->nId              = GSLC_ID_NONE;
+  pElem->nType            = GSLC_TYPE_BOX;
+  pElem->nGroup           = GSLC_GROUP_ID_NONE;
+  pElem->rElem            = (gslc_tsRect){0,0,0,0};
+  pElem->sImgRefNorm      = gslc_ResetImage();
+  pElem->sImgRefGlow      = gslc_ResetImage();
+  pElem->colElemFrame     = GSLC_COL_WHITE;
+  pElem->colElemFill      = GSLC_COL_WHITE;
+  pElem->colElemFrameGlow = GSLC_COL_WHITE;
+  pElem->colElemFillGlow  = GSLC_COL_WHITE;
+  pElem->eTxtFlags        = GSLC_TXT_DEFAULT;
+  #if (GSLC_LOCAL_STR)
+    pElem->pStrBuf[0]       = '\0';
+    pElem->nStrBufMax       = 0;
+  #else
+    pElem->pStrBuf          = NULL;
+    pElem->nStrBufMax       = 0;
+  #endif
+  pElem->colElemText      = GSLC_COL_WHITE;
+  pElem->colElemTextGlow  = GSLC_COL_WHITE;
+  pElem->eTxtAlign        = GSLC_ALIGN_MID_MID;
+  pElem->nTxtMarginX      = 0;
+  pElem->nTxtMarginY      = 0;
+  pElem->pTxtFont         = NULL;
+
+  pElem->pXData           = NULL;
+  pElem->pfuncXEvent      = NULL; // UNUSED
+  pElem->pfuncXDraw       = NULL;
+  pElem->pfuncXTouch      = NULL;
+  pElem->pfuncXTick       = NULL;
+#if (GSLC_FEATURE_COMPOUND)
+  pElem->pElemRefParent   = NULL;
+#endif
+
+}
+
+// Initialize the font struct to all zeros
+void gslc_ResetFont(gslc_tsFont* pFont)
+{
+  if (pFont == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ResetFont";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pFont->nId            = GSLC_FONT_NONE;
+  pFont->eFontRefType   = GSLC_FONTREF_FNAME;
+  pFont->eFontRefMode   = GSLC_FONTREF_MODE_DEFAULT;
+  pFont->pvFont         = NULL;
+  pFont->nSize          = 0;
+}
+
+
+// Close down an element
+void gslc_ElemDestruct(gslc_tsElem* pElem)
+{
+  if (pElem == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemDestruct";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  if (pElem->sImgRefNorm.pvImgRaw != NULL) {
+    gslc_DrvImageDestruct(pElem->sImgRefNorm.pvImgRaw);
+    pElem->sImgRefNorm = gslc_ResetImage();
+  }
+  if (pElem->sImgRefGlow.pvImgRaw != NULL) {
+    gslc_DrvImageDestruct(pElem->sImgRefGlow.pvImgRaw);
+    pElem->sImgRefGlow = gslc_ResetImage();
+  }
+
+  // TODO: Mark Element valid as false?
+
+  // TODO: Add callback function so that
+  // we can support additional closure actions
+  // (eg. closing sub-elements of compound element).
+
+}
+
+
+// Close down a collection
+void gslc_CollectDestruct(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  if (pCollect == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectDestruct";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  uint16_t      nInd;
+  gslc_tsElem*  pElem = NULL;
+
+  for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+    gslc_tsElemRef*     pElemRef = &pCollect->asElemRef[nInd];
+    gslc_teElemRefFlags eFlags = pElemRef->eElemFlags;
+    // Only elements in RAM need destruction
+    if ((eFlags & GSLC_ELEMREF_SRC) != GSLC_ELEMREF_SRC_RAM) {
+      continue;
+    }
+    // Fetch the element pointer from the reference array
+    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+    gslc_ElemDestruct(pElem);
+  }
+  pCollect->nElemRefCnt = 0;
+  pCollect->nElemCnt = 0;
+
+}
+
+// Close down all in page
+void gslc_PageDestruct(gslc_tsGui* pGui,gslc_tsPage* pPage)
+{
+  if (pPage == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "PageDestruct";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+  gslc_CollectDestruct(pGui,pCollect);
+}
+
+// Close down all GUI members, including pages and fonts
+void gslc_GuiDestruct(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "GuiDestruct";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  // Loop through all pages in GUI
+  uint8_t nPageInd;
+  gslc_tsPage*  pPage = NULL;
+  for (nPageInd=0;nPageInd<pGui->nPageCnt;nPageInd++) {
+    pPage = &pGui->asPage[nPageInd];
+    gslc_PageDestruct(pGui,pPage);
+  }
+  pGui->nPageCnt = 0;
+
+  // TODO: Consider moving into main element array
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  // Close all fonts
+  gslc_DrvFontsDestruct(pGui);
+
+  // Close any driver-specific data
+  gslc_DrvDestruct(pGui);
+
+}
+
+
+// ================================
+// Private: Element Collection
+
+void gslc_CollectReset(gslc_tsCollect* pCollect,gslc_tsElem* asElem,uint16_t nElemMax,
+        gslc_tsElemRef* asElemRef,uint16_t nElemRefMax)
+{
+  if (pCollect == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectReset";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  pCollect->nElemMax          = nElemMax;
+  pCollect->nElemCnt          = 0;
+
+  pCollect->nElemAutoIdNext   = GSLC_ID_AUTO_BASE;
+
+  //pCollect->pfuncXEvent       = NULL; // UNUSED
+
+  // Save the pointer to the element array
+  pCollect->asElem = asElem;
+
+  uint16_t nInd;
+  for (nInd=0;nInd<nElemMax;nInd++) {
+    gslc_ResetElem(&(pCollect->asElem[nInd]));
+  }
+
+  // Initialize element references
+  pCollect->nElemRefMax = nElemRefMax;
+  pCollect->nElemRefCnt = 0;
+  pCollect->asElemRef   = asElemRef;
+  for (nInd=0;nInd<nElemMax;nInd++) {
+    (pCollect->asElemRef[nInd]).pElem = NULL;
+  }
+
+  // Reset touch / input tracking
+  pCollect->pElemRefTracked = NULL;
+  pCollect->nElemIndFocused = GSLC_IND_NONE;
+}
+
+
+bool gslc_CollectFindFocusStep(gslc_tsGui* pGui,gslc_tsCollect* pCollect,bool bNext,bool* pbWrapped,int16_t* pnElemInd)
+{
+#if !(GSLC_FEATURE_INPUT)
+  return false;
+#else
+  gslc_tsElemRef*   pElemRef = NULL;
+  gslc_tsElem*      pElem = NULL;
+  int16_t           nIndStart;
+  bool              bFound = false;
+  unsigned          nElemIndCnt = pCollect->nElemRefCnt;
+  int16_t           nIndStep;
+  int16_t           nInd;
+  int16_t           nIndFocus = GSLC_IND_NONE;
+  bool              bCanFocus;
+
+  *pbWrapped = false;
+  *pnElemInd = GSLC_IND_NONE;
+
+  nIndFocus = gslc_CollectGetFocus(pGui, pCollect);
+  if (nIndFocus == GSLC_IND_NONE) {
+    nIndStart = (bNext) ? 0 : (nElemIndCnt - 1);
+  } else {
+    nIndStart = (bNext) ? (nIndFocus + 1) : (nIndFocus - 1);
+  }
+
+  for (nIndStep=0;((!bFound)&&(nIndStep<nElemIndCnt));nIndStep++) {
+    if (bNext) {
+      nInd = nIndStep + nIndStart;
+      // Detect wrap
+      if (nInd >= nElemIndCnt) {
+        *pbWrapped = true;
+        nInd -= nElemIndCnt;
+      }
+    } else {
+      nInd = nIndStart - nIndStep;
+      // Detect wrap
+      if (nInd < 0) {
+        *pbWrapped = true;
+        nInd += nElemIndCnt;
+      }
+    }
+
+    // Get focus capability attribute
+    bCanFocus = false;
+    pElemRef = &(pCollect->asElemRef[nInd]);
+    pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+    if (pElemRef->eElemFlags != GSLC_ELEMREF_NONE) {
+      if (pElem == NULL) {
+        GSLC_DEBUG2_PRINT("ERROR: eElemFlags not none, but pElem is NULL%s\n","");
+        exit(1); // FATAL
+      } else {
+        // Check the "click enable" flag
+        if (pElem->nFeatures & GSLC_ELEM_FEA_CLICK_EN) {
+          bCanFocus = true;
+        }
+      }
+    }
+
+
+    if (bCanFocus) {
+      bFound = true;
+    }
+  }
+
+  if (bFound) {
+    *pnElemInd = nInd;
+  }
+
+  return bFound;
+#endif // GSLC_FEATURE_INPUT
+}
+
+
+// Search internal element array for one with a particular ID
+gslc_tsElemRef* gslc_CollectFindElemById(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nElemId)
+{
+  if (pCollect == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectFindElemById";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem*      pElem = NULL;
+  gslc_tsElemRef*   pElemRef = NULL;
+  gslc_tsElemRef*   pFoundElemRef = NULL;
+  uint16_t          nInd;
+
+  if (nElemId == GSLC_ID_TEMP) {
+    // ERROR: Don't expect to do this
+    GSLC_DEBUG2_PRINT("ERROR: CollectFindElemById(%s) searching for temp ID\n","");
+    return NULL;
+  }
+
+  for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+    // Fetch the element pointer from the reference array
+    pElemRef = &(pCollect->asElemRef[nInd]);
+    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+    if (pElem->nId == nElemId) {
+      pFoundElemRef = pElemRef;
+      break;
+    }
+
+  }
+
+  return pFoundElemRef;
+}
+
+int gslc_CollectGetNextId(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  int16_t nElemId = pCollect->nElemAutoIdNext;
+  pCollect->nElemAutoIdNext++;
+  return nElemId;
+}
+
+gslc_tsElemRef* gslc_CollectGetElemRefTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  return pCollect->pElemRefTracked;
+}
+
+void gslc_CollectSetElemTracked(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRef)
+{
+  pCollect->pElemRefTracked = pElemRef;
+}
+
+// Find an element index in a collection from a coordinate
+// - Note that the search is in decreasing Z-order (ie. front to back)
+//   so that we effectively find the top-most element that should
+//   receive an event.
+gslc_tsElemRef* gslc_CollectFindElemFromCoord(gslc_tsGui* pGui,gslc_tsCollect* pCollect,int16_t nX, int16_t nY)
+{
+  int16_t               nInd;
+  bool                  bFound = false;
+  gslc_tsElemRef*       pElemRef = NULL;
+  gslc_tsElemRef*       pFoundElemRef = NULL;
+
+  if (pCollect->nElemRefCnt == 0) { return NULL; }
+  for (nInd=pCollect->nElemRefCnt-1;nInd>=0;nInd--) {
+    pElemRef  = &(pCollect->asElemRef[nInd]);
+
+    if (!gslc_ElemGetVisible(pGui, pElemRef)) {
+      // Element is marked as hidden, so don't accept touch
+      continue;
+    }
+
+    bFound = gslc_ElemOwnsCoord(pGui,pElemRef,nX,nY,true);
+    if (bFound) {
+      pFoundElemRef = pElemRef;
+      // Stop searching
+      break;
+    }
+  }
+   // Return pointer or NULL if none found
+  return pFoundElemRef;
+}
+
+
+int16_t gslc_CollectGetFocus(gslc_tsGui* pGui,gslc_tsCollect* pCollect)
+{
+  return pCollect->nElemIndFocused;
+}
+
+void gslc_CollectSetFocus(gslc_tsGui* pGui, gslc_tsCollect* pCollect, int16_t nElemInd)
+{
+  pCollect->nElemIndFocused = nElemInd;
+}
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// Go through all elements in a collection and set the parent
+// element pointer.
+void gslc_CollectSetParent(gslc_tsGui* pGui,gslc_tsCollect* pCollect,gslc_tsElemRef* pElemRefParent)
+{
+  gslc_tsElemRef* pElemRef = NULL;
+  gslc_tsElem*    pElem = NULL;
+  uint16_t        nInd;
+  for (nInd=0;nInd<pCollect->nElemRefCnt;nInd++) {
+    gslc_teElemRefFlags eFlags = pCollect->asElemRef[nInd].eElemFlags;
+    // NOTE: Only elements in RAM are updated
+    // TODO: Error handling if we attempt to modify FLASH-based element
+    if ((eFlags & GSLC_ELEMREF_SRC) != GSLC_ELEMREF_SRC_RAM) {
+      continue;
+    }
+    pElemRef = &pCollect->asElemRef[nInd];
+    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+    pElem->pElemRefParent = pElemRefParent;
+  }
+}
+#endif
+
+/* UNUSED
+void gslc_CollectSetEventFunc(gslc_tsGui* pGui,gslc_tsCollect* pCollect,GSLC_CB_EVENT funcCb)
+{
+  if ((pCollect == NULL) || (funcCb == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "CollectSetEventFunc";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pCollect->pfuncXEvent       = funcCb;
+}
+*/
+
+// ============================================================================
+
+// Trigonometric lookup table for sin(x)
+// - The lookup table saves us from having to import the sin/cos
+//   functions and the associated floating point libraries. GUIslice
+//   has provided a relatively lightweight fixed-point representation
+//   using the following 16-bit LUT (8-bit index).
+// - At this point in time, the LUT is only used by GUIslice for sin/cos
+//   in supporting the XRadial controls
+// - The LUT consumes approx 514 bytes of FLASH memory. FIXME: Ensure in FLASH!
+uint16_t  m_nLUTSinF0X16[257] = {
+  0x0000,0x0192,0x0324,0x04B6,0x0648,0x07DA,0x096C,0x0AFD,0x0C8F,0x0E21,0x0FB2,0x1143,0x12D5,0x1465,0x15F6,0x1787,
+  0x1917,0x1AA7,0x1C37,0x1DC6,0x1F56,0x20E5,0x2273,0x2402,0x258F,0x271D,0x28AA,0x2A37,0x2BC3,0x2D4F,0x2EDB,0x3066,
+  0x31F1,0x337B,0x3505,0x368E,0x3816,0x399E,0x3B26,0x3CAD,0x3E33,0x3FB9,0x413E,0x42C3,0x4447,0x45CA,0x474C,0x48CE,
+  0x4A4F,0x4BD0,0x4D4F,0x4ECE,0x504D,0x51CA,0x5347,0x54C3,0x563E,0x57B8,0x5931,0x5AAA,0x5C21,0x5D98,0x5F0E,0x6083,
+  0x61F7,0x636A,0x64DC,0x664D,0x67BD,0x692C,0x6A9A,0x6C07,0x6D73,0x6EDE,0x7048,0x71B1,0x7319,0x747F,0x75E5,0x7749,
+  0x78AC,0x7A0F,0x7B6F,0x7CCF,0x7E2E,0x7F8B,0x80E7,0x8242,0x839B,0x84F3,0x864A,0x87A0,0x88F5,0x8A48,0x8B99,0x8CEA,
+  0x8E39,0x8F86,0x90D3,0x921E,0x9367,0x94AF,0x95F6,0x973B,0x987F,0x99C1,0x9B02,0x9C41,0x9D7F,0x9EBB,0x9FF6,0xA12F,
+  0xA266,0xA39D,0xA4D1,0xA604,0xA735,0xA865,0xA993,0xAABF,0xABEA,0xAD13,0xAE3B,0xAF60,0xB085,0xB1A7,0xB2C8,0xB3E7,
+  0xB504,0xB61F,0xB739,0xB851,0xB967,0xBA7B,0xBB8E,0xBC9F,0xBDAE,0xBEBB,0xBFC6,0xC0D0,0xC1D7,0xC2DD,0xC3E1,0xC4E3,
+  0xC5E3,0xC6E1,0xC7DD,0xC8D7,0xC9D0,0xCAC6,0xCBBB,0xCCAD,0xCD9E,0xCE8C,0xCF79,0xD063,0xD14C,0xD232,0xD317,0xD3F9,
+  0xD4DA,0xD5B8,0xD695,0xD76F,0xD847,0xD91D,0xD9F1,0xDAC3,0xDB93,0xDC60,0xDD2C,0xDDF5,0xDEBD,0xDF82,0xE045,0xE106,
+  0xE1C4,0xE281,0xE33B,0xE3F3,0xE4A9,0xE55D,0xE60E,0xE6BD,0xE76A,0xE815,0xE8BE,0xE964,0xEA08,0xEAAA,0xEB4A,0xEBE7,
+  0xEC82,0xED1B,0xEDB1,0xEE45,0xEED7,0xEF67,0xEFF4,0xF07F,0xF108,0xF18E,0xF212,0xF294,0xF313,0xF390,0xF40A,0xF483,
+  0xF4F9,0xF56C,0xF5DD,0xF64C,0xF6B9,0xF723,0xF78A,0xF7F0,0xF853,0xF8B3,0xF911,0xF96D,0xF9C6,0xFA1D,0xFA72,0xFAC4,
+  0xFB13,0xFB61,0xFBAB,0xFBF4,0xFC3A,0xFC7D,0xFCBE,0xFCFD,0xFD39,0xFD73,0xFDAA,0xFDDF,0xFE12,0xFE42,0xFE6F,0xFE9A,
+  0xFEC3,0xFEE9,0xFF0D,0xFF2E,0xFF4D,0xFF69,0xFF83,0xFF9B,0xFFB0,0xFFC2,0xFFD2,0xFFE0,0xFFEB,0xFFF3,0xFFFA,0xFFFD,
+  0xFFFF,
+};
diff --git a/src/guislice/GUIslice.h b/src/guislice/GUIslice.h
new file mode 100644
index 0000000..19928b8
--- /dev/null
+++ b/src/guislice/GUIslice.h
@@ -0,0 +1,3801 @@
+#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_
diff --git a/src/guislice/GUIslice_config.h b/src/guislice/GUIslice_config.h
new file mode 100644
index 0000000..38c8d6c
--- /dev/null
+++ b/src/guislice/GUIslice_config.h
@@ -0,0 +1,218 @@
+#ifndef _GUISLICE_CONFIG_H_
+#define _GUISLICE_CONFIG_H_
+
+// =======================================================================
+// GUIslice library (user configuration) selection by device
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_config.h
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// =========================================================================================
+// SELECT ONE OF THE FOLLOWING EXAMPLE CONFIGURATIONS OR ADD YOUR OWN
+// - Uncomment one of the following lines
+// - These example configurations are located in the /configs folder
+// - To add your own, make a copy of an example config, rename it
+//   and add it to the list here.
+// - If no line is uncommented, then the default combined configuration
+//   file will be used, ie. GUIslice_config_ard.h / GUIslice_config_linux.h
+//   which is selected at the bottom of this file
+// - Refer to https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Config-Table
+//   to help identify a suitable config for your MCU shield / display
+// - Multiple configurations can be supported using the method described here:
+//   https://github.com/ImpulseAdventure/GUIslice/wiki/Arduino-Multiple-Configs
+// =========================================================================================
+
+// =========================================================================================
+// IMPORTANT: Ensure you backup any custom config files before updating GUIslice!
+//            The Arduino IDE deletes all files within the library when updating
+// =========================================================================================
+
+  // ---------------------------------------------------------------------------------------
+  // Add your own configs here:
+  // ---------------------------------------------------------------------------------------
+  //#include "../configs/my-config.h"
+
+  // ---------------------------------------------------------------------------------------
+  // Example configs included in library /configs:
+  // ---------------------------------------------------------------------------------------
+
+  // Arduino, ARM SAMD, Cortex M0/M4, nRF52:
+  // ------------------------------------------------------
+  //#include "../configs/ard-shld-adafruit_18_joy.h"
+  //#include "../configs/ard-shld-adafruit_28_cap.h"
+  //#include "../configs/ard-shld-adafruit_28_res.h"
+  //#include "../configs/ard-shld-eastrising_50_ra8875_res.h"
+  //#include "../configs/ard-shld-eastrising_50_ra8875_sumo_res.h"
+  //#include "../configs/ard-shld-eastrising_50_ssd1963_res.h"  
+  //#include "../configs/ard-shld-eastrising_70_ra8876_gv.h"
+  //#include "../configs/ard-shld-elegoo_28_res.h"
+  //#include "../configs/ard-shld-generic1_35_touch.h"
+  //#include "../configs/ard-shld-gevino_tft.h"
+  //#include "../configs/ard-shld-ili9341_16b_touch.h"
+  //#include "../configs/ard-shld-mcufriend.h"
+  //#include "../configs/ard-shld-mcufriend_4wire.h"
+  //#include "../configs/ard-shld-mcufriend_xpt2046.h"
+  //#include "../configs/ard-shld-osmart_22_68130_touch.h"
+  //#include "../configs/ard-shld-waveshare_28_touch.h"
+  //#include "../configs/ard-shld-waveshare_40_notouch.h"
+  //#include "../configs/ard-shld-waveshare_40_xpt2046.h"
+  //#include "../configs/ard-adagfx-hx8347-xpt2046.h"
+  //#include "../configs/ard-adagfx-hx8357-ft6206.h"
+  //#include "../configs/ard-adagfx-hx8357-notouch.h"
+  //#include "../configs/ard-adagfx-hx8357-simple.h"
+  //#include "../configs/ard-adagfx-hx8357-stmpe610.h"
+  //#include "../configs/ard-adagfx-ili9341-ft6206.h"
+  //#include "../configs/ard-adagfx-ili9341-input.h"
+  //#include "../configs/ard-adagfx-ili9341-notouch.h"
+  //#include "../configs/ard-adagfx-ili9341-simple.h"
+  //#include "../configs/ard-adagfx-ili9341-stmpe610.h"
+  //#include "../configs/ard-adagfx-ili9341-xpt2046.h"
+  //#include "../configs/ard-adagfx-pcd8544-notouch.h"
+  //#include "../configs/ard-adagfx-ra8875-notouch.h"
+  //#include "../configs/ard-adagfx-ra8876-notouch.h"
+  //#include "../configs/ard-adagfx-ra8876-ft5206.h"
+  //#include "../configs/ard-adagfx-ssd1306-notouch.h"
+  //#include "../configs/ard-adagfx-st7735-notouch.h"
+  //#include "../configs/due-adagfx-ili9341-ft6206.h"
+  //#include "../configs/due-adagfx-ili9341-urtouch.h"
+
+  // ESP8266, ESP32, M5stack, TTGO:
+  // ------------------------------------------------------
+  //#include "../configs/esp-shld-m5stack.h"
+  //#include "../configs/esp-shld-ttgo_btc_ticker.h"
+  //#include "../configs/esp-tftespi-default-ft6206.h"
+  //#include "../configs/esp-tftespi-default-notouch.h"
+  //#include "../configs/esp-tftespi-default-simple.h"
+  //#include "../configs/esp-tftespi-default-stmpe610.h"
+  //#include "../configs/esp-tftespi-default-xpt2046.h"
+  //#include "../configs/esp-tftespi-default-xpt2046_int.h"
+
+  // Teensy:
+  // ------------------------------------------------------
+  //#include "../configs/teensy-adagfx-ili9341-xpt2046.h"
+  //#include "../configs/teensy-adagfx-ili9341-xpt2046-audio.h"
+  //#include "../configs/teensy-adagfx-ili9341_t3-xpt2046.h"
+  //#include "../configs/teensy-adagfx-ili9341_t3-xpt2046-audio.h"
+
+  // STM32:
+  // ------------------------------------------------------
+  //#include "../configs/stm32-adagfx-mcufriend-notouch.h"
+  //#include "../configs/stm32-adagfx-mcufriend-simple.h"
+
+  // Multi-device shields:
+  // ------------------------------------------------------
+  //#include "../configs/mult-shld-adafruit_24_feather_touch.h"
+  //#include "../configs/mult-shld-adafruit_35_feather_touch.h"
+
+  // Raspberry Pi / LINUX:
+  // ------------------------------------------------------
+  //#include "../configs/rpi-sdl1-default-tslib.h"
+  //#include "../configs/rpi-sdl1-default-sdl.h"
+  //#include "../configs/linux-sdl1-default-mouse.h"
+
+
+// =========================================================================================
+// DETECT DEVICE PLATFORM
+// =========================================================================================
+
+// Detect device platform
+// #if defined(__linux__)
+//   #define GSLC_CFG_LINUX
+// #elif defined(__AVR__) && !defined(TEENSYDUINO)
+//   // Note: Teensy 2 also defines __AVR__, so differentiate with TEENSYDUINO
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_SAMD_ZERO)
+//   #define GSLC_CFG_ARD
+// #elif defined(ESP8266) || defined(ESP32)
+//   #define GSLC_CFG_ARD
+// #elif defined(NRF52)
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_STM32_FEATHER) || defined(__STM32F1__)
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_ARCH_STM32)  // ST Core from STMicroelectronics
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_ARCH_SAM)   // Arduino Due
+//   #define GSLC_CFG_ARD
+// #elif defined(ARDUINO_ARCH_SAMD)   // M0_PRO
+//   #define GSLC_CFG_ARD
+// #elif defined(__AVR__) && defined(TEENSYDUINO) // Teensy 2
+//   #define GSLC_DEV_TEENSY_2
+//   #define GSLC_CFG_ARD
+// #elif defined(__MKL26Z64__) // Teensy LC
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_LC
+// #elif defined(__MK20DX256__) // Teensy 3.2
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_3_2
+// #elif defined(__MK64FX512__) // Teensy 3.5
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_3_5
+// #elif defined(__MK66FX1M0__) // Teensy 3.6
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_3_6
+// #elif defined(__MK66FX1M0__) // Teensy 3.6
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_3_6
+// #elif defined(__IMXRT1062__)
+//   #define GSLC_CFG_ARD
+//   #define GSLC_DEV_TEENSY_4_0
+// #else
+// #warning Unknown
+//   #error "Unknown device platform"
+// #endif
+
+// Adafruit nRF52840 Feather
+#include "ard-adagfx-ili9341-stmpe610.h"
+// #include "ard-adagfx-ili9341-notouch.h"
+#define GSLC_CFG_ARD
+
+// =========================================================================================
+// DEFAULT COMBINED CONFIGURATION FILE
+// - If no user configuration has been selected, a default config will be selected here
+// - Note that the include guard _GUISLICE_CONFIG_ARD_H_ and _GUISLICE_CONFIG_LINUX_H_
+//   will prevent these from loading if any of the user configs have been loaded
+// =========================================================================================
+
+#if defined(GSLC_CFG_LINUX)
+  #include "GUIslice_config_linux.h"
+#elif defined(GSLC_CFG_ARD)
+  #include "GUIslice_config_ard.h"
+#endif
+
+// -----------------------------------------------------------------------------------------
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_H_
\ No newline at end of file
diff --git a/src/guislice/GUIslice_config_ard.h b/src/guislice/GUIslice_config_ard.h
new file mode 100644
index 0000000..d576a76
--- /dev/null
+++ b/src/guislice/GUIslice_config_ard.h
@@ -0,0 +1,526 @@
+#ifndef _GUISLICE_CONFIG_ARD_H_
+#define _GUISLICE_CONFIG_ARD_H_
+
+#warning No config selected in GUIslice_config.h - resorting to defaults.
+
+// =============================================================================
+// GUIslice library (user configuration) for:
+//     - Arduino
+//     - Cortex-M0
+//     - ESP8266 / ESP32
+//     - nRF52
+//     - STM32
+//
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =============================================================================
+//
+// 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_config_ard.h
+
+// =============================================================================
+// User Configuration
+// - This file can be modified by the user to match the
+//   intended target configuration
+// - Please refer to "docs/GUIslice_config_guide.xlsx" for detailed examples
+//   specific to board and display combinations
+// =============================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// =============================================================================
+// DISPLAY CONFIGURATION - SELECT
+// =============================================================================
+
+  // Specify the graphics driver library
+  // - Uncomment one of the following graphics drivers DRV_DISP_*
+  //   applicable to the device type in use
+
+  // --------------------------------------------------------------
+  // Arduino / ATmega / AVR / Cortex-M0 / nRF52:
+      #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  // --------------------------------------------------------------
+  // ESP8266 / ESP32 / NodeMCU:
+  //  #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  //  #define DRV_DISP_TFT_ESPI         // Bodmer/TFT_eSPI library
+  //  #define DRV_DISP_M5STACK          // m5stack/M5Stack library
+  // --------------------------------------------------------------
+  // STM32:
+  //  #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  //  #define DRV_DISP_ADAGFX_AS        // Adafruit-GFX-AS library, high speed using DMA
+  // --------------------------------------------------------------
+
+
+// =============================================================================
+// TOUCH CONFIGURATION - SELECT
+// =============================================================================
+
+  // Specify the touchscreen driver
+  // - Uncomment one of the following touchscreen drivers DRV_TOUCH_*
+  //   applicable to the controller chip in use
+
+      #define DRV_TOUCH_NONE            // No touchscreen support & no input (GPIO / keyboard)
+  //  #define DRV_TOUCH_ADA_STMPE610    // Adafruit STMPE610 touch driver
+  //  #define DRV_TOUCH_ADA_FT6206      // Adafruit FT6206 touch driver
+  //  #define DRV_TOUCH_ADA_SIMPLE      // Adafruit Touchscreen
+  //  #define DRV_TOUCH_TFT_ESPI        // TFT_eSPI integrated XPT2046 touch driver
+  //  #define DRV_TOUCH_M5STACK         // M5stack integrated button driver
+  //  #define DRV_TOUCH_XPT2046_PS      // PaulStoffregen/XPT2046_Touchscreen
+  //  #define DRV_TOUCH_XPT2046_STM     // Arduino_STM32/Serasidis_XPT2046_touch (XPT2046_touch.h)
+  //  #define DRV_TOUCH_INPUT           // No touchscreen support, but input only (GPIO / keyboard)
+  //  #define DRV_TOUCH_HANDLER         // touch handler class
+
+
+// =============================================================================
+// DISPLAY CONFIGURATION - DETAILS
+// - Graphics display driver-specific additional configuration
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+#if defined(DRV_DISP_ADAGFX)
+
+  // The Adafruit-GFX library supports a number of displays
+  // - Select a display sub-type by uncommenting one of the
+  //   following DRV_DISP_ADAGFX_* lines
+  #define DRV_DISP_ADAGFX_ILI9341         // Adafruit ILI9341
+  //#define DRV_DISP_ADAGFX_ILI9341_8BIT  // Adafruit ILI9341 (8-bit interface)
+  //#define DRV_DISP_ADAGFX_ST7735        // Adafruit ST7735
+  //#define DRV_DISP_ADAGFX_SSD1306       // Adafruit SSD1306
+  //#define DRV_DISP_ADAGFX_HX8347        // prenticedavid/HX8347D_kbv
+  //#define DRV_DISP_ADAGFX_HX8357        // Adafruit HX8357
+  //#define DRV_DISP_ADAGFX_PCD8544       // Adafruit PCD8544
+
+  // For Adafruit-GFX drivers, define pin connections
+  // - Define general pins (modify these example pin assignments to match your board)
+  // - Please refer to "docs/GUIslice_config_guide.xlsx" for detailed examples
+  #define ADAGFX_PIN_CS    10   // Display chip select
+  #define ADAGFX_PIN_DC     9   // Display SPI data/command
+  #define ADAGFX_PIN_RST    0   // Display Reset (some displays could use pin 11)
+  #define ADAGFX_PIN_SDCS   4   // SD card chip select
+  #define ADAGFX_PIN_WR    A1   // Display write pin (for parallel displays)
+  #define ADAGFX_PIN_RD    A0   // Display read pin (for parallel displays)
+
+  // Use hardware SPI interface?
+  // - Set to 1 to enable hardware SPI interface, 0 to use software SPI
+  // - Software SPI may support the use of custom pin selection (via ADAGFX_PIN_MOSI,
+  //   ADAGFX_PIN_MISO, ADAGFX_PIN_CLK). These pin definitions can be left blank in
+  //   hardware SPI mode.
+  #define ADAGFX_SPI_HW     1
+
+  // Define custom SPI pin connections used in software SPI mode (ADAGFX_SPI_HW=0)
+  // - These definitions can be left blank in hardware mode (ADAGFX_SPI_HW=1)
+  #define ADAGFX_PIN_MOSI
+  #define ADAGFX_PIN_MISO
+  #define ADAGFX_PIN_CLK
+
+  // Set Default rotation
+  // you can specify values 0,1,2,3, rotation is clockwise
+  #define GSLC_ROTATE     1
+
+
+#elif defined(DRV_DISP_ADAGFX_AS)
+
+  //NOTE: this is a optimized driver for STM32 only
+
+  // The Adafruit-GFX-AS library supports a number of displays
+  // - Select a display sub-type by uncommenting one of the
+  //   following DRV_DISP_ADAGFX_* lines
+  #define DRV_DISP_ADAGFX_ILI9341_STM     // Adafruit ILI9341 (STM32 version)
+
+  // For Adafruit-GFX drivers, define pin connections
+  // - Define general pins (modify these example pin assignments to match your board)
+  // - Please refer to "docs/GUIslice_config_guide.xlsx" for detailed examples
+
+  //Note: Fixed pin setting for HW SPI1
+  //  PA5  SCLK
+  //  PA6  MISO
+  //  PA7  MOSI
+
+  // USE Arduino STM32 PIN Notations
+  // - Define to use Arduino STM32 PIN Notations
+  // #define STM32_NOTATION
+
+  #if defined(STM32_NOTATION)
+    // NOTE: Using Arduino STM32 pin notation
+    #define ADAGFX_PIN_CS   PA4   // Display chip select
+    #define ADAGFX_PIN_DC   PB1   // Display SPI data/command
+    #define ADAGFX_PIN_RST  PB0   // Display Reset (set to -1 in order to use Adafruit-GFX drivers w/o reset)
+    #define ADAGFX_PIN_SDCS       // SD card chip select
+    #define ADAGFX_PIN_WR         // Display write pin (for parallel displays)
+    #define ADAGFX_PIN_RD         // Display read pin (for parallel displays)
+  #else
+    // NOTE: Using Arduino pin notation
+    #define ADAGFX_PIN_CS    10   // Display chip select
+    #define ADAGFX_PIN_DC     9   // Display SPI data/command
+    #define ADAGFX_PIN_RST    0   // Display Reset (some displays could use pin 11)
+    #define ADAGFX_PIN_SDCS   4   // SD card chip select
+    #define ADAGFX_PIN_WR    A1   // Display write pin (for parallel displays)
+    #define ADAGFX_PIN_RD    A0   // Display read pin (for parallel displays)
+  #endif
+
+  // Use hardware SPI interface?
+  // - Set to 1 to enable hardware SPI interface, 0 to use software SPI
+  // - Software SPI may support the use of custom pin selection (via ADAGFX_PIN_MOSI,
+  //   ADAGFX_PIN_MISO, ADAGFX_PIN_CLK). These pin definitions can be left blank in
+  //   hardware SPI mode.
+  #define ADAGFX_SPI_HW     1
+
+  // Define custom SPI pin connections used in software SPI mode (ADAGFX_SPI_HW=0)
+  // - These definitions can be left blank in hardware mode (ADAGFX_SPI_HW=1)
+  #define ADAGFX_PIN_MOSI
+  #define ADAGFX_PIN_MISO
+  #define ADAGFX_PIN_CLK
+
+
+  // Set Default rotation
+  // you can specify values 0,1,2,3, rotation is clockwise
+  #define GSLC_ROTATE     1
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_DISP_TFT_ESPI)
+
+  // NOTE: When using the TFT_eSPI library, there are additional
+  //       library-specific configuration files that may need
+  //       customization (including pin configuration), such as
+  //       "User_Setup_Select.h" (typically located in the
+  //       Arduino /libraries/TFT_eSPI folder). Please refer to
+  //       Bodmer's TFT_eSPI library for more details:
+  //       https://github.com/Bodmer/TFT_eSPI
+
+  // NOTE: To avoid potential SPI conflicts, it is recommended
+  //       that SUPPORT_TRANSACTIONS is defined in TFT_eSPI's "User Setup"
+
+
+  // Set Default rotation
+  // you can specify values 0,1,2,3, rotation is clockwise
+  #define GSLC_ROTATE     1
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_DISP_M5STACK)
+
+  #define ADAGFX_PIN_SDCS   4   // SD card chip select
+  #define TFT_LIGHT_PIN    32   // display backlight
+
+  // Set Default rotation
+  // you can specify values 0,1,2,3, rotation is clockwise
+
+  // NOTE: M5stack has a fixed display. A setting of 1 should
+  //       match the built-in display and not need changing.
+  #define GSLC_ROTATE     1
+
+#else
+
+  #error "Unknown driver for display DRV_DISP_..."
+
+#endif // DRV_DISP_*
+
+
+// =============================================================================
+// TOUCH CONFIGURATION - DETAILS
+// - Touch Driver-specific additional configuration
+// =============================================================================
+
+// -----------------------------------------------------------------------------
+#if defined(DRV_TOUCH_NONE)
+
+  //no touch defined
+
+#elif defined(DRV_TOUCH_ADA_STMPE610)
+
+  // Select wiring method by setting one of the following to 1
+  #define ADATOUCH_I2C_HW 0
+  #define ADATOUCH_SPI_HW 1
+  #define ADATOUCH_SPI_SW 0  // [TODO]
+
+  // For ADATOUCH_I2C_HW=1
+  #define ADATOUCH_I2C_ADDR   0x41  // I2C address of touch device
+
+  // For ADATOUCH_SPI_HW=1
+  #define ADATOUCH_PIN_CS     8 // From Adafruit 2.8" TFT touch shield
+
+  // Calibration values for touch display
+  // - These values may need to be updated to match your display
+  // - Typically used in resistive displays
+  // - These values can be determined from the Adafruit touchtest example sketch
+  //   (check for min and max values reported from program as you touch display
+  //   corners)
+  // - Note that X & Y directions reference the display's natural orientation
+  #define ADATOUCH_X_MIN 230
+  #define ADATOUCH_Y_MIN 260
+  #define ADATOUCH_X_MAX 3800
+  #define ADATOUCH_Y_MAX 3700
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  // Define sensitivity coefficient (capacitive touch)
+  #define ADATOUCH_SENSITIVITY  40
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+
+  // Define 4-wire resistive touchscreen pinout
+  #define ADATOUCH_PIN_YP A2   // "Y+": Must be an analog pin, use "An" notation
+  #define ADATOUCH_PIN_XM A3   // "X-": Must be an analog pin, use "An" notation
+  #define ADATOUCH_PIN_YM 44   // "Y-": Can be a digital pin
+  #define ADATOUCH_PIN_XP 45   // "X+": Can be a digital pin
+  #define ADATOUCH_RX 300      // "rxplate"
+
+  // Calibration values for touch display
+  // - These values may need to be updated to match your display
+  // - Typically used in resistive displays
+  #define ADATOUCH_X_MIN 100
+  #define ADATOUCH_Y_MIN 150
+  #define ADATOUCH_X_MAX 900
+  #define ADATOUCH_Y_MAX 900
+
+  // Define pressure threshold for detecting a touch
+  #define ADATOUCH_PRESS_MIN 10
+  #define ADATOUCH_PRESS_MAX 1000
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_TFT_ESPI)
+  // The TFT_eSPI display library also includes support for XPT2046 touch controller
+  // Note that TFT_eSPI's "User_Setup" should define TOUCH_CS
+  #define DRV_TOUCH_IN_DISP   // Use the display driver (TFT_eSPI) for touch events
+
+  // Define the XPT2046 touch driver calibration values
+  // - The following are some example defaults, but they should be updated
+  //   to match your specific touch device.
+  #define TFT_ESPI_TOUCH_CALIB { 321,3498,280,3593,3 }
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_M5STACK)
+  // M5stack integrated button handler
+  #define DRV_TOUCH_IN_DISP   // Use the display driver (M5stack) for touch events
+
+  // NOTE: Long-press detection is only available in the latest
+  //       M5stack library releases. Uncomment the following
+  //       if the Btn wasReleasefor() API is available.
+  //
+  // Define duration (in ms) for a long-press button event
+  //#define M5STACK_TOUCH_PRESS_LONG  300
+
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  // PaulStoffregen/XPT2046_Touchscreen
+
+  // Chip select pin for touch
+  #define XPT2046_CS 3
+
+  // Calibration values for touch display
+  // - These values may need to be updated to match your display
+  // - empirically found for XPT2046
+  #define ADATOUCH_X_MIN    246
+  #define ADATOUCH_Y_MIN    3925
+  #define ADATOUCH_X_MAX    3837
+  #define ADATOUCH_Y_MAX    370
+
+  // Define pressure threshold for detecting a touch
+  #define ADATOUCH_PRESS_MIN 10
+  #define ADATOUCH_PRESS_MAX 1000
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  // Arduino_STM32/Serasidis_XPT2046_touch (XPT2046_touch.h)
+  // NOTE: This touch library is included in the Arduino_STM32 library
+  //       While it still works on many non-STM32 targets, it is recommended
+  //       that users use DRV_TOUCH_XPT2046_PS instead.
+
+  // SPI2 is used. Due to some known issues of the TFT SPI driver working on SPI1
+  // it was not possible to share the touch with SPI1.
+  // On the Arduino STM32 these are the following pins:
+  //   PB13   SCLK
+  //   PB14   MISO
+  //   PB15   MOSI
+  #define XPT2046_DEFINE_DPICLASS SPIClass XPT2046_spi(2); //Create an SPI instance on SPI2 port
+
+  // Chip select pin for touch SPI2
+  #define XPT2046_CS PB12
+
+  // Calibration values for touch display
+  // - These values may need to be updated to match your display
+  // - empirically found for XPT2046
+  #define ADATOUCH_X_MIN 398
+  #define ADATOUCH_Y_MIN 280
+  #define ADATOUCH_X_MAX 3877
+  #define ADATOUCH_Y_MAX 3805
+
+  // Define pressure threshold for detecting a touch
+  #define ADATOUCH_PRESS_MIN 10
+  #define ADATOUCH_PRESS_MAX 1000
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_INPUT)
+// Include basic support for GPIO/keyboard only
+
+// -----------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_HANDLER)
+  // touch handler class
+
+// -----------------------------------------------------------------------------
+#else
+
+  #error "Unknown driver for touch DRV_TOUCH_..."
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------------
+
+
+  // TODO: maybe those macros should be moved to one include file which is included by all drivers
+  #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 )
+  
+  // - Set any of the following to 1 to perform touch display
+  //   remapping functions, 0 to disable. Use DBG_TOUCH to determine which
+  //   remapping modes should be enabled for your display
+  // - Please refer to the wiki for details:
+  //   https://github.com/ImpulseAdventure/GUIslice/wiki/Configure-Touch-Support
+  #define ADATOUCH_SWAP_XY  0
+  #define ADATOUCH_FLIP_X   0
+  #define ADATOUCH_FLIP_Y   0
+
+  // Define the maximum number of touch events that are handled
+  // per gslc_Update() call. Normally this can be set to 1 but certain
+  // displays may require a greater value (eg. 30) in order to increase
+  // responsiveness of the touch functionality.
+  #define GSLC_TOUCH_MAX_EVT    1
+
+
+// =============================================================================
+// COMMON CONFIGURATION
+// =============================================================================
+
+  // Error reporting
+  // - Set DEBUG_ERR to 1 to enable error reporting via the Serial connection
+  // - Enabling DEBUG_ERR increases FLASH memory consumption which may be
+  //   limited on the baseline Arduino (ATmega328P) devices. Therefore it
+  //   is recommended to disable DEBUG_ERR (set to 0) on baseline Arduino
+  //   once initial device operation confirmed to work in examples ex01 and ex02.
+  //   
+  #if defined(__AVR__)
+    #define DEBUG_ERR               1   // Debugging enabled by default
+  #else
+    // For all other devices, DEBUG_ERR is enabled by default.
+    // Since this mode increases FLASH memory considerably, it may be
+    // necessary to disable this feature.
+    #define DEBUG_ERR               1   // Debugging enabled by default
+  #endif
+
+  // Debug initialization message
+  // - By default, GUIslice outputs a message in DEBUG_ERR mode
+  //   to indicate the initialization status, even during success.
+  // - To disable the messages during successful initialization,
+  //   uncomment the following line.
+  //#define INIT_MSG_DISABLE
+
+
+  // Enable of optional features
+  // - For memory constrained devices such as Arduino, it is best to
+  //   set the following features to 0 (to disable) unless they are
+  //   required.
+
+  #define GSLC_FEATURE_COMPOUND       0   // Compound elements (eg. XSelNum)
+  #define GSLC_FEATURE_XGAUGE_RADIAL  0   // XGauge control with radial support
+  #define GSLC_FEATURE_XGAUGE_RAMP    0   // XGauge control with ramp support
+  #define GSLC_FEATURE_XTEXTBOX_EMBED 0   // XTextbox control with embedded color
+  #define GSLC_FEATURE_INPUT          0   // Keyboard / GPIO input control
+
+
+  // Enable support for SD card
+  // - Set to 1 to enable, 0 to disable
+  // - Note that the inclusion of the SD library consumes considerable
+  //   RAM and flash memory which could be problematic for Arduino models
+  //   with limited resources.
+  #define GSLC_SD_EN    0
+
+  // Define buffer size for loading images from SD
+  // - A larger buffer will be faster but at the cost of RAM
+  #define GSLC_SD_BUFFPIXEL   50
+
+
+  // Enable support for graphics clipping (DrvSetClipRect)
+  // - Note that this will impact performance of drawing graphics primitives
+  #define GSLC_CLIP_EN 1
+
+  // Enable for bitmap transparency and definition of color to use
+  #define GSLC_BMP_TRANS_EN     1               // 1 = enabled, 0 = disabled
+  #define GSLC_BMP_TRANS_RGB    0xFF,0x00,0xFF  // RGB color (default:pink)
+
+
+  // In "Local String" mode, memory within internal element array is
+  // used for strings. This mode incurs a memory cost for all elements,
+  // irrespective of whether strings are used or their length. This
+  // mode may make string definition convenient but is not memory-efficient.
+  // Therefore, it is not recommended for limited memory devices such as
+  // Arduino.
+  // - When using element local string storage (GSLC_LOCAL_STR=1),
+  //   GSLC_LOCAL_STR_LEN defines the fixed length buffer used for every element
+  #define GSLC_LOCAL_STR      0   // 1=Use local strings (in element array), 0=External
+  #define GSLC_LOCAL_STR_LEN  30  // Max string length of text elements
+
+  #define GSLC_USE_FLOAT      0   // 1=Use floating pt library, 0=Fixed-point lookup tables
+
+
+  // Debug diagnostic modes
+  // - Uncomment any of the following to enable specific debug modes
+  //#define DBG_LOG           // Enable debugging log output
+  //#define DBG_TOUCH         // Enable debugging of touch-presses
+  //#define DBG_FRAME_RATE    // Enable diagnostic frame rate reporting
+  //#define DBG_DRAW_IMM      // Enable immediate rendering of drawing primitives
+  //#define DBG_DRIVER        // Enable graphics driver debug reporting
+
+
+// =============================================================================
+// INTERNAL CONFIGURATION
+// - Users should not need to modify the following
+// =============================================================================
+
+  // Display device string is only used in LINUX drivers
+  #define GSLC_DEV_TOUCH ""   // No device path used
+
+
+  // Define compatibility for non-AVR to call PROGMEM functions
+  #if defined(__AVR__)
+    #define GSLC_USE_PROGMEM 1
+  #else
+    #define GSLC_USE_PROGMEM 0
+  #endif
+
+
+// =============================================================================
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_ARD_H_
diff --git a/src/guislice/GUIslice_config_linux.h b/src/guislice/GUIslice_config_linux.h
new file mode 100644
index 0000000..53b438f
--- /dev/null
+++ b/src/guislice/GUIslice_config_linux.h
@@ -0,0 +1,191 @@
+#ifndef _GUISLICE_CONFIG_LINUX_H_
+#define _GUISLICE_CONFIG_LINUX_H_
+
+#warning No config selected in GUIslice_config.h - resorting to defaults.
+
+// =======================================================================
+// GUIslice library (user configuration) for LINUX / Raspberry Pi / Beaglebone
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_config_linux.h
+// \brief GUIslice library (user configuration) for LINUX / Raspberry Pi / Beaglebone
+
+// =======================================================================
+// User Configuration
+// - This file can be modified by the user to match the
+//   intended target configuration
+// - Please refer to "docs/GUIslice_config_guide.xlsx" for detailed examples
+//   specific to board and display combinations
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// -----------------------------------------------------------------------------------------
+
+// Specify the graphics driver library
+// - Uncomment one of the following graphics drivers
+#define DRV_DISP_SDL1                // LINUX: SDL 1.2 library
+//#define DRV_DISP_SDL2              // LINUX: SDL 2.0 library
+
+
+
+// Specify the touchscreen driver
+// - Uncomment one of the following touchscreen drivers
+//#define DRV_TOUCH_NONE          // No touchscreen support
+//#define DRV_TOUCH_SDL           // LINUX: Use SDL touch driver
+#define DRV_TOUCH_TSLIB           // LINUX: Use tslib touch driver
+
+
+
+// -----------------------------------------------------------------------------------------
+// Enable of optional features
+// - For memory constrained devices such as Arduino, it is best to
+//   set the following features to 0 (to disable) unless they are
+//   required.
+
+#define GSLC_FEATURE_COMPOUND       1   // Compound elements (eg. XSelNum)
+#define GSLC_FEATURE_XGAUGE_RADIAL  1   // XGauge control with radial support
+#define GSLC_FEATURE_XGAUGE_RAMP    1   // XGauge control with ramp support
+#define GSLC_FEATURE_XTEXTBOX_EMBED 0   // XTextbox control with embedded color
+#define GSLC_FEATURE_INPUT          1   // Keyboard / GPIO input control
+
+// Error reporting
+// - Set DEBUG_ERR to 1 to enable error reporting via the console
+#define DEBUG_ERR                   1   // Enable by default
+
+// Debug initialization message
+// - By default, GUIslice outputs a message in DEBUG_ERR mode
+//   to indicate the initialization status, even during success.
+// - To disable the messages during successful initialization,
+//   uncomment the following line.
+//#define INIT_MSG_DISABLE
+
+// -----------------------------------------------------------------------------------------
+
+// Graphics display driver-specific additional configuration
+#if defined(DRV_DISP_SDL1)
+  // Define default device paths for framebuffer & touchscreen
+  #define GSLC_DEV_FB       "/dev/fb1"
+  #define GSLC_DEV_TOUCH    "/dev/input/touchscreen"
+  #define GSLC_DEV_VID_DRV  "fbcon"
+
+  // Enable SDL startup workaround? (1 to enable, 0 to disable)
+  #define DRV_SDL_FIX_START 0
+
+  // Show SDL mouse (1 to show, 0 to hide)
+  #define DRV_SDL_MOUSE_SHOW 0
+
+  #define GSLC_LOCAL_STR      1
+  #define GSLC_USE_FLOAT      1
+
+
+#elif defined(DRV_DISP_SDL2)
+  // Define default device paths for framebuffer & touchscreen
+  // - The following assumes display driver (eg. fbtft) reads from fb1
+  // - Raspberry Pi can support hardware acceleration onto fb0
+  // - To use SDL2.0 with hardware acceleration with such displays,
+  //   use fb0 as the target and then run fbcp to mirror fb0 to fb1
+  #define GSLC_DEV_FB       "/dev/fb0"
+  #define GSLC_DEV_TOUCH    ""
+  #define GSLC_DEV_VID_DRV  "x11"
+
+  // Show SDL mouse (1 to show, 0 to hide)
+  #define DRV_SDL_MOUSE_SHOW 0
+  // Enable hardware acceleration
+  #define DRV_SDL_RENDER_ACCEL 1
+
+  #define GSLC_LOCAL_STR      1
+  #define GSLC_USE_FLOAT      1
+
+
+#endif // DRV_DISP_*
+
+
+// -----------------------------------------------------------------------------------------
+
+// Touch Driver-specific additional configuration
+#if defined(DRV_TOUCH_SDL)
+  #define DRV_TOUCH_IN_DISP   // Use the display driver (SDL) for touch events
+
+
+#endif // DRV_TOUCH_*
+
+
+  // NOTE: The GSLC_ROTATE feature is not yet supported in SDL mode
+  //       however, the following settings are provided for future use.
+
+
+  // - Set any of the following to 1 to perform touch display
+  //   remapping functions, 0 to disable. Use DBG_TOUCH to determine which
+  //   remapping modes should be enabled for your display
+  // - Please refer to the wiki for details:
+  //   https://github.com/ImpulseAdventure/GUIslice/wiki/Configure-Touch-Support
+  #define ADATOUCH_SWAP_XY  0
+  #define ADATOUCH_FLIP_X   0
+  #define ADATOUCH_FLIP_Y   0
+
+// Define the maximum number of touch events that are handled
+// per gslc_Update() call. Normally this can be set to 1 but certain
+// displays may require a greater value (eg. 30) in order to increase
+// responsiveness of the touch functionality.
+#define GSLC_TOUCH_MAX_EVT    1
+
+// -----------------------------------------------------------------------------------------
+
+
+// When using element local string storage (GSLC_LOCAL_STR=1),
+// this defines the fixed length buffer used for every element
+#define GSLC_LOCAL_STR_LEN  30  // Max string length of text elements
+
+
+// Debug modes
+// - Uncomment the following to enable specific debug modes
+//#define DBG_LOG           // Enable debugging log output
+//#define DBG_TOUCH         // Enable debugging of touch-presses
+//#define DBG_FRAME_RATE    // Enable diagnostic frame rate reporting
+//#define DBG_DRAW_IMM      // Enable immediate rendering of drawing primitives
+//#define DBG_DRIVER        // Enable graphics driver debug reporting
+
+// Enable for bitmap transparency and definition of color to use
+#define GSLC_BMP_TRANS_EN     1               // 1 = enabled, 0 = disabled
+#define GSLC_BMP_TRANS_RGB    0xFF,0x00,0xFF  // RGB color (default:pink)
+
+
+// -----------------------------------------------------------------------------------------
+
+// Define compatibility for non-AVR to call PROGMEM functions
+#define GSLC_USE_PROGMEM 0
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_LINUX_H_
diff --git a/src/guislice/GUIslice_drv.h b/src/guislice/GUIslice_drv.h
new file mode 100644
index 0000000..158cabb
--- /dev/null
+++ b/src/guislice/GUIslice_drv.h
@@ -0,0 +1,66 @@
+#ifndef _GUISLICE_DRV_H_
+#define _GUISLICE_DRV_H_
+
+// =======================================================================
+// GUIslice library (generic driver layer include)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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.
+//
+// =======================================================================
+
+
+// =======================================================================
+// Generic Driver Layer
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if defined(DRV_DISP_SDL1)
+  #include "GUIslice_drv_sdl.h"
+#elif defined(DRV_DISP_SDL2)
+  #include "GUIslice_drv_sdl.h"
+#elif defined(DRV_DISP_ADAGFX) || defined(DRV_DISP_ADAGFX_AS)
+  #include "GUIslice_drv_adagfx.h"
+#elif defined(DRV_DISP_TFT_ESPI)
+  #include "GUIslice_drv_tft_espi.h"
+#elif defined(DRV_DISP_M5STACK)
+  #include "GUIslice_drv_m5stack.h"
+#elif defined(DRV_DISP_UTFT)
+  #include "GUIslice_drv_utft.h"
+#else
+  #error "Driver needs to be specified in GUIslice_config_*.h (DRV_DISP_*)"
+#endif
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_H_
+
diff --git a/src/guislice/GUIslice_drv_adagfx.cpp b/src/guislice/GUIslice_drv_adagfx.cpp
new file mode 100644
index 0000000..56834ee
--- /dev/null
+++ b/src/guislice/GUIslice_drv_adagfx.cpp
@@ -0,0 +1,3063 @@
+// =======================================================================
+// GUIslice library (driver layer for Adafruit-GFX)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_adagfx.cpp
+
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_ADAGFX) || defined(DRV_DISP_ADAGFX_AS)
+
+// =======================================================================
+// Driver Layer for Adafruit-GFX
+// =======================================================================
+
+// GUIslice library
+#include "GUIslice_drv_adagfx.h"
+
+#include <stdio.h>
+
+// ------------------------------------------------------------------------
+// Load display drivers
+// ------------------------------------------------------------------------
+#if defined(DRV_DISP_ADAGFX)
+
+  // Almost all GFX-compatible libraries depend on Adafruit-GFX
+  // There are a couple exceptions that do not require it
+  #if defined(DRV_DISP_ADAGFX_ILI9341_T3) || defined(DRV_DISP_ADAGFX_RA8876) || defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // No need to import Adafruit_GFX
+  #else
+    #include <Adafruit_GFX.h>
+  #endif
+
+  // Now configure specific display driver for Adafruit-GFX
+  #if defined(DRV_DISP_ADAGFX_ILI9341)
+    // https://github.com/adafruit/Adafruit_ILI9341
+    #include <Adafruit_ILI9341.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_8BIT)
+    #include <Adafruit_TFTLCD.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_T3)
+    // https://github.com/PaulStoffregen/ILI9341_t3
+    #include <ILI9341_t3.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+    // https://github.com/marekburiak/ILI9341_due
+    #include <ILI9341_due.h>
+    #include <SPI.h>
+    // Include the "SystemFont5x7" so that we can provide a
+    // suitable default in case the user doesn't load
+    // one explicitly.
+    #include <SystemFont5x7.h>
+  #elif defined(DRV_DISP_ADAGFX_SSD1306)
+    // https://github.com/adafruit/Adafruit_SSD1306
+    #include <Adafruit_SSD1306.h>
+    // TODO: Select either SPI or I2C. For now, assume SPI
+    #include <SPI.h>
+    #include <Wire.h>
+    #define DRV_COLORMODE_MONO // Monochrome display
+  #elif defined(DRV_DISP_ADAGFX_ST7735)
+    // https://github.com/adafruit/Adafruit-ST7735-Library
+    #include <Adafruit_ST7735.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_HX8347)
+    // https://github.com/prenticedavid/HX8347D_kbv
+    #include <HX8347D_kbv.h>
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_HX8357)
+    // https://github.com/adafruit/Adafruit_HX8357_Library
+    #include <Adafruit_HX8357.h>
+    // TODO: Select either SPI or I2C. For now, assume SPI
+    #include <SPI.h>
+  #elif defined(DRV_DISP_ADAGFX_PCD8544)
+    // https://github.com/adafruit/Adafruit-PCD8544-Nokia-5110-LCD-library
+    #include <Adafruit_PCD8544.h>
+    #include <SPI.h>
+    #define DRV_COLORMODE_MONO // Monochrome display
+  #elif defined(DRV_DISP_ADAGFX_RA8875)
+    // https://github.com/adafruit/Adafruit_RA8875
+    #include <Adafruit_RA8875.h>
+  #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+    // https://github.com/mjs513/RA8875 (branch: RA8875_t4)
+    //
+    // NOTE: Must also install the following library for font support:
+    // https://github.com/mjs513/ILI9341_fonts
+    #include <SPI.h>
+    #include <RA8875.h>
+    // Include a default font in case the user doesn't specify one
+    #include "font_LiberationSans.h" // If compile error, ensure ILI9341_fonts installed
+  #elif defined(DRV_DISP_ADAGFX_RA8876)
+    // https://github.com/xlatb/ra8876
+    #include <RA8876.h>
+  #elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // GEVINO RA8876 based on https://github.com/xlatb/ra8876 + RAIO vendor libs
+    #include <gevinoTFT_RA8876.h>
+  #elif defined(DRV_DISP_ADAGFX_MCUFRIEND)
+    // https://github.com/prenticedavid/MCUFRIEND_kbv
+    #include <MCUFRIEND_kbv.h>
+  #elif defined(DRV_DISP_LCDGFX)
+    // https://github.com/lexus2k/lcdgfx
+    #include <lcdgfx.h>
+  #elif defined(DRV_DISP_WAVESHARE_ILI9486)
+    // https://github.com/ImpulseAdventure/Waveshare_ILI9486
+    #include <Waveshare_ILI9486.h>
+    #include <SPI.h>
+    // Ensure we are using recent API
+    #if !defined(_WAVESHARE_ILI9486_h)
+      #error "Need to update Waveshare_ILI9486 library (>= v2.0)"
+    #endif
+
+
+  #else
+    #error "CONFIG: Need to enable a supported DRV_DISP_ADAGFX_* option in GUIslice config"
+  #endif
+
+  // Load any additional drivers
+  #ifdef DRV_DISP_ADAGFX_SEESAW_18
+    #define DRV_DISP_ADAGFX_SEESAW
+    #include <Adafruit_seesaw.h>
+    // Seesaw config specific to Adafruit 1.8" TFT shield
+    #include <Adafruit_TFTShield18.h>
+  #endif
+
+#elif defined(DRV_DISP_ADAGFX_AS)
+  #include <Adafruit_GFX_AS.h>
+
+  // Now configure specific display driver for Adafruit-GFX-AS
+  #if defined(DRV_DISP_ADAGFX_ILI9341_STM)
+    #include <Adafruit_ILI9341_STM.h>
+    #include <SPI.h>
+  #else
+    #error "CONFIG: Need to enable a supported DRV_DISP_ADAGFX_* option in GUIslice config"
+  #endif
+
+#endif
+
+// ------------------------------------------------------------------------
+// Load storage drivers
+// - Support SD card interface
+// ------------------------------------------------------------------------
+#if (GSLC_SD_EN)
+  #if (GSLC_SD_EN == 1)
+    // Use Arduino built-in SD library
+    // - Only supports HW SPI
+    #include <SD.h>
+  #elif (GSLC_SD_EN == 2)
+    // Use greiman/SdFat library
+    // - Supports SW SPI
+    // - Recommend usage of SdFat library version 1.0.1
+    // - To support SW SPI interface, need to make mod to SdFat lib:
+    // -   Arduino\libraries\SdFat\src\SdFatConfig.h:
+    // -     #define ENABLE_SOFTWARE_SPI_CLASS 1 // Change default from 0 to 1
+    #include <SdFat.h>
+    SdFatSoftSpi<12, 11, 13> SD; // FIXME: Add configurability
+  #endif
+#endif
+ 
+
+// ------------------------------------------------------------------------
+// Load touch drivers
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  // https://github.com/adafruit/Adafruit_STMPE610
+  #include <SPI.h>
+  #include <Wire.h>
+  #include "Adafruit_STMPE610.h"
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  // https://github.com/adafruit/Adafruit_FT6206_Library
+  #include <Wire.h>
+  #include "Adafruit_FT6206.h"
+#elif defined(DRV_TOUCH_ADA_FT5206)
+  // https://github.com/sumotoy/FT5206
+  #include <FT5206.h>
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  // https://github.com/adafruit/Adafruit_TouchScreen
+  #include <stdint.h>
+  #include <TouchScreen.h>
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  // NOTE: This file is located in the Arduino_STM32 library:
+  //       Arduino_STM32/STM32F1/libraries/Serasidis_XPT2046_touch/src/XPT2046_touch.h
+  #include <XPT2046_touch.h>
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  // https://github.com/PaulStoffregen/XPT2046_Touchscreen
+  #include <XPT2046_Touchscreen.h>
+#elif defined(DRV_TOUCH_URTOUCH)
+  #if defined(DRV_TOUCH_URTOUCH_OLD)
+    #include <UTouch.h> // Select old version of URTouch
+  #else
+    #include <URTouch.h>
+  #endif
+#elif defined(DRV_TOUCH_HANDLER)
+  #include <GUIslice_th.h>
+#endif
+
+// ------------------------------------------------------------------------
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+// ------------------------------------------------------------------------
+#if defined(DRV_DISP_ADAGFX_ILI9341)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_ILI9341(SPI-HW)";
+    Adafruit_ILI9341 m_disp = Adafruit_ILI9341(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+  #else
+    const char* m_acDrvDisp = "ADA_ILI9341(SPI-SW)";
+    Adafruit_ILI9341 m_disp = Adafruit_ILI9341(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_RST, ADAGFX_PIN_MISO);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ILI9341_8BIT)
+  const char* m_acDrvDisp = "ADA_ILI9341_8b";
+  Adafruit_TFTLCD m_disp = Adafruit_TFTLCD (ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_WR, ADAGFX_PIN_RD, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ILI9341_T3)
+  #if (ADAGFX_SPI_HW)
+    // Default hardware SPI pinout
+    const char* m_acDrvDisp = "ADA_ILI9341_T3(SPI-HW)";
+    ILI9341_t3 m_disp = ILI9341_t3(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+  #else
+    // Alternate hardware SPI pinout
+    const char* m_acDrvDisp = "ADA_ILI9341_T3(SPI-HW-Alt)";
+    ILI9341_t3 m_disp = ILI9341_t3 (ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_MISO);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ILI9341_STM)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_ILI9341_STM(SPI-HW)";
+    //PIN_RST=-1 doesn't give same behavior as 2-param function variant, therefore use different functions
+    #if ADAGFX_PIN_RST==-1
+      Adafruit_ILI9341_STM m_disp = Adafruit_ILI9341_STM(ADAGFX_PIN_CS, ADAGFX_PIN_DC);
+    #else
+      Adafruit_ILI9341_STM m_disp = Adafruit_ILI9341_STM(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+    #endif
+  #else
+    const char* m_acDrvDisp = "ADA_ILI9341_STM(SPI-SW)";
+    Adafruit_ILI9341_STM m_disp = Adafruit_ILI9341_STM(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_RST, ADAGFX_PIN_MISO);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+  const char* m_acDrvDisp = "ADA_ILI9341_DUE_MB(SPI-HW)";
+  ILI9341_due m_disp = ILI9341_due(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_SSD1306)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_SSD1306(SPI-HW)";
+    Adafruit_SSD1306 m_disp(ADAGFX_PIN_DC, ADAGFX_PIN_RST, ADAGFX_PIN_CS);
+  #else
+    const char* m_acDrvDisp = "ADA_SSD1306(SPI-SW)";
+    Adafruit_SSD1306 m_disp(ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_DC, ADAGFX_PIN_RST, ADAGFX_PIN_CS);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_ST7735)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_ST7735(SPI-HW)";
+    Adafruit_ST7735 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+  #else
+    const char* m_acDrvDisp = "ADA_ST7735(SPI-SW)";
+    Adafruit_ST7735 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_RST);
+  #endif
+
+  #ifdef DRV_DISP_ADAGFX_SEESAW_18
+    Adafruit_TFTShield18 m_seesaw;
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_HX8347)
+  const char* m_acDrvDisp = "ADA_HX8347(SPI-HW)";
+  HX8347D_kbv m_disp;
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_HX8357)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_HX8357(SPI-HW)";
+    Adafruit_HX8357 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_RST);
+  #else
+    const char* m_acDrvDisp = "ADA_HX8357(SPI-SW)";
+    Adafruit_HX8357 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_DC, ADAGFX_PIN_MOSI, ADAGFX_PIN_CLK, ADAGFX_PIN_RESET);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_PCD8544)
+  #if (ADAGFX_SPI_HW) // Use hardware SPI or software SPI (with custom pins)
+    const char* m_acDrvDisp = "ADA_PCD8544(SPI-HW)";
+    Adafruit_PCD8544 m_disp(ADAGFX_PIN_DC, ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+  #else
+    const char* m_acDrvDisp = "ADA_PCD8544(SPI-SW)";
+    Adafruit_PCD8544 m_disp(ADAGFX_PIN_CLK, ADAGFX_PIN_MOSI, ADAGFX_PIN_DC, ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_RA8875)
+  const char* m_acDrvDisp = "ADA_RA8875(SPI-HW)";
+  Adafruit_RA8875 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+  const char* m_acDrvDisp = "ADA_RA8875_SUMO(SPI-HW)";
+  RA8875 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+  const char* m_acDrvDisp = "ADA_RA8876(SPI-HW)";
+  RA8876 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+  const char* m_acDrvDisp = "ADA_RA8876_GV(SPI-HW)";
+  RA8876 m_disp(ADAGFX_PIN_CS, ADAGFX_PIN_RST);
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_ADAGFX_MCUFRIEND)
+  const char* m_acDrvDisp = "ADA_MCUFRIEND";
+  MCUFRIEND_kbv m_disp;
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_LCDGFX)
+
+  // Support selection between multiple LCDGFX constructors
+  #if defined(DRV_DISP_LCDGFX_SH1106_128x64_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SH1106_128x64_I2C)";
+  DisplaySH1106_128x64_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SH1106_128x64_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SH1106_128x64_SPI)";
+  DisplaySH1106_128x64_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1306_128x64_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SSD1306_128x64_I2C)";
+  DisplaySSD1306_128x64_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SSD1306_128x64_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1306_128x64_SPI)";
+  DisplaySSD1306_128x64_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1306_128x32_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SSD1306_128x32_I2C)";
+  DisplaySSD1306_128x32_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SSD1306_128x32_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1306_128x32_SPI)";
+  DisplaySSD1306_128x32_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1325_128x64_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SSD1325_128x64_I2C)";
+  DisplaySSD1325_128x64_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SSD1325_128x64_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1325_128x64_SPI)";
+  DisplaySSD1325_128x64_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1327_128x128_I2C)
+  const char* m_acDrvDisp = "LCDGFX (SSD1327_128x128_I2C)";
+  DisplaySSD1327_128x128_I2C m_disp(-1);
+  #elif defined(DRV_DISP_LCDGFX_SSD1327_128x128_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1327_128x128_SPI)";
+  DisplaySSD1327_128x128_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1331_96x64x8_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1331_96x64x8_SPI)";
+  DisplaySSD1331_96x64x8_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1331_96x64x16_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1331_96x64x16_SPI)";
+  DisplaySSD1331_96x64x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_SSD1351_128x128_SPI)
+  const char* m_acDrvDisp = "LCDGFX (SSD1351_128x128x16_SPI)";
+  DisplaySSD1351_128x128x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_ILI9163_128x128_SPI)
+  const char* m_acDrvDisp = "LCDGFX (ILI9163_128x128x16_SPI)";
+  DisplayIL9163_128x128x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_ST7735_128x160_SPI)
+  const char* m_acDrvDisp = "LCDGFX (ST7735_128x160x16_SPI)";
+  DisplayST7735_128x160x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_ILI9341_240x320_SPI)
+  const char* m_acDrvDisp = "LCDGFX (ILI9341_240x32x16_SPI)";
+  DisplayILI9341_240x320x16_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #elif defined(DRV_DISP_LCDGFX_PCD8544_84x48_SPI)
+  const char* m_acDrvDisp = "LCDGFX (PCD8544_84x48_SPI)";
+  DisplayPCD8544_84x48_SPI m_disp(ADAGFX_PIN_RST, { -1,ADAGFX_PIN_CS,ADAGFX_PIN_DC,0,-1,-1 });
+  #else
+  #error "ERROR: LCDGFX driver: no display option (DRV_DISP_LCDGFX_*) selected in config"
+  #endif
+
+// ------------------------------------------------------------------------
+#elif defined(DRV_DISP_WAVESHARE_ILI9486)
+  const char* m_acDrvDisp = "WAVESHARE_ILI9486";
+  Waveshare_ILI9486 m_disp;
+
+// ------------------------------------------------------------------------
+#else
+  const char* m_acDrvDisp = "Unsupported Display";
+
+// ------------------------------------------------------------------------
+#endif // DRV_DISP_ADAGFX_*
+
+
+
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #if (ADATOUCH_I2C_HW) // Use I2C
+    const char* m_acDrvTouch = "STMPE610(I2C-HW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610();
+  #elif (ADATOUCH_SPI_HW) // Use hardware SPI
+    const char* m_acDrvTouch = "STMPE610(SPI-HW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610(ADATOUCH_PIN_CS);
+  #elif (ADATOUCH_SPI_SW) // Use software SPI
+    const char* m_acDrvTouch = "STMPE610(SPI-SW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610(ADATOUCH_PIN_CS, ADATOUCH_PIN_SDI, ADATOUCH_PIN_SDO, ADATOUCH_PIN_SCK);
+  #else // No interface flag set
+    #error "DRV_TOUCH_ADA_STMPE610 but no ADATOUCH_I2C_* or ADATOUCH_SPI_* set in config"
+  #endif
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  const char* m_acDrvTouch = "FT6206(I2C)";
+  // Always use I2C
+  Adafruit_FT6206 m_touch = Adafruit_FT6206();
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_FT5206)
+  const char* m_acDrvTouch = "FT5206(I2C)";
+  // Always use I2C
+  FT5206 m_touch = FT5206(ADATOUCH_PIN_INT);
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  const char* m_acDrvTouch = "SIMPLE(Analog)";
+  TouchScreen m_touch = TouchScreen(ADATOUCH_PIN_XP, ADATOUCH_PIN_YP, ADATOUCH_PIN_XM, ADATOUCH_PIN_YM, ADATOUCH_RX);
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_RA8875)
+  const char* m_acDrvTouch = "RA8875(internal)";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_RA8875_SUMO)
+  const char* m_acDrvTouch = "RA8875_SUMO(internal)";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  const char* m_acDrvTouch = "XPT2046_STM(SPI-HW)";
+  // Create an SPI class for XPT2046 access
+  XPT2046_DEFINE_DPICLASS;
+  // XPT2046 driver from Arduino_STM32 by Serasidis (<XPT2046_touch.h>)
+  XPT2046_touch m_touch(XPT2046_CS, XPT2046_spi); // Chip Select pin, SPI instance
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  const char* m_acDrvTouch = "XPT2046_PS(SPI-HW)";
+  // Use SPI, no IRQs
+  XPT2046_Touchscreen m_touch(XPT2046_CS); // Chip Select pin
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_URTOUCH)
+  #if defined(DRV_TOUCH_URTOUCH_OLD)
+    const char* m_acDrvTouch = "URTOUCH_OLD";
+    UTouch m_touch(DRV_TOUCH_URTOUCH_INIT);
+  #else
+    const char* m_acDrvTouch = "URTOUCH";
+    URTouch m_touch(DRV_TOUCH_URTOUCH_INIT);
+  #endif
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_HANDLER)
+  const char* m_acDrvTouch = "Handler";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_INPUT)
+  const char* m_acDrvTouch = "INPUT";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_NONE)
+  const char* m_acDrvTouch = "NONE";
+// ------------------------------------------------------------------------
+#else
+  const char* m_acDrvTouch = "Unsupported touch";
+// ------------------------------------------------------------------------
+#endif // DRV_TOUCH_*
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+  // Report any debug info (before init) if enabled
+  #if defined(DBG_DRIVER)
+  // TODO
+  #endif
+
+  // Initialize any library-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    pDriver->nColBkgnd = GSLC_COL_BLACK;
+
+    // These displays can accept partial redraw as they retain the last
+    // image in the controller graphics RAM
+    pGui->bRedrawPartialEn = true;
+
+    // Support any additional initialization prior to display init
+    #ifdef DRV_DISP_ADAGFX_SEESAW
+      // Special initialization for Adafruit Seesaw chip
+      if (!m_seesaw.begin()) {
+       GSLC_DEBUG_PRINT("ERROR: Adafruit seesaw not initialized", "");
+      } else {
+        #if !defined(INIT_MSG_DISABLE)
+        GSLC_DEBUG_PRINT("- Adafruit seesaw OK\n", "");
+        #endif
+      }
+      m_seesaw.setBacklight(TFTSHIELD_BACKLIGHT_OFF);
+      m_seesaw.tftReset();
+      m_seesaw.setBacklight(TFTSHIELD_BACKLIGHT_ON);
+    #endif
+
+    // Perform any display initialization
+    #if defined(DRV_DISP_ADAGFX_ILI9341) || defined(DRV_DISP_ADAGFX_ILI9341_STM) || defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+
+      #if (ADAGFX_SPI_SET) // Use extra SPI initialization (eg. on Teensy devices)
+        // TODO: Consider check for GSLC_DEV_TEENSY
+        // If ADAGFX_SPI_SET is enabled, then perform additional SPI initialization.
+        // This may be required for certain pinouts with Teensy 3 devices.
+        // If enabled, it must be done ahead of m_disp.begin()
+        SPI.setMOSI(ADAGFX_PIN_MOSI);
+        SPI.setSCK(ADAGFX_PIN_CLK);
+      #endif
+
+      m_disp.begin();
+      m_disp.readcommand8(ILI9341_RDMODE);
+      m_disp.readcommand8(ILI9341_RDMADCTL);
+      m_disp.readcommand8(ILI9341_RDPIXFMT);
+      m_disp.readcommand8(ILI9341_RDIMGFMT);
+      m_disp.readcommand8(ILI9341_RDSELFDIAG);
+
+      #if defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+        // ILI9341_DUE_MB library defaults to "solid" mode, so we
+        // initialize it to transparent mode for text rendering consistency.
+        m_disp.setFontMode(gTextFontModeTransparent);
+        // The ILI9341_DUE_MB library does not automatically
+        // assign a default font, so we will do that here.
+        m_disp.setFont(SystemFont5x7);
+      #endif
+
+    #elif defined(DRV_DISP_ADAGFX_ILI9341_8BIT)
+      uint16_t identifier = m_disp.readID();
+      m_disp.begin(identifier);
+
+    #elif defined(DRV_DISP_ADAGFX_ILI9341_T3)
+      m_disp.begin();
+
+    #elif defined(DRV_DISP_ADAGFX_SSD1306)
+      m_disp.begin(SSD1306_SWITCHCAPVCC);
+
+    #elif defined(DRV_DISP_ADAGFX_ST7735)
+
+      // ST7735 requires additional initialization depending on
+      // display type. Enable the user to specify the
+      // configuration via DRV_DISP_ADAGFX_ST7735_INIT.
+      #ifndef DRV_DISP_ADAGFX_ST7735_INIT
+        m_disp.initR(INITR_144GREENTAB);  // Default to Green Tab 1.44"
+      #else
+        m_disp.initR(DRV_DISP_ADAGFX_ST7735_INIT);
+      #endif
+
+    #elif defined(DRV_DISP_ADAGFX_HX8347)
+      m_disp.begin();
+
+    #elif defined(DRV_DISP_ADAGFX_HX8357)
+      m_disp.begin(HX8357D);
+
+    #elif defined(DRV_DISP_ADAGFX_PCD8544)
+      m_disp.begin();
+      //m_disp.setContrast(50); Set the contrast level
+
+    #elif defined(DRV_DISP_ADAGFX_RA8875)
+      // RA8875 requires additional initialization depending on
+      // display type. Enable the user to specify the
+      // configuration via DRV_DISP_ADAGFX_RA8875_INIT.
+      bool bInitOk = true;
+      #ifndef DRV_DISP_ADAGFX_RA8875_INIT
+        bInitOk = m_disp.begin(RA8875_800x480);  // Default to 800x480
+      #else
+        bInitOk = m_disp.begin(DRV_DISP_ADAGFX_RA8875_INIT);
+      #endif
+      if (!bInitOk) {
+        GSLC_DEBUG_PRINT("ERROR: RA8875 init failed\n", "");
+        return false;
+      }
+      m_disp.displayOn(true);
+      m_disp.GPIOX(true); // Enable TFT - display enable tied to GPIOX
+      m_disp.PWM1config(true, RA8875_PWM_CLK_DIV1024); // PWM output for backlight
+      m_disp.PWM1out(255);
+      m_disp.graphicsMode(); // Go back to graphics mode
+    
+    #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+      // RA8875 requires additional initialization depending on
+      // display type. Enable the user to specify the
+      // configuration via DRV_DISP_ADAGFX_RA8875_INIT.
+      #ifndef DRV_DISP_ADAGFX_RA8875_SUMO_INIT
+        m_disp.begin(RA8875_800x480);  // Default to 800x480
+      #else
+        m_disp.begin(DRV_DISP_ADAGFX_RA8875_SUMO_INIT);
+      #endif
+      // As the RA8875_t4 library doesn't currently support font dimensioning
+      // APIs for the internal/hardware RA8875 font, we will default to using
+      // an Adafruit-GFX style font from mjs513/ILI9341_fonts:
+      m_disp.setFont(LiberationSans_9);
+      m_disp.fillWindow(0);        
+
+    #elif defined(DRV_DISP_ADAGFX_RA8876)
+      m_disp.init();
+      //pinMode(RA8876_BACKLIGHT, OUTPUT);  // Set backlight pin to OUTPUT mode
+      //digitalWrite(RA8876_BACKLIGHT, HIGH);  // Turn on backlight
+      m_disp.clearScreen(0);
+
+    #elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+      m_disp.init();
+      m_disp.clearScreen(0);
+
+    #elif defined(DRV_DISP_ADAGFX_MCUFRIEND)
+      uint16_t identifier = m_disp.readID();
+      // Support override for MCUFRIEND ID auto-detection
+      #if defined(DRV_DISP_ADAGFX_MCUFRIEND_FORCE)
+        m_disp.begin(DRV_DISP_ADAGFX_MCUFRIEND_FORCE);
+        #if !defined(INIT_MSG_DISABLE)
+        GSLC_DEBUG_PRINT("- MCUfriend ID forced\n","");
+        #endif
+      #else
+        m_disp.begin(identifier);
+      #endif
+
+    #elif defined(DRV_DISP_LCDGFX)
+      m_disp.begin();
+      // Establish default font
+      m_disp.setFixedFont(ssd1306xled_font6x8);
+
+    #elif defined(DRV_DISP_WAVESHARE_ILI9486)
+      SPI.begin();
+      m_disp.begin();
+
+    #endif
+
+    // Now that we have initialized the display, we can assign
+    // the rotation parameters and clipping region
+    gslc_DrvRotate(pGui,GSLC_ROTATE);
+
+
+    // Initialize SD card usage
+    #if (GSLC_SD_EN)
+    if (!SD.begin(ADAGFX_PIN_SDCS)) {
+      GSLC_DEBUG_PRINT("ERROR: DrvInit() SD init failed\n",0);
+      return false;
+    }
+    #endif
+
+  }
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (void*)(&m_disp);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // GUIslice adapter for Adafruit-GFX doesn't preload the
+  // images into RAM (to keep RAM requirements low), so we
+  // don't need to do any further processing here. Instead,
+  // the loading is done during render.
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    return NULL;  // No image preload done
+  }
+
+  // Default
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->nColBkgnd = nCol;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefNorm = sImgRef;
+  return true; // TODO
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefGlow = sImgRef;
+  return true; // TODO
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // NOTE: The clipping rect is currently saved in the
+  // driver struct, but the drawing code does not currently
+  // use it.
+  gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pRect == NULL) {
+    // Default to entire display
+    pDriver->rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  } else {
+    pDriver->rClipRect = *pRect;
+  }
+
+  // TODO: For ILI9341, perhaps we can leverage m_disp.setAddrWindow(x0, y0, x1, y1)?
+  return true;
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz)
+{
+  // Arduino mode currently only supports font definitions from memory
+  if (eFontRefType != GSLC_FONTREF_PTR) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvFontAdd(%s) failed - Arduino only supports memory-based fonts\n","");
+    return NULL;
+  }
+  // Return pointer to Adafruit-GFX GFXfont structure
+  return pvFontRef;
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  // Nothing to deallocate
+}
+
+// Centralized code for driver-specific font initiailization
+// Font init is often reused by both DrvGetTxtSize() and DrvDrawTxt()
+// hence there is value in centralizing the initialization.
+bool gslc_DrvFontSetHelp(gslc_tsGui* pGui,gslc_tsFont* pFont)
+{
+#if defined(DRV_DISP_ADAGFX_RA8876)
+  uint16_t  nTxtScale = 0;
+
+
+  // TODO: Add support for user defined fonts
+  // TODO: Support FLASH strings, custom font dimensions
+  // - For now, hardcode assumption of 8x16 built-in "embedded" font
+  int16_t nFontSel = RA8876_FONT_SIZE_16;
+
+  nTxtScale = pFont->nSize;
+  if ((nTxtScale >= 1) && (nTxtScale <= 3)) {
+    // Convert text scale into embedded font
+    nFontSel = RA8876_FONT_SIZE_16 + (nTxtScale-1);
+    nTxtScale = 1;
+  }
+
+  uint8_t nFontModeRom;
+  uint8_t nFontModeFamily;
+  int16_t nFontRefMode = 0;
+  if (pFont->eFontRefMode == GSLC_FONTREF_MODE_DEFAULT) {
+    // Default to internal ROM font
+    m_disp.selectInternalFont((enum FontSize) nFontSel);
+  } else if (pFont->eFontRefMode == GSLC_FONTREF_MODE_1) {
+    // Reserved for rendered fonts (not yet supported in RA8876 lib)
+  } else {
+    // All other encodings represent an external ROM font
+    // - These values are packed into the integer value as follows:
+    //    [1:0] GSLC_FONTREF_MODE_2  (==2)
+    //    [3:2] RA8876_FONT_FAMILY_x (0..3 defined)
+    //    [7:4] RA8876_FONT_ROM_x    (0..6 defined)
+    // - GSLC_FONTREF_MODE_2 + RA8876_FONT_ROM_x << 4 + RA8876_FONT_FAMILY_x << 2
+    nFontRefMode = (int16_t)(pFont->eFontRefMode);
+    nFontModeRom = (nFontRefMode >> 4) & 0xF;
+    nFontModeFamily = (nFontRefMode >> 2) & 0x3;
+    m_disp.initExternalFontRom(0, (enum ExternalFontRom)nFontModeRom);
+    m_disp.selectExternalFont((enum ExternalFontFamily)nFontModeFamily, (enum FontSize)nFontSel, RA8876_FONT_ENCODING_ASCII);
+  }
+
+  m_disp.setTextScale(nTxtScale);
+
+  return true;
+#else
+  return true;
+#endif // DRV_DISP_*
+
+}
+
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  uint16_t  nTxtScale = 0;
+
+#if defined(DRV_DISP_ADAGFX_ILI9341_T3)
+  // Use PaulStoffregen/ILI9341_t3
+  //
+  // - IMPORTANT NOTE: Recent version of ILI9341_t3 library is required
+  // - If you see a compilation error such as the following, then you
+  //   need to update your ILI9341_t3 library to a more recent version:
+  //     error: 'class ILI9341_t3' has no member named 'measureTextWidth'
+  //     error: 'class ILI9341_t3' has no member named 'measureTextHeight'
+  // - To update ILI9341_t3 to the latest, please follow the guidance here:
+  //    https://github.com/ImpulseAdventure/GUIslice/wiki/Install-ILI9341_t3-for-Teensy
+
+  // Fetch the string dimensions
+  // - Note that the following APIs (measureTextHeight / measureTextWidth)
+  //   were recently added to ILI9341_t3, so the latest version of
+  //   the library from GitHub should be used.
+
+  const ILI9341_t3_font_t* pT3Font = NULL;
+  switch (pFont->eFontRefMode) {
+  case GSLC_FONTREF_MODE_DEFAULT:
+  default:
+    // Default Adafruit-GFX font
+    m_disp.setFontAdafruit();
+    break;
+  case GSLC_FONTREF_MODE_1:
+    // T3 font
+    pT3Font = (const ILI9341_t3_font_t*)(pFont->pvFont);
+    m_disp.setFont(*pT3Font);
+    break;
+  }
+
+  nTxtScale = pFont->nSize;
+  m_disp.setTextSize(nTxtScale);
+
+  // Fetch the font sizing
+  *pnTxtSzW = m_disp.measureTextWidth(pStr,0);  // NOTE: If compile error, see note https://github.com/ImpulseAdventure/GUIslice/wiki/Install-ILI9341_t3-for-Teensy
+  *pnTxtSzH = m_disp.measureTextHeight(pStr,0); // NOTE: If compile error, see note https://github.com/ImpulseAdventure/GUIslice/wiki/Install-ILI9341_t3-for-Teensy
+
+  // Debug: report font sizing
+  // GSLC_DEBUG2_PRINT("DBG:GetTxtSize: [%s] w=%d h=%d scale=%d\n",
+  //   pStr,*pnTxtSzW,*pnTxtSzH,nTxtScale);
+
+  // TODO: Support for extracting baseline info from Teensy fonts?
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  return true;
+
+#elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+  if (pFont->pvFont == NULL) {
+    m_disp.setFont(SystemFont5x7);
+  } else {
+    m_disp.setFont((gTextFont)(pFont->pvFont));
+  }
+  nTxtScale = pFont->nSize;
+  m_disp.setTextScale(nTxtScale);
+
+  // Fetch the font sizing
+  *pnTxtSzW = m_disp.getStringWidth(pStr);
+  *pnTxtSzH = nTxtScale * m_disp.getFontHeight();
+
+  // No baseline info
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  return true;
+
+#elif defined(DRV_DISP_LCDGFX)
+  // TODO: Add support for user defined fonts
+  m_disp.setFixedFont(ssd1306xled_font6x8); // FIXME
+
+  *pnTxtSzW = m_disp.getFont().getTextSize(pStr,pnTxtSzH);
+  // FIXME: Add *pnTxtSzH
+
+  // No baseline info
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  return true;
+
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+
+  // Initialize the current font mode & size
+  gslc_DrvFontSetHelp(pGui,pFont);
+
+  // Estimate the string sizing
+
+  nTxtScale = pFont->nSize;
+
+  // NOTE: The following accurately defines the dimensions
+  //        of the fixed fonts. Proportional fonts (eg. from
+  //        external ROM font chips) will not be accurately
+  //        measured as the underlying RA8876 library doesn't
+  //        currently support an API to retrieve the character width.
+
+  // TODO: Add support for FLASH-based strings
+  // TODO: Add support for custom fonts
+  *pnTxtSzW = strlen(pStr) * (nTxtScale+1)*4;
+  *pnTxtSzH =                (nTxtScale+1)*8;
+
+  // No baseline info
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  return true;
+
+#elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+  // Use mjs513/RA8875: branch "RA8875_t4"
+  const ILI9341_t3_font_t* pT3Font = NULL;
+  switch (pFont->eFontRefMode) {
+  case GSLC_FONTREF_MODE_DEFAULT:
+  default:
+    if (pFont->pvFont == NULL) {
+      // FIXME: The RA8875_t4 library does not currently support font dimension APIs
+      // so we are going to select an Adafruit-GFX font as the default for now.
+      m_disp.setFont(LiberationSans_9);
+    } else {
+      // Default Adafruit-GFX font - UNTESTED
+      m_disp.setFontAdafruit();
+    }
+    break;
+  case GSLC_FONTREF_MODE_1:
+    // T3 font
+    pT3Font = (const ILI9341_t3_font_t*)(pFont->pvFont);
+    m_disp.setFont(*pT3Font);
+    break;
+  }
+
+  nTxtScale = pFont->nSize;
+  m_disp.setTextSize(nTxtScale);
+
+  // Fetch the font sizing
+  m_disp.getTextBounds((char*)pStr,0,0,pnTxtX,pnTxtY,pnTxtSzW,pnTxtSzH);
+
+  // Debug: report font sizing
+  //GSLC_DEBUG_PRINT("DBG:GetTxtSize: [%s] w=%d h=%d scale=%d\n",
+     //pStr,*pnTxtSzW,*pnTxtSzH,nTxtScale);
+
+  return true;
+
+#else
+
+  // Support library-specific font exceptions
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    if (pFont->pvFont == NULL) {
+      // Internal ROM font
+      m_disp.selectInternalFont(RA8876_FONT_SIZE_16);
+    } else {
+      // Custom font
+      m_disp.setFont((const FONT_INFO *)pFont->pvFont);
+    }
+  #else
+    m_disp.setFont((const GFXfont *)pFont->pvFont);
+  #endif
+
+  nTxtScale = pFont->nSize;
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    m_disp.setTextScale(nTxtScale); // TODO: Test this
+  #else
+    m_disp.setTextSize(nTxtScale);
+  #endif
+
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_RAM) {
+    // Fetch the text bounds
+    m_disp.getTextBounds((char*)pStr,0,0,pnTxtX,pnTxtY,pnTxtSzW,pnTxtSzH);
+
+  } else if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    #if (GSLC_USE_PROGMEM)
+    uint16_t nTxtLen = strlen_P(pStr);
+    char tempStr[nTxtLen+1];
+    strncpy_P(tempStr,pStr,nTxtLen);
+    tempStr[nTxtLen] = '\0';  // Force termination
+
+    // Fetch the text bounds
+    m_disp.getTextBounds(tempStr,0,0,pnTxtX,pnTxtY,pnTxtSzW,pnTxtSzH);
+    #else
+    // NOTE: Should not get here
+    // - The text string has been marked as being stored in
+    //   FLASH via PROGMEM (typically for Arduino) but
+    //   the current device does not support the PROGMEM
+    //   methodology.
+    // - Degrade back to using SRAM directly
+
+    // Fetch the text bounds
+    m_disp.getTextBounds((char*)pStr,0,0,pnTxtX,pnTxtY,pnTxtSzW,pnTxtSzH);
+    #endif
+  }
+
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // TODO: Add default font
+  #else
+    m_disp.setFont();
+  #endif
+  return true;
+
+#endif // DRV_DISP_*
+
+}
+
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t  nTxtScale = pFont->nSize;
+  uint16_t  nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  int16_t   nCurPosY = 0;
+  char      ch;
+
+  // Initialize the font and positioning
+#if defined(DRV_DISP_ADAGFX_ILI9341_T3)
+  const ILI9341_t3_font_t* pT3Font = NULL;
+  switch (pFont->eFontRefMode) {
+  case GSLC_FONTREF_MODE_DEFAULT:
+  default:
+    // Default Adafruit-GFX font
+    m_disp.setFontAdafruit();
+    break;
+  case GSLC_FONTREF_MODE_1:
+    // T3 font
+    pT3Font = (const ILI9341_t3_font_t*)(pFont->pvFont);
+    m_disp.setFont(*pT3Font);
+    break;
+  }
+  m_disp.setTextColor(nColRaw);
+  m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextSize(nTxtScale);
+#elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+  if (pFont->pvFont == NULL) {
+    m_disp.setFont(SystemFont5x7);
+  } else {
+    m_disp.setFont((gTextFont)(pFont->pvFont));
+  }
+  m_disp.setTextColor(nColRaw);
+  m_disp.cursorToXY(nTxtX,nTxtY);
+  m_disp.setTextScale(nTxtScale);
+#elif defined(DRV_DISP_LCDGFX)
+  // TODO: Add support for user defined fonts
+  m_disp.setFixedFont(ssd1306xled_font6x8);
+  m_disp.setColor(nColRaw);
+  // As LCDGFX doesn't support a setCursor() API to update the text
+  // coordinates, we will retain a static variable here.
+  static int16_t m_nTxtX; // Text cursor coordinate (X)
+  static int16_t m_nTxtY; // Text cursor coordinate (Y)
+  m_nTxtX = nTxtX;
+  m_nTxtY = nTxtY;
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+
+  // Initialize the current font mode & size
+  gslc_DrvFontSetHelp(pGui,pFont);
+
+  m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextColor(nColRaw);
+
+#elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+  const ILI9341_t3_font_t* pT3Font = NULL;
+  switch (pFont->eFontRefMode) {
+  case GSLC_FONTREF_MODE_DEFAULT:
+  default:
+    // Force default font (see earlier notes)
+    //m_disp.setFontAdafruit();
+    m_disp.setFont(LiberationSans_9);
+    break;
+  case GSLC_FONTREF_MODE_1:
+    // T3 font
+    pT3Font = (const ILI9341_t3_font_t*)(pFont->pvFont);
+    m_disp.setFont(*pT3Font);
+    break;
+  }
+  m_disp.setTextColor(nColRaw);
+  m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextSize(nTxtScale);
+#else
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    if (pFont->pvFont == NULL) {
+      // Internal ROM font
+      m_disp.selectInternalFont(RA8876_FONT_SIZE_16);
+    } else {
+      // Custom font
+      m_disp.setFont((const FONT_INFO *)pFont->pvFont);
+    }
+  #else
+    m_disp.setFont((const GFXfont *)pFont->pvFont);
+  #endif
+  m_disp.setTextColor(nColRaw);
+  m_disp.setCursor(nTxtX,nTxtY);
+  #if defined(DRV_DISP_ADAGFX_RA8876_GV)
+    m_disp.setTextScale(nTxtScale); // TODO: Support scaling
+  #else
+    m_disp.setTextSize(nTxtScale);
+  #endif
+#endif
+
+  // Driver-specific overrides
+  #if defined(DRV_DISP_ADAGFX_RA8875)
+    // TODO: Add a mode to use the RA8875's internal ROM font
+    // - Note that it is larger than the default Adafruit-GFX font
+    //   so for now we won't use it. It is expected that it should
+    //   be much faster.
+    bool bInternal8875Font = false;
+
+    if (bInternal8875Font) {
+      uint16_t nColBgRaw = gslc_DrvAdaptColorToRaw(colBg);
+      // Enter text mode when using RA8875 built-in fonts
+      m_disp.textMode();
+      nTxtScale = (nTxtScale > 0) ? nTxtScale : 0;
+      // Adapt to RA8875 text scaling with 0-based notation
+      m_disp.textEnlarge(nTxtScale - 1);
+      m_disp.textColor(nColRaw, nColBgRaw);
+      m_disp.textSetCursor(nTxtX, nTxtY);
+    }
+  #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+    bool bInternal8875Font = false;
+  #endif // DRV_DISP_*
+
+  // Default to accessing RAM directly (GSLC_TXT_MEM_RAM)
+  bool bProg = false;
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    bProg = true;
+  }
+
+  while (1) {
+    // Fetch the next character
+    if (!bProg) {
+      // String in SRAM; can access buffer directly
+      ch = *(pStr++);
+    } else {
+      // String in PROGMEM (flash); must access via pgm_* calls
+      ch = pgm_read_byte(pStr++);
+    }
+
+    // Detect string terminator
+    if (ch == 0) {
+      break;
+    }
+
+    // Render the character
+    #if defined(DRV_DISP_ADAGFX_RA8875)
+      // When using custom fonts, we 
+      if (bInternal8875Font) {
+        // Use the default font, so call the RA8875 textWrite() function
+        m_disp.textWrite((const char *)&ch, 1);
+      } else {
+        // Use Adafruit-GFX for rendering
+        // - When using a custom Adafruit-GFX font with RA8875, we need to
+        //   call the Adafruit-GFX base class write() function instead of
+        //   the overloaded version in Adafruit_RA8875
+        //   This is because Adafruit_RA8875 has overloaded the write() calls
+        //   in a way that is not compatible with the Adafruit-GFX font rendering.
+        m_disp.Adafruit_GFX::write(ch);
+      }
+
+    #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+      m_disp.write((const char *)&ch, 1);
+      //m_disp.print(ch); // Alternate?
+    #elif defined(DRV_DISP_ADAGFX_RA8876)
+      m_disp.putChar(ch);
+
+    #elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+      // The ILI9341_DUE_MB library utilizes the API setTextLetterSpacing()
+      // to control the kerning / spacing between letters in a string.
+      // With a "letter spacing" (_letterSpacing variable in the lib) of
+      // 0, the characters will be horizontally abutted. Therefore, a
+      // small non-zero _letterSpacing is typically used (default is 2).
+      //
+      // When printing a string with ILI9341_DUE_MB, the cursor is automatically
+      // advanced after every character. The ILI9341_DUE_MB library increments
+      // the current text cursor by the character width plus the _letterSpacing
+      // (multiplied by the text scale factor). However, the ILI9341_DUE_MB treats
+      // the first character of a string differently from the remainder in that the
+      // _letterSpacing is not used in the first character.
+      //
+      // Since we are rendering individual characters, we need to adjust the
+      // cursor position to advance the _letterSpacing offset accordingly.
+
+      // Print the character
+      // - Note that this will automatically advance the text cursor
+      m_disp.print(ch);
+
+      // Now account for the _letterSpacing
+      int16_t nCurPosX = 0;
+      nCurPosY = m_disp.getCursorY();
+      nCurPosX = m_disp.getCursorX();
+      nCurPosX += m_disp.getTextLetterSpacing() * nTxtScale;
+      m_disp.cursorToXY(nCurPosX,nCurPosY);
+
+    #elif defined(DRV_DISP_LCDGFX)
+      // Create dummy string for character render
+      char chStr[2];
+      chStr[0] = ch;
+      chStr[1] = 0;
+      m_disp.printFixed(m_nTxtX, m_nTxtY, chStr, STYLE_NORMAL);
+      // Advance the text cursor
+	    m_nTxtX += m_disp.getFont().getTextSize(chStr, NULL);
+
+    #else
+      // Call Adafruit-GFX for rendering
+      // NOTE: This should automatically advance the "cursor" (current text position)
+      m_disp.print(ch);
+    #endif
+
+    // Handle multi-line text:
+    // If we just output a newline, Adafruit-GFX will automatically advance
+    // the Y cursor but reset the X cursor to 0. Therefore we need to
+    // readjust the X cursor to our aligned bounding box.
+    if (ch == '\n') {
+
+      #if defined(DRV_DISP_ADAGFX_RA8875)
+        nCurPosY = m_disp.getCursorY();
+        if (bInternal8875Font) {
+          // TODO: Is getCursorY() supported in RA8875 mode?
+          m_disp.textSetCursor(nTxtX, nCurPosY);
+        }
+      #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+        nCurPosY = m_disp.getCursorY();
+        if (bInternal8875Font) {
+          // TODO: Is getCursorY() supported in RA8875 mode?
+          m_disp.setCursor(nTxtX, nCurPosY);
+        }
+
+      #elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+        nTxtY += m_disp.getFontHeight();
+        m_disp.cursorToXY(nTxtX,nTxtY);
+
+      #elif defined(DRV_DISP_LCDGFX)
+	    m_nTxtY += m_disp.getFont().getHeader().height;
+
+      #else
+        nCurPosY = m_disp.getCursorY();
+        m_disp.setCursor(nTxtX,nCurPosY);
+      #endif
+    }
+
+  } // while(1)
+
+  #if defined(DRV_DISP_ADAGFX_RA8875)
+  if (bInternal8875Font) {
+    // Return to RA8875 graphics mode
+    m_disp.graphicsMode();
+  }
+  #endif // DRV_DISP_ADAGFX_RA8875
+
+  // Restore the font
+#if defined(DRV_DISP_ADAGFX_ILI9341_T3)
+  // TODO
+#elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+  // TODO
+#elif defined(DRV_DISP_LCDGFX)
+  // TODO
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+  // TODO
+#elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+  // TODO
+#elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+  // TODO
+#else
+  m_disp.setFont();
+#endif
+
+  return true;
+}
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  #if defined(DRV_DISP_ADAGFX_SSD1306)
+    // Show the display buffer on the hardware.
+    // NOTE: You _must_ call display after making any drawing commands
+    // to make them visible on the display hardware!
+    m_disp.display();
+    // TODO: Might need to call m_disp.clearDisplay() now?
+
+  #else
+    // Nothing to do as we're not double-buffered
+
+  #endif
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+inline void gslc_DrvDrawPoint_base(int16_t nX, int16_t nY, uint16_t nColRaw)
+{
+  #if defined(DRV_DISP_LCDGFX)
+    NanoPoint p;
+    p.setPoint(nX, nY);
+    m_disp.setColor(nColRaw);
+    m_disp.putPixel(nX,nY);
+  #else
+    m_disp.drawPixel(nX,nY,nColRaw);
+  #endif
+}
+
+inline void gslc_DrvDrawLine_base(int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,uint16_t nColRaw)
+{
+  #if defined(DRV_DISP_LCDGFX)
+    m_disp.setColor(nColRaw);
+    m_disp.drawLine(nX0,nY0,nX1,nY1);
+  #else
+    m_disp.drawLine(nX0,nY0,nX1,nY1,nColRaw);
+  #endif	
+}
+
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipPt(&pDriver->rClipRect,nX,nY)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawPoint_base(nX, nY, nColRaw);
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+  return false;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipRect(&pDriver->rClipRect,&rRect)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  #if defined(DRV_DISP_LCDGFX)
+    NanoRect r;
+    r.setRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1);
+    m_disp.setColor(nColRaw);
+	  m_disp.fillRect(r);
+  #elif defined(DRV_DISP_ADAGFX_RA8876) || defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // xlatb/RA8876 uses a non-standard fillRect() API
+    m_disp.fillRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1,nColRaw);
+  #else
+    m_disp.fillRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+  #endif
+  return true;
+}
+
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FILL)
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  // - TODO: Optimize the following, perhaps with new ClipLineHV()
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  int16_t nX0, nY0, nX1, nY1;
+  // Top
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Bottom
+  nX0 = rRect.x;
+  nY0 = rRect.y + rRect.h - 1;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Left
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Right
+  nX0 = rRect.x + rRect.w - 1;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+#else
+  #if defined(DRV_DISP_LCDGFX)
+    NanoRect r;
+    r.setRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1);
+    m_disp.setColor(nColRaw);
+	  m_disp.drawRect(r);
+  #elif defined(DRV_DISP_ADAGFX_RA8876) || defined(DRV_DISP_ADAGFX_RA8876_GV)
+    m_disp.drawRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1,nColRaw);
+  #else
+    m_disp.drawRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+  #endif
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  m_disp.drawRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipLine(&pDriver->rClipRect,&nX0,&nY0,&nX1,&nY1)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawLine_base(nX0,nY0,nX1,nY1,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFrameCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FILL)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FRAME)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FILL)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+
+
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Adafruit_GFX.cpp
+//   Original author:  Adafruit
+//   Function:         drawBitmap()
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer using the foreground color defined in the
+// header (unset bits are transparent).
+
+// GUIslice modified the raw memory format to add a header:
+// Image array format:
+// - Width[15:8],  Width[7:0],
+// - Height[15:8], Height[7:0],
+// - ColorR[7:0],  ColorG[7:0],
+// - ColorB[7:0],  0x00,
+// - Monochrome bitmap follows...
+//
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,
+ const unsigned char *pBitmap,bool bProgMem)
+ {
+  const unsigned char*  bmap_base = pBitmap;
+  int16_t         w,h;
+  gslc_tsColor    nCol;
+
+  // Read header
+  w       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  w      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  h       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  h      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  nCol.r  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.g  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.b  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  bmap_base++;
+
+  int16_t i, j, byteWidth = (w + 7) / 8;
+  uint8_t nByte = 0;
+
+  for(j=0; j<h; j++) {
+    for(i=0; i<w; i++) {
+      if(i & 7) nByte <<= 1;
+      else {
+        if (bProgMem) {
+          nByte = pgm_read_byte(bmap_base + j * byteWidth + i / 8);
+        } else {
+          nByte = bmap_base[j * byteWidth + i / 8];
+        }
+      }
+      if(nByte & 0x80) {
+        gslc_DrvDrawPoint(pGui,nDstX+i,nDstY+j,nCol);
+      }
+    }
+  }
+}
+// ----- REFERENCE CODE end
+
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem)
+{
+  // AdaFruit GFX doesn't have a routine for this so we output pixel by pixel
+  const uint16_t* pImage = (const uint16_t*)pBitmap;
+  int16_t h, w;
+  if (bProgMem) {
+    h = pgm_read_word(pImage++);
+    w = pgm_read_word(pImage++);
+  } else {
+    h = *(pImage++);
+    w = *(pImage++);
+  }
+  #if defined(DBG_DRIVER)
+  GSLC_DEBUG_PRINT("DBG: DrvDrawBmp24FromMem() w=%d h=%d\n", w, h);
+  #endif
+  #if (DRV_HAS_DRAW_BMP_MEM)
+  if (!bProgMem) {
+    m_disp.drawRGBBitmap(nDstX, nDstY, (uint16_t*) pImage,w, h); 
+    return;
+  }
+  #endif
+  int row, col;
+  for (row=0; row<h; row++) { // For each scanline...
+    for (col=0; col<w; col++) { // For each pixel...
+      if (bProgMem) {
+        //To read from Flash Memory, pgm_read_XXX is required.
+        //Since image is stored as uint16_t, pgm_read_word is used as it uses 16bit address
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, pgm_read_word(pImage++));
+      } else {
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, *(pImage++));
+      }
+    } // end pixel
+  }
+}
+
+#if (GSLC_SD_EN)
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/spitftbitmap/spitftbitmap.ino
+//   Original author:  Adafruit
+//   Function:         bmpDraw()
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+uint16_t gslc_DrvRead16SD(File &f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t gslc_DrvRead32SD(File &f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+void gslc_DrvDrawBmp24FromSD(gslc_tsGui* pGui,const char *filename, uint16_t x, uint16_t y)
+{
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  uint8_t  sdbuffer[3*GSLC_SD_BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+  boolean  goodBmp = false;       // Set to true on valid header parse
+  boolean  flip    = true;        // BMP is stored bottom-to-top
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0, startTime = millis();
+  (void)startTime; // Unused
+
+  if((x >= pGui->nDispW) || (y >= pGui->nDispH)) return;
+
+  //Serial.println();
+  //Serial.print("Loading image '");
+  //Serial.print(filename);
+  //Serial.println('\'');
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(filename)) == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() file not found [%s]",filename);
+    return;
+  }
+  // Parse BMP header
+  if(gslc_DrvRead16SD(bmpFile) == 0x4D42) { // BMP signature
+    uint32_t nFileSize = gslc_DrvRead32SD(bmpFile);
+    (void)nFileSize; // Unused
+    //Serial.print("File size: "); Serial.println(nFileSize);
+    (void)gslc_DrvRead32SD(bmpFile); // Read & ignore creator bytes
+    bmpImageoffset = gslc_DrvRead32SD(bmpFile); // Start of image data
+    //Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
+    // Read DIB header
+    uint32_t nHdrSize = gslc_DrvRead32SD(bmpFile);
+    (void)nHdrSize; // Unused
+    //Serial.print("Header size: "); Serial.println(nHdrSize);
+    bmpWidth  = gslc_DrvRead32SD(bmpFile);
+    bmpHeight = gslc_DrvRead32SD(bmpFile);
+    if(gslc_DrvRead16SD(bmpFile) == 1) { // # planes -- must be '1'
+      bmpDepth = gslc_DrvRead16SD(bmpFile); // bits per pixel
+      //Serial.print("Bit Depth: "); Serial.println(bmpDepth);
+      if((bmpDepth == 24) && (gslc_DrvRead32SD(bmpFile) == 0)) { // 0 = uncompressed
+        goodBmp = true; // Supported BMP format -- proceed!
+        //Serial.print("Image size: ");
+        //Serial.print(bmpWidth);
+        //Serial.print('x');
+        //Serial.println(bmpHeight);
+
+        // BMP rows are padded (if needed) to 4-byte boundary
+        rowSize = (bmpWidth * 3 + 3) & ~3;
+
+        // If bmpHeight is negative, image is in top-down order.
+        // This is not canon but has been observed in the wild.
+        if(bmpHeight < 0) {
+          bmpHeight = -bmpHeight;
+          flip      = false;
+        }
+
+        // Crop area to be loaded
+        w = bmpWidth;
+        h = bmpHeight;
+        if((x+w-1) >= pGui->nDispW) w = pGui->nDispW  - x;
+        if((y+h-1) >= pGui->nDispH) h = pGui->nDispH - y;
+
+        // Set TFT address window to clipped image bounds
+        //xxx tft.setAddrWindow(x, y, x+w-1, y+h-1);
+
+        for (row=0; row<h; row++) { // For each scanline...
+
+          // Seek to start of scan line.  It might seem labor-
+          // intensive to be doing this on every line, but this
+          // method covers a lot of gritty details like cropping
+          // and scanline padding.  Also, the seek only takes
+          // place if the file position actually needs to change
+          // (avoids a lot of cluster math in SD library).
+          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
+            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
+          else     // Bitmap is stored top-to-bottom
+            pos = bmpImageoffset + row * rowSize;
+          if(bmpFile.position() != pos) { // Need seek?
+            bmpFile.seek(pos);
+            buffidx = sizeof(sdbuffer); // Force buffer reload
+          }
+
+          for (col=0; col<w; col++) { // For each pixel...
+            // Time to read more pixel data?
+            if (buffidx >= sizeof(sdbuffer)) { // Indeed
+              bmpFile.read(sdbuffer, sizeof(sdbuffer));
+              buffidx = 0; // Set index to beginning
+            }
+
+            // Convert pixel from BMP to TFT format, push to display
+            b = sdbuffer[buffidx++];
+            g = sdbuffer[buffidx++];
+            r = sdbuffer[buffidx++];
+            //xxx tft.pushColor(tft.Color565(r,g,b));
+            gslc_tsColor nCol = (gslc_tsColor){r,g,b};
+            bool bDrawBit = true;
+            if (GSLC_BMP_TRANS_EN) {
+              gslc_tsColor nColTrans = pGui->sTransCol;
+              if ((nCol.r == nColTrans.r) && (nCol.g == nColTrans.g) && (nCol.b == nColTrans.b)) {
+                bDrawBit = false;
+              }
+            }
+            if (bDrawBit) {
+              gslc_DrvDrawPoint(pGui,x+col,y+row,nCol);
+            }
+
+          } // end pixel
+        } // end scanline
+        //Serial.print("Loaded in ");
+        //Serial.print(millis() - startTime);
+        //Serial.println(" ms");
+      } // end goodBmp
+    }
+  }
+  bmpFile.close();
+  if(!goodBmp) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() BMP format unknown [%s]",filename);
+  }
+}
+// ----- REFERENCE CODE end
+#endif // GSLC_SD_EN
+
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  #if defined(DBG_DRIVER)
+  char addr[6];
+  GSLC_DEBUG_PRINT("DBG: DrvDrawImage() with ImgBuf address=","");
+  sprintf(addr,"%04X",(unsigned int)sImgRef.pImgBuf);
+  GSLC_DEBUG_PRINT("%s\n",addr);
+  #endif
+
+  // GUIslice adapter library for Adafruit-GFX does not pre-load
+  // image data into memory before calling DrvDrawImage(), so
+  // we to handle the loading now (when rendering).
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return true;  // Nothing to do
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return false; // Not supported
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from SRAM
+      // - Dimensions and output color are defined in arrray header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in ram
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+#if (GSLC_USE_PROGMEM)
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // TODO: Probably need to fix this to work with PROGMEM,
+    //       but check (GSLC_USE_PROGMEM) first
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from program memory
+      // - Dimensions and output color are defined in array header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in flash
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+#endif
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD media
+    #if (GSLC_SD_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // 24-bit Bitmap
+        gslc_DrvDrawBmp24FromSD(pGui,sImgRef.pFname,nDstX,nDstY);
+        return true;
+      } else {
+        // Unsupported format
+        return false;
+      }
+    #else
+      // SD card access not enabled
+      return false;
+    #endif
+
+  } else {
+    // Unsupported source
+    GSLC_DEBUG2_PRINT("DBG: DrvDrawImage() unsupported source eImgFlags=%d\n", sImgRef.eImgFlags);
+    return false;
+  }
+}
+
+
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    // Check to see if an image has been assigned to the background
+    if (pGui->sImgRefBkgnd.eImgFlags == GSLC_IMGREF_NONE) {
+      // No image assigned, so assume flat color background
+      // TODO: Create a new eImgFlags enum to signal that the
+      //       background should be a flat color instead of
+      //       an image.
+
+      // NOTE: We don't call m_disp.fillScreen() here as
+      //       that API doesn't support clipping. Since
+      //       we may be redrawing the page with a clipping
+      //       region enabled, it is important that we don't
+      //       redraw the entire screen.
+      gslc_tsRect rRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+      gslc_DrvDrawFillRect(pGui, rRect, pDriver->nColBkgnd);
+    } else {
+      // An image should be loaded
+      // TODO: For now, re-use the DrvDrawImage(). Later, consider
+      //       extending to support different background drawing
+      //       capabilities such as stretching and tiling of background
+      //       image.
+      gslc_DrvDrawImage(pGui,0,0,pGui->sImgRefBkgnd);
+    }
+  }
+}
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (via display driver)
+// -----------------------------------------------------------------------
+
+
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+  // TODO
+  // Perform any driver-specific touchscreen init here
+  return true;
+}
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  // As the touch driver instance is optional, we need to check for
+  // its existence before returning a pointer to it.
+  #if defined(DRV_TOUCH_INSTANCE)
+    return (void*)(&m_touch);
+  #else
+    return NULL;
+  #endif
+}
+
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  // TODO
+  return false;
+}
+
+// ------------------------------------------------------------------------
+// Touch Functions (via external touch driver)
+// ------------------------------------------------------------------------
+
+
+#if defined(DRV_TOUCH_ADA_SIMPLE)
+
+  // --------------------------------------------------------------------------
+  // Enable Adafruit_TouchScreen workarounds
+  // --------------------------------------------------------------------------
+
+  // NOTE: The Adafruit_TouchScreen is not natively compatible with certain
+  //       devices (eg. ESP32) and also doesn't safeguard against pin-sharing
+  //       conflicts. For these and some other issues, the following workarounds
+  //       are optionally enabled.
+
+  // Enable workaround for ambiguity in Adafruit_TouchScreen pressure readings
+  // - See https://github.com/ImpulseAdventure/GUIslice/issues/96
+  #define FIX_4WIRE_Z // Comment out to disable
+
+  // Enable workaround for Adafruit_TouchScreen getPoint() altering
+  // the pin state and not restoring it. Without working around this,
+  // the touch handler may interfere with displays that share pins.
+  #define FIX_4WIRE_PIN_STATE // Comment out to disable
+
+  // --------------------------------------------------------------------------
+
+  // Disable certain workarounds for Adafruit_TouchScreen in STM32 & SAMD mode
+  // as we haven't implemented the equivalent pin save/restore code yet.
+  #if defined(ARDUINO_ARCH_STM32) || defined(__STM32F1__)
+    #undef FIX_4WIRE_PIN_STATE
+  #endif
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+  // NOTE: The Adafruit_TouchScreen library alters the state of several
+  //       pins during the course of reading the touch coordinates and
+  //       pressure. Unfortunately, it does not restore the prior state
+  //       which can impact other processes such as graphics drivers which
+  //       may share the same pins. The following routines are responsible
+  //       for saving and restoring the pin state and will wrap the
+  //       touch polling logic. If a future release of the Adafruit_TouchScreen
+  //       library addresses this issue, this wrapper logic can be removed.
+  //       For further reference, please refer to Issue #96.
+
+  /// Structure used to retain a port state (mode and level)
+  /// so that it can be restored later.
+  struct gslc_tsPinState
+  {
+    int     nMode;     // OUTPUT, INPUT, INPUT_PULLUP
+    bool    bIsHigh;   // Is an output and HIGH?
+  };
+
+  /// Return the current pinMode() for a pin
+  int gslc_TDrvGetPinMode(uint8_t nPin)
+  {
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+    // Not supported
+    return -1;
+
+    #else
+    if (nPin >= NUM_DIGITAL_PINS) {
+      return (-1);
+    }
+    uint8_t nBit            = digitalPinToBitMask(nPin);
+    uint8_t nPort           = digitalPinToPort(nPin);
+
+    // Determine if port is an output
+    volatile uint8_t *nReg  = portModeRegister(nPort);
+    if (*nReg & nBit) {
+      return (OUTPUT);
+    }
+
+    // Determine if port is an input and whether pullup is active
+    volatile  uint8_t *nOut = portOutputRegister(nPort);
+    return ((*nOut & nBit) ? INPUT_PULLUP : INPUT);
+
+    #endif
+  }
+
+  /// Fetch the current pin mode and level
+  inline void gslc_TDrvSavePinState(int nPin, gslc_tsPinState &sPinState)
+  {
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+      // Not supported
+      return;
+    #else
+
+    sPinState.nMode = gslc_TDrvGetPinMode(nPin);
+    sPinState.bIsHigh = digitalRead(nPin);
+
+    #endif
+  }
+
+  /// Restore the pin mode and level
+  inline void gslc_TDrvRestorePinState(int nPin,gslc_tsPinState sPinState)
+  {
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+      // Not supported
+      return;
+    #else
+
+    pinMode(nPin,sPinState.nMode);
+    if (sPinState.nMode == OUTPUT) digitalWrite(nPin,sPinState.bIsHigh);
+
+    #endif
+  }
+
+  #endif // FIX_4WIRE_PIN_STATE
+
+  // --------------------------------------------------------------------------
+
+#endif // DRV_TOUCH_ADA_SIMPLE
+
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+
+  // Capture default calibration settings for resistive displays
+  #if defined(DRV_TOUCH_TYPE_RES)
+    pGui->nTouchCalXMin = ADATOUCH_X_MIN;
+    pGui->nTouchCalXMax = ADATOUCH_X_MAX;
+    pGui->nTouchCalYMin = ADATOUCH_Y_MIN;
+    pGui->nTouchCalYMax = ADATOUCH_Y_MAX;
+  #endif // DRV_TOUCH_TYPE_RES
+
+  // Support touch controllers with swapped X & Y
+  #if defined(ADATOUCH_REMAP_YX)
+    // Capture swap setting from config file
+    pGui->bTouchRemapYX = ADATOUCH_REMAP_YX;
+  #else
+    // For backward compatibility with older config files
+    // that have not defined this config option
+    pGui->bTouchRemapYX = false;
+  #endif
+
+  #if defined(DRV_TOUCH_ADA_STMPE610)
+    #if (ADATOUCH_I2C_HW)
+    if (!m_touch.begin(ADATOUCH_I2C_ADDR)) {
+    #else
+    if (!m_touch.begin()) {
+    #endif
+      GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch() failed to init STMPE610\n",0);
+      return false;
+    } else {
+      return true;
+    }
+  #elif defined(DRV_TOUCH_ADA_FT6206)
+    if (!m_touch.begin(ADATOUCH_SENSITIVITY)) {
+      GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch() failed to init FT6206\n",0);
+      return false;
+    } else {
+      return true;
+    }
+  #elif defined(DRV_TOUCH_ADA_FT5206)
+    m_touch.begin();
+    m_touch.setTouchLimit(1);
+    return true;
+  #elif defined(DRV_TOUCH_ADA_SIMPLE)
+    return true;
+  #elif defined(DRV_TOUCH_XPT2046_STM)
+    m_touch.begin();
+    return true;
+  #elif defined(DRV_TOUCH_XPT2046_PS)
+    m_touch.begin();
+    // Since this XPT2046 library supports "touch rotation", and defaults
+    // to landscape orientation, rotate to traditional portrait orientation
+    // for consistency with other handlers.
+    //
+    // Unfortunately, this API (from 2018/01/04) is not available in the
+    // latest tagged release of XPT2046 in the Library Manager. Therefore,
+    // we can't use this API and instead need to hardcode the mapping
+    // during the DrvGetTouch() function.
+    //m_touch.setRotation(0);
+    return true;
+  #elif defined(DRV_TOUCH_ADA_RA8875)
+    m_disp.touchEnable(true);
+    return true;
+  #elif defined(DRV_TOUCH_ADA_RA8875_SUMO)
+    m_disp.touchEnable(true);
+    return true;
+  #elif defined(DRV_TOUCH_URTOUCH)
+    m_touch.InitTouch();
+    m_touch.setPrecision(PREC_MEDIUM);
+    // Disable touch remapping since URTouch handles it
+    gslc_SetTouchRemapEn(pGui, false);
+    return true;
+  #elif defined(DRV_TOUCH_INPUT)
+    // Nothing more to initialize for GPIO input control mode
+    return true;
+  #elif defined(DRV_TOUCH_HANDLER)
+    return true;
+  #else
+    // ERROR: Unsupported driver mode
+    GSLC_DEBUG_PRINT("ERROR: TDrvInitTouch() driver not supported yet\n",0);
+    return false;
+  #endif
+
+}
+
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+
+  #if defined(DRV_TOUCH_NONE)
+    return false;
+  #endif
+
+  // As the STMPE610 hardware driver doesn't appear to return
+  // an indication of "touch released" with a coordinate, we
+  // must detect the release transition here and send the last
+  // known coordinate but with pressure=0. To do this, we are
+  // allocating a static variable to maintain the last touch
+  // coordinate.
+  // TODO: This code can be reworked / simplified
+  static int16_t  m_nLastRawX     = 0;
+  static int16_t  m_nLastRawY     = 0;
+  static uint16_t m_nLastRawPress = 0;
+  static bool     m_bLastTouched  = false;
+
+  bool bValid = false;  // Indicate a touch event to GUIslice core?
+
+  // Define maximum bounds for display in native orientation
+  int nDispOutMaxX,nDispOutMaxY;
+  nDispOutMaxX = pGui->nDisp0W-1;
+  nDispOutMaxY = pGui->nDisp0H-1;
+
+  // ----------------------------------------------------------------
+  #if defined(DRV_TOUCH_ADA_STMPE610)
+
+  uint16_t  nRawX,nRawY;
+  uint8_t   nRawPress;
+
+  if (m_touch.touched()) {
+
+    if (m_touch.bufferEmpty()) {
+      // Nothing to do
+    } else {
+      while (!m_touch.bufferEmpty()) {
+        // Continued press; update next reading
+        // TODO: Is there a risk that the touch hardware could
+        //       maintain a non-empty state for an extended period of time?
+        m_touch.readData(&nRawX,&nRawY,&nRawPress);
+        m_nLastRawX = nRawX;
+        m_nLastRawY = nRawY;
+        m_nLastRawPress = nRawPress;
+        m_bLastTouched = true;
+        bValid = true;
+      }
+
+    }
+    // Clear interrupts
+    m_touch.writeRegister8(STMPE_INT_STA, 0xFF);
+
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+    // Flush the FIFO
+    while (!m_touch.bufferEmpty()) {
+      m_touch.readData(&nRawX,&nRawY,&nRawPress);
+    }
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_FT6206)
+
+  if (m_touch.touched()) {
+    TS_Point ptTouch = m_touch.getPoint();
+    // FT6206 coordinates appear to have flipped both axes vs other controllers
+    // - Confirmed by comments in Adafruit_FT6206 library example code:
+    //   "rotate coordinate system. flip it around to match the screen."
+    m_nLastRawX = nDispOutMaxX-ptTouch.x;
+    m_nLastRawY = nDispOutMaxY-ptTouch.y;
+    m_nLastRawPress = 255;  // Select arbitrary non-zero value
+    m_bLastTouched = true;
+    bValid = true;
+
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_FT5206)
+
+  if (m_touch.touched()) {
+
+    uint8_t anRegs[FT5206_REGISTERS];
+    uint16_t anCoords[5][2];
+    m_touch.getTSregisters(anRegs);
+    uint8_t nCurTouches = m_touch.getTScoordinates(anCoords,anRegs);
+
+    if (nCurTouches >= 1) {
+      // Only accept the first touch
+
+      // Additional unused touch info
+      //uint8_t nTemp1 = m_touch.getGesture(anRegs);
+      //uint8_t nTemp2 = m_touch.getTSflag(anRegs);
+
+      // As the FT5206 has flipped axes, we adjust them here
+      m_nLastRawX = nDispOutMaxX-anCoords[0][0];
+      m_nLastRawY = nDispOutMaxY-anCoords[0][1];
+
+      m_nLastRawPress = 255;  // Select arbitrary non-zero value
+      m_bLastTouched = true;
+      bValid = true;
+
+    } else {
+	  // No touches detected, so treat as release event
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  } else {
+    // Interrupt didn't occur, so no change in events
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_SIMPLE)
+
+  uint16_t  nRawX,nRawY;
+  int16_t   nRawPress;
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+    // Saved pin state
+    gslc_tsPinState   sPinStateXP, sPinStateXM, sPinStateYP, sPinStateYM;
+
+    // As Adafruit_TouchScreen polling will alter the pin state and some
+    // of these pins may be shared with the display, we need to save and
+    // then later restore the pin state.
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+      // For Arduino Due & Nano 33, we don't attempt to record state
+    #else
+    gslc_TDrvSavePinState(ADATOUCH_PIN_XP, sPinStateXP);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_XM, sPinStateXM);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_YP, sPinStateYP);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_YM, sPinStateYM);
+    #endif
+  #endif // FIX_4WIRE_PIN_STATE
+  
+  // Perform the polling of touch coordinate & pressure
+  TSPoint p = m_touch.getPoint();
+
+  // Select reasonable touch pressure threshold range.
+  // Note that the Adafruit_TouchScreen library appears to
+  // return the following:
+  // - 0:     If no touch (results from integer overflow, div/0)
+  // - 0:     If touch active but filtered due to noise
+  // - small: If touch active and hard
+  // - large: If touch active and soft
+  // Note that the "pressure" (z) value is inverted in interpretation
+  if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+    nRawX = p.x;
+    nRawY = p.y;
+    nRawPress = p.z;
+    m_nLastRawX = nRawX;
+    m_nLastRawY = nRawY;
+    m_nLastRawPress = nRawPress;
+    m_bLastTouched = true;
+    bValid = true;
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+
+      #if !defined(FIX_4WIRE_Z) // Original behavior without touch pressure workaround
+
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+      #ifdef DBG_TOUCH
+      GSLC_DEBUG_PRINT("DBG: Touch End  =%u Raw[%d,%d] *****\n",
+          m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+      #endif
+
+      #else // Apply touch pressure workaround
+
+      // Unfortunately, the Adafruit_TouchScreen has a few issues that
+      // make it hard to deal with reliably. The most difficult problem
+      // involves the ambiguous return state from getTouch().
+      // Without handling this in a special way, we might see spurious
+      // touch-release events.
+      //
+      // Upon entering this clause, we can infer Adafruit_TouchScreen returned z=0
+      // - This either means:
+      //   a) Touch was released (z is 0 due to integer overflow, div/0)
+      //   b) Touch still active but filtered due to noisy read
+      //
+      // Because of case (b) returning the same signature as case (a), we
+      // need to take an additional step to differentiate the two cases
+      // otherwise we might interpret spurious "touch release" events.
+      //
+      // In order to differentiate these cases, we can call the Adafruit
+      // getPressure() API since it does not include the filtering for (b).
+      // Therefore, if we see that the pressure is non-zero, and less than
+      // the max pressure threshold, we can re-interpret our original reading
+      // as (b), wherein we would still want to treat as a touch pressed event.
+
+      // Read the touch pressure
+      // Note that we will need to restore the pin status later
+      // once we are done with our polling.
+      uint16_t nPressCur = m_touch.pressure();
+
+      if ((nPressCur > ADATOUCH_PRESS_MIN) && (nPressCur < ADATOUCH_PRESS_MAX)) {
+        // The unfiltered result is that the display is still pressed
+        // Therefore we are likely in case (b) and should return our
+        // last saved result (with touch pressure still active)
+        bValid = true;
+        #ifdef DBG_TOUCH
+        // Give indication that workaround applied: continue press
+        GSLC_DEBUG_PRINT("DBG: Touch Cont =%u Raw[%d,%d]\n",
+            m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+        #endif
+      } else {
+        // The unfiltered result is that the display is not pressed
+        // Therefore we are likely in case (a) and should force
+        // the touch pressure to be deactivated
+
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+        #ifdef DBG_TOUCH
+        GSLC_DEBUG_PRINT("DBG: Touch End  =%u Raw[%d,%d] *****\n",
+            m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+        #endif
+      } // nPressCur
+      #endif // FIX_4WIRE_Z
+
+      // TODO: Implement touch debouncing
+
+    } // m_bLastTouched
+  }
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+    // Now that we have completed our polling into Adafruit_TouchScreen,
+    // we need to restore the original pin state.
+    #if defined(ARDUINO_ARCH_SAM) || defined(ARDUINO_SAMD_NANO_33_IOT)
+      // For Arduino Due & Nano 33 IOT, we simply force output state
+      pinMode(ADATOUCH_PIN_XM,OUTPUT);
+      pinMode(ADATOUCH_PIN_YP,OUTPUT);
+      pinMode(ADATOUCH_PIN_YM,OUTPUT);
+    #else
+      gslc_TDrvRestorePinState(ADATOUCH_PIN_XP, sPinStateXP);
+      gslc_TDrvRestorePinState(ADATOUCH_PIN_XM, sPinStateXM);
+      gslc_TDrvRestorePinState(ADATOUCH_PIN_YP, sPinStateYP);
+      gslc_TDrvRestorePinState(ADATOUCH_PIN_YM, sPinStateYM);
+    #endif
+  #endif // FIX_4WIRE_PIN_STATE
+
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_XPT2046_STM)
+    // NOTE: XPT2046_STM returns pressure (z) values with a reversed
+    //       convention versus other touch libraries (ie. a small
+    //       non-zero z value means light touch, whereas a large
+    //       value means a hard / wide touch).
+
+    uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+    uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+    TS_Point p = m_touch.getPoint();
+
+    if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+      nRawX = p.x;
+      nRawY = p.y;
+      nRawPress = p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_XPT2046_PS)
+    uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+    uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+    TS_Point p = m_touch.getPoint();
+
+    if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+      // PaulStoffregen/XPT2046 appears to use a different orientation
+      // than other libraries. Therefore, we will remap it here
+      // to match the default portrait orientation.
+      nRawX = 4095-p.y;
+      nRawY = p.x;
+
+      nRawPress = p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_RA8875)
+    uint16_t  nRawX,nRawY;
+
+    // Use Adafruit_RA8875 display driver for touch
+    // Note that it doesn't support a "pressure" reading
+    if (m_disp.touched()) {
+      m_disp.touchRead(&nRawX,&nRawY);
+
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = 255;  // Select arbitrary non-zero value
+      m_bLastTouched = true;
+      bValid = true;
+
+      // The Adafruit_RA8875 touched() implementation relies on reading
+      // the status of the Touch Panel interrupt register bit. The touchRead()
+      // call clears the status of the interrupt. It appears that the
+      // interrupt requires moderate time to propagate (so that it can be
+      // available for the next call to touched). Therefore, a 1ms delay
+      // is inserted here. Note that a similar delay can be found in
+      // the Adafruit example code.
+      delay(1);
+
+    } else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_RA8875_SUMO)
+    uint16_t  nRawX,nRawY;
+
+    // Use Adafruit_RA8875 display driver for touch
+    // Note that it doesn't support a "pressure" reading
+    if (m_disp.touched()) {
+      m_disp.touchReadAdc(&nRawX,&nRawY);
+
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = 255;  // Select arbitrary non-zero value
+      m_bLastTouched = true;
+      bValid = true;
+
+      // NOTE: The following comments were based on Adafruit_RA8875
+      //       and have not been updated to reflect sumotoy/RA8875
+      // The Adafruit_RA8875 touched() implementation relies on reading
+      // the status of the Touch Panel interrupt register bit. The touchRead()
+      // call clears the status of the interrupt. It appears that the
+      // interrupt requires moderate time to propagate (so that it can be
+      // available for the next call to touched). Therefore, a 1ms delay
+      // is inserted here. Note that a similar delay can be found in
+      // the Adafruit example code.
+      delay(1);
+
+    } else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_HANDLER)
+
+    uint16_t  nRawX,nRawY;
+    uint16_t  nRawPress; 
+  
+    TouchHandler *pTH = gslc_getTouchHandler();
+    THPoint p(0,0,0);
+    //if no TouchHandler was defined use (0,0,0)
+    if (pTH!=NULL)
+        p = pTH->getPoint();
+    
+    if (p.z > 0) {
+      nRawX=p.x;
+      nRawY=p.y;
+      nRawPress=p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+      //Serial.print("pTH= ");Serial.print(p.x);Serial.print(" ");Serial.print(p.y);Serial.print(" ");Serial.println(p.z);
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_URTOUCH)
+
+    // Note that we rely on URTouch's calibration
+    // - This is detected by URTouch / URTouch_Calibration
+    // - The calibration settings are stored in URTouch/URTouchCD.h
+
+    int16_t   nRawX,nRawY;
+    uint16_t  nRawPress = 0;
+    bool bTouchOk = true;
+
+    if (!m_touch.dataAvailable()) {
+      bTouchOk = false;
+    }
+
+    if (bTouchOk) {
+      m_touch.read();
+      nRawX = m_touch.getX();
+      nRawY = m_touch.getY();
+      if ((nRawX == -1) || (nRawY == -1)) {
+        bTouchOk = false;
+      }
+    }
+
+    if (bTouchOk) {
+      nRawPress = 255; // Dummy non-zero value
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    } else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_INPUT)
+    // No more to do for GPIO-only mode since gslc_Update() already
+    // looks for GPIO inputs before calling TDrvGetTouch().
+    // bValid will default to false
+
+
+  // Assign defaults
+  *pnX = 0;
+  *pnY = 0;
+  *pnPress = 0;
+
+  *peInputEvent = GSLC_INPUT_NONE;
+  *pnInputVal = 0;
+
+  #ifdef DRV_DISP_ADAGFX_SEESAW
+    // Keep track of last value to support simple debouncing
+    static uint32_t nButtonsLast = 0xFFFFFFFF;     // Saved last value (static to preserve b/w calls)
+    uint32_t nButtonsCur = m_seesaw.readButtons(); // Current value (note active low)
+    if ((nButtonsLast & TFTSHIELD_BUTTON_UP) && !(nButtonsCur & TFTSHIELD_BUTTON_UP)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_UP;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_DOWN) && !(nButtonsCur & TFTSHIELD_BUTTON_DOWN)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_DOWN;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_LEFT) && !(nButtonsCur & TFTSHIELD_BUTTON_LEFT)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_LEFT;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_RIGHT) && !(nButtonsCur & TFTSHIELD_BUTTON_RIGHT)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_RIGHT;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_IN) && !(nButtonsCur & TFTSHIELD_BUTTON_IN)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_SEL;
+    }
+    // Save button state so that transitions can be detected
+    // during the next pass.
+    nButtonsLast = nButtonsCur;
+  #endif
+
+
+  // If we reached here, then we had a button event
+  return true;
+
+  // ----------------------------------------------------------------
+  #endif // DRV_TOUCH_*
+
+
+  // If an event was detected, signal it back to GUIslice
+  if (bValid) {
+
+    int nRawX,nRawY;
+    int nInputX,nInputY;
+    int nOutputX,nOutputY;
+
+    // Input assignment
+    nRawX = m_nLastRawX;
+    nRawY = m_nLastRawY;
+
+    // Handle any hardware swapping in native orientation
+    // This is done prior to any flip/swap as a result of
+    // rotation away from the native orientation.
+    // In most cases, the following is not used, but there
+    // may be touch modules that have swapped their X&Y convention.
+    if (pGui->bTouchRemapYX) {
+      nRawX = m_nLastRawY;
+      nRawY = m_nLastRawX;
+    }
+
+    nInputX = nRawX;
+    nInputY = nRawY;
+
+    // For resistive displays, perform constraint and scaling
+    #if defined(DRV_TOUCH_TYPE_RES)
+      if (pGui->bTouchRemapEn) {
+        // Perform scaling from input to output
+        // - Calibration done in native orientation (GSLC_ROTATE=0)
+        // - Input to map() is done with raw unswapped X,Y
+        // - map() and constrain() done with native dimensions and
+        //   native calibration
+        // - Swap & Flip done to output of map/constrain according
+        //   to GSLC_ROTATE
+        //
+        #if defined(DBG_TOUCH)
+          GSLC_DEBUG_PRINT("DBG: remapX: (%d,%d,%d,%d,%d)\n", nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+          GSLC_DEBUG_PRINT("DBG: remapY: (%d,%d,%d,%d,%d)\n", nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        #endif
+        nOutputX = map(nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+        nOutputY = map(nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        // Perform constraining to OUTPUT boundaries
+        nOutputX = constrain(nOutputX, 0, nDispOutMaxX);
+        nOutputY = constrain(nOutputY, 0, nDispOutMaxY);
+      } else {
+        // No scaling from input to output
+        nOutputX = nInputX;
+        nOutputY = nInputY;
+      }
+    #else
+      // No scaling from input to output
+      nOutputX = nInputX;
+      nOutputY = nInputY;
+    #endif  // DRV_TOUCH_TYPE_RES
+  
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: PreRotate: x=%u y=%u\n", nOutputX, nOutputY);
+    #if defined(DRV_TOUCH_TYPE_RES)
+      GSLC_DEBUG_PRINT("DBG: RotateCfg: remap=%u nSwapXY=%u nFlipX=%u nFlipY=%u\n",
+        pGui->bTouchRemapEn,pGui->nSwapXY,pGui->nFlipX,pGui->nFlipY);
+    #endif // DRV_TOUCH_TYPE_RES
+    #endif // DBG_TOUCH
+
+    // Perform remapping due to current orientation
+    if (pGui->bTouchRemapEn) {
+      // Perform any requested swapping of input axes
+      if (pGui->nSwapXY) {
+        int16_t nOutputXTmp = nOutputX;
+        nOutputX = nOutputY;
+        nOutputY = nOutputXTmp;
+        // Perform any requested output axis flipping
+        // TODO: Collapse these cases
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxY - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxX - nOutputY;
+        }
+      } else {
+        // Perform any requested output axis flipping
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxX - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxY - nOutputY;
+        }
+      }
+    }
+
+    // Final assignment
+    *pnX          = nOutputX;
+    *pnY          = nOutputY;
+    *pnPress      = m_nLastRawPress;
+    *peInputEvent = GSLC_INPUT_TOUCH;
+    *pnInputVal   = 0;
+
+    // Print output for debug
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: Touch Press=%u Raw[%d,%d] Out[%d,%d]\n",
+        m_nLastRawPress,m_nLastRawX,m_nLastRawY,nOutputX,nOutputY);
+    #endif
+
+    // Return with indication of new value
+    return true;
+  }
+
+  // No new value
+  return false;
+}
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  bool bChange = true;
+  bool bSupportRotation = true;
+
+  // Determine if the new orientation has swapped axes
+  // versus the native orientation (0)
+  bool bSwap = false;
+  if ((nRotation == 1) || (nRotation == 3)) {
+    bSwap = true;
+  }
+  (void)bSwap; // May be Unused in some driver modes
+
+  // Did the orientation change?
+  if (nRotation == pGui->nRotation) {
+    // Orientation did not change -- indicate this by returning
+    // false so that we can avoid a redraw
+    bChange = false;
+  }
+
+  // Update the GUI rotation member
+  pGui->nRotation = nRotation;
+
+  // Inform the display to adjust the orientation and
+  // update the saved display dimensions
+  #if defined(DRV_DISP_ADAGFX_ILI9341) || defined(DRV_DISP_ADAGFX_ILI9341_STM) || defined(DRV_DISP_ADAGFX_ILI9341_T3)
+    pGui->nDisp0W = ILI9341_TFTWIDTH;
+    pGui->nDisp0H = ILI9341_TFTHEIGHT;
+    m_disp.setRotation(pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = ILI9341_TFTWIDTH;
+      pGui->nDispH = ILI9341_TFTHEIGHT;
+    } else {
+      pGui->nDispW = ILI9341_TFTHEIGHT;
+      pGui->nDispH = ILI9341_TFTWIDTH;
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_8BIT)
+    pGui->nDisp0W = ILI9341_TFTWIDTH;
+    pGui->nDisp0H = ILI9341_TFTHEIGHT;
+    m_disp.setRotation(pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = ILI9341_TFTWIDTH;
+      pGui->nDispH = ILI9341_TFTHEIGHT;
+    } else {
+      pGui->nDispW = ILI9341_TFTHEIGHT;
+      pGui->nDispH = ILI9341_TFTWIDTH;
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_ILI9341_DUE_MB)
+    pGui->nDisp0W = ILI9341_TFTWIDTH;
+    pGui->nDisp0H = ILI9341_TFTHEIGHT;
+    m_disp.setRotation((iliRotation)pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = ILI9341_TFTWIDTH;
+      pGui->nDispH = ILI9341_TFTHEIGHT;
+    } else {
+      pGui->nDispW = ILI9341_TFTHEIGHT;
+      pGui->nDispH = ILI9341_TFTWIDTH;
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_SSD1306)
+    // No support for rotation in SSD1306 library
+    pGui->nDisp0W = SSD1306_LCDWIDTH;
+    pGui->nDisp0H = SSD1306_LCDHEIGHT;
+    pGui->nDispW = SSD1306_LCDWIDTH;
+    pGui->nDispH = SSD1306_LCDHEIGHT;
+
+  #elif defined(DRV_DISP_ADAGFX_ST7735)
+    // TODO: To support ST7789, init() is called with the display dimensions
+    //       instead of initR() with the initialization enumeration.
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_ADAGFX_HX8347)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_ADAGFX_HX8357)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = HX8357_TFTWIDTH;
+    pGui->nDisp0H = HX8357_TFTHEIGHT;
+    m_disp.setRotation(pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = HX8357_TFTWIDTH;
+      pGui->nDispH = HX8357_TFTHEIGHT;
+    } else {
+      pGui->nDispW = HX8357_TFTHEIGHT;
+      pGui->nDispH = HX8357_TFTWIDTH;
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_PCD8544)
+    pGui->nDisp0W = LCDWIDTH;
+    pGui->nDisp0H = LCDHEIGHT;
+    // No support for rotation in PCD8544 library
+    pGui->nDispW = LCDWIDTH;
+    pGui->nDispH = LCDHEIGHT;
+
+  #elif defined(DRV_DISP_ADAGFX_RA8875)
+    // No support for rotation in Adafruit_RA8875 library
+    bSupportRotation = false;
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_ADAGFX_RA8875_SUMO)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    if (!bSwap) {
+      pGui->nDispW = m_disp.width();
+      pGui->nDispH = m_disp.height();
+    } else {
+      pGui->nDispW = m_disp.height();
+      pGui->nDispH = m_disp.width();
+    }
+
+  #elif defined(DRV_DISP_ADAGFX_RA8876)
+    // No support for rotation in xlatb/RA8875 library
+    bSupportRotation = false;
+    pGui->nDisp0W = m_disp.getWidth();
+    pGui->nDisp0H = m_disp.getHeight();
+    pGui->nDispW = m_disp.getWidth();
+    pGui->nDispH = m_disp.getHeight();
+
+  #elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+    // No support for rotation in GEVINO RA8875 library
+    bSupportRotation = false;
+    pGui->nDisp0W = m_disp.getWidth();
+    pGui->nDisp0H = m_disp.getHeight();
+    pGui->nDispW = m_disp.getWidth();
+    pGui->nDispH = m_disp.getHeight();
+
+  #elif defined(DRV_DISP_ADAGFX_MCUFRIEND)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_LCDGFX)
+    m_disp.getInterface().setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    // It appears that LCDGFX rotation is 180 degrees offset from other libraries
+    m_disp.getInterface().setRotation((pGui->nRotation + 2) & 0x3);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #elif defined(DRV_DISP_WAVESHARE_ILI9486)
+    m_disp.setRotation(0);
+    pGui->nDisp0W = m_disp.width();
+    pGui->nDisp0H = m_disp.height();
+    m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.width();
+    pGui->nDispH = m_disp.height();
+
+  #else
+    // Report error for unsupported display mode
+    // - If we don't trap this condition, the GUI dimensions will be incorrect
+    #error "ERROR: DRV_DISP_* mode not supported in DrvRotate initialization"
+
+  #endif
+
+  // Update the clipping region
+  gslc_tsRect rClipRect = { 0,0,pGui->nDispW,pGui->nDispH };
+  gslc_DrvSetClipRect(pGui, &rClipRect);
+
+  if (!bSupportRotation) {
+    // No support for rotation, so override rotation indicator to 0
+    // This will also ensure that nSwapXY / nFlipX / nFlipY all remain 0
+    pGui->nRotation = 0;
+    // Ensure no redraw forced due to change in rotation value
+    bChange = false;
+  }
+
+  // Now update the touch remapping
+  #if !defined(DRV_TOUCH_NONE)
+    // Correct touch mapping according to current rotation mode
+    pGui->nSwapXY = TOUCH_ROTATION_SWAPXY(pGui->nRotation);
+    pGui->nFlipX = TOUCH_ROTATION_FLIPX(pGui->nRotation);
+    pGui->nFlipY = TOUCH_ROTATION_FLIPY(pGui->nRotation);
+  #endif // !DRV_TOUCH_NONE
+
+  // Mark the current page ask requiring redraw
+  // if the rotation value changed
+  if (bChange) {
+    gslc_PageRedrawSet( pGui, true );
+  }
+
+  return true;
+}
+
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+
+// Convert from RGB struct to native screen format
+// TODO: Use 32bit return type?
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol)
+{
+  uint16_t nColRaw = 0;
+
+  #if defined(DRV_COLORMODE_MONO)
+    // Monochrome
+    if ((nCol.r == 0) && (nCol.g == 0) && (nCol.b == 0)) { // GSLC_COL_BLACK
+      nColRaw = 0;  // BLACK
+    } else {
+      nColRaw = 1;  // WHITE
+    }
+
+  #elif defined(DRV_COLORMODE_BGR565)
+    nColRaw |= (((nCol.b & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.r & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #else
+    // Default to DRV_COLORMODE_RGB565
+    nColRaw |= (((nCol.r & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.b & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #endif // DRV_COLORMODE_*
+
+  return nColRaw;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // Compiler guard for requested driver
diff --git a/src/guislice/GUIslice_drv_adagfx.h b/src/guislice/GUIslice_drv_adagfx.h
new file mode 100644
index 0000000..95c5030
--- /dev/null
+++ b/src/guislice/GUIslice_drv_adagfx.h
@@ -0,0 +1,757 @@
+#ifndef _GUISLICE_DRV_ADAGFX_H_
+#define _GUISLICE_DRV_ADAGFX_H_
+
+// =======================================================================
+// GUIslice library (driver layer for Adafruit-GFX)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_adagfx.h
+/// \brief GUIslice library (driver layer for Adafruit-GFX)
+
+
+// =======================================================================
+// Driver Layer for Adafruit-GFX
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+
+// Determine characteristics for configured touch driver
+// - DRV_TOUCH_TYPE_EXTERNAL: TDrv* external touch APIs are enabled
+// - DRV_TOUCH_TYPE_RES:      Resistive overlay
+// - DRV_TOUCH_TYPE_CAP:      Capacitive overlay
+// - DRV_TOUCH_TYPE_ANALOG:   Analog input
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_CAP         // Capacitive
+#elif defined(DRV_TOUCH_ADA_FT5206)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_CAP         // Capacitive
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+  #define DRV_TOUCH_TYPE_ANALOG      // Analog
+#elif defined(DRV_TOUCH_ADA_RA8875)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_ADA_RA8875_SUMO)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_URTOUCH)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  // Don't set DRV_TOUCH_TYPE_RES since URTouch provides its own calibration
+  //#define DRV_TOUCH_TYPE_RES         // Resistive  
+#elif defined(DRV_TOUCH_INPUT)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_HANDLER)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_NONE)
+#endif // DRV_TOUCH_*
+
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT             1 ///< Support gslc_DrvDrawPoint()
+
+#define DRV_HAS_DRAW_POINTS            0 ///< Support gslc_DrvDrawPoints()
+#define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+#define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+#define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FRAME  1 ///< Support gslc_DrvDrawFrameRoundRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FILL   1 ///< Support gslc_DrvDrawFillRoundRect()
+#define DRV_HAS_DRAW_CIRCLE_FRAME      1 ///< Support gslc_DrvDrawFrameCircle()
+#define DRV_HAS_DRAW_CIRCLE_FILL       1 ///< Support gslc_DrvDrawFillCircle()
+#define DRV_HAS_DRAW_TRI_FRAME         1 ///< Support gslc_DrvDrawFrameTriangle()
+#define DRV_HAS_DRAW_TRI_FILL          1 ///< Support gslc_DrvDrawFillTriangle()
+#define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+#define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+
+#define DRV_OVERRIDE_TXT_ALIGN         0 ///< Driver provides text alignment
+
+
+// -----------------------------------------------------------------------
+// Driver-specific overrides
+// - Some drivers have exceptions to the above support configuration
+// -----------------------------------------------------------------------
+#if defined(DRV_DISP_WAVESHARE_ILI9486)
+  #undef DRV_HAS_DRAW_RECT_ROUND_FRAME
+  #undef DRV_HAS_DRAW_RECT_ROUND_FILL
+  #undef DRV_HAS_DRAW_TRI_FRAME
+  #undef DRV_HAS_DRAW_TRI_FILL
+
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0
+  #define DRV_HAS_DRAW_TRI_FRAME         0
+  #define DRV_HAS_DRAW_TRI_FILL          0
+
+#elif defined(DRV_DISP_LCDGFX)
+  #undef DRV_HAS_DRAW_RECT_ROUND_FRAME
+  #undef DRV_HAS_DRAW_RECT_ROUND_FILL
+  #undef DRV_HAS_DRAW_CIRCLE_FRAME
+  #undef DRV_HAS_DRAW_CIRCLE_FILL
+  #undef DRV_HAS_DRAW_TRI_FRAME
+  #undef DRV_HAS_DRAW_TRI_FILL
+
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0
+  #define DRV_HAS_DRAW_CIRCLE_FRAME      0
+  #define DRV_HAS_DRAW_CIRCLE_FILL       0
+  #define DRV_HAS_DRAW_TRI_FRAME         0
+  #define DRV_HAS_DRAW_TRI_FILL          0
+
+#elif defined(DRV_DISP_ADAGFX_RA8876)
+  #undef DRV_HAS_DRAW_RECT_ROUND_FRAME
+  #undef DRV_HAS_DRAW_RECT_ROUND_FILL
+
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0
+
+#elif defined(DRV_DISP_ADAGFX_RA8876_GV)
+  #undef DRV_HAS_DRAW_RECT_ROUND_FRAME
+  #undef DRV_HAS_DRAW_RECT_ROUND_FILL
+
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0
+
+
+#elif defined(DRV_DISP_ADAGFX_ILI9341)
+  // BLIT support in library
+  #undef  DRV_HAS_DRAW_BMP_MEM
+  #define DRV_HAS_DRAW_BMP_MEM           1
+#endif
+
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+  gslc_tsColor  nColBkgnd;      ///< Background color (if not image-based)
+
+  gslc_tsRect   rClipRect;      ///< Clipping rectangle
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit(). This can be done with gslc_DrvInitEnv()
+///   or manually in user function.
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTs(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(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_DrvGetDriverDisp(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_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// 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_DrvSetBkgndImage(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_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type (GSLC_FONTREF_PTR for Arduino)
+/// \param[in]  pvFontRef:      Font reference pointer (Pointer to the GFXFont array)
+/// \param[in]  nFontSz:        Typeface size to use
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in ADAGFX, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,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 true if success, false if error
+///
+bool gslc_DrvDrawFillRect(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 rounded corners
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,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 rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameCircle(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 of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillCircle(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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameTriangle(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 to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// Draw a monochrome bitmap from a memory array
+/// - Draw from the bitmap buffer using the foreground color
+///   defined in the header (unset bits are transparent)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY, const unsigned char *pBitmap,bool bProgMem);
+
+
+///
+/// Draw a color 24-bit depth bitmap from a memory array
+/// - Note that users must convert images from their native
+///   format (eg. BMP, PNG, etc.) into a C array. Please
+///   refer to the following guide for details:
+///   https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Images-from-FLASH
+/// - The converted file (c array) can then be included in the sketch.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       X coord for copy
+/// \param[in]  nDstY:       Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem);
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using display driver library)
+// -----------------------------------------------------------------------
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the internal touch handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using external touch driver library)
+// -----------------------------------------------------------------------
+
+// Check for deprecated config option
+// - This check will be removed in future releases
+#if defined(DRV_TOUCH_XPT2046)
+  #error "NOTE: DRV_TOUCH_XPT2046 has been renamed to DRV_TOUCH_XPT2046_STM. Please update your config."
+#endif
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the SDL_Event handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_ADAGFX_H_
diff --git a/src/guislice/GUIslice_drv_m5stack.cpp b/src/guislice/GUIslice_drv_m5stack.cpp
new file mode 100644
index 0000000..e97a35c
--- /dev/null
+++ b/src/guislice/GUIslice_drv_m5stack.cpp
@@ -0,0 +1,1071 @@
+// =======================================================================
+// GUIslice library (driver layer for m5stack/M5Stack)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_m5stack.cpp
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_M5STACK)
+
+// =======================================================================
+// Driver Layer for m5stack/M5Stack
+// - https://github.com/m5stack/M5Stack
+// =======================================================================
+
+// GUIslice library
+#include "GUIslice_drv_m5stack.h"
+
+#include <stdio.h>
+
+#include <M5Stack.h>
+
+#include <SPI.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+  // Define driver naming
+  const char* m_acDrvDisp = "M5STACK";
+  const char* m_acDrvTouch = "M5STACK(NONE)";
+
+
+// ------------------------------------------------------------------------
+// Use default pin settings as defined in M5Stack/src/utility/Config.h
+#define m_disp m5.Lcd
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+
+  // Report any debug info if enabled
+  #if defined(DBG_DRIVER)
+  // TODO
+  #endif
+
+  // Initialize any library-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    pDriver->nColBkgnd = GSLC_COL_BLACK;
+
+    // These displays can accept partial redraw as they retain the last
+    // image in the controller graphics RAM
+    pGui->bRedrawPartialEn = true;
+
+    // Initialize the M5stack driver
+    // - Note that this will automatically initialize the SD driver
+    // - It also configures the serial interface for 115200 baud
+    m5.begin();
+  
+    // Now that we have initialized the display, we can assign
+    // the rotation parameters and clipping region
+    gslc_DrvRotate(pGui,GSLC_ROTATE);
+
+    // Additional init specific to M5stack
+    pinMode(TFT_LIGHT_PIN, OUTPUT);
+    digitalWrite(TFT_LIGHT_PIN, HIGH);
+
+  }
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (void*)(&m_disp);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // GUIslice adapter for Adafruit-GFX doesn't preload the
+  // images into RAM (to keep RAM requirements low), so we
+  // don't need to do any further processing here. Instead,
+  // the loading is done during render.
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    return NULL;  // No image preload done
+  }
+
+  // Default
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->nColBkgnd = nCol;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefNorm = sImgRef;
+  return true; // TODO
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefGlow = sImgRef;
+  return true; // TODO
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // NOTE: The clipping rect is currently saved in the
+  // driver struct, but the drawing code does not currently
+  // use it.
+  gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pRect == NULL) {
+    // Default to entire display
+    pDriver->rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  } else {
+    pDriver->rClipRect = *pRect;
+  }
+
+  // TODO: For ILI9341, perhaps we can leverage m_disp.setAddrWindow(x0, y0, x1, y1)?
+  return true;
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz)
+{
+  // Arduino mode currently only supports font definitions from memory
+  if (eFontRefType != GSLC_FONTREF_PTR) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvFontAdd(%s) failed - Arduino only supports memory-based fonts\n","");
+    return NULL;
+  }
+  // Return pointer to Adafruit-GFX GFXfont structure
+  return pvFontRef;
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  // Nothing to deallocate
+}
+
+
+// NOTE: Please see the comments associated with gslc_DrvDrawTxt().
+//       In summary, DrvGetTxtSize() is not able to gather the complete
+//       text sizing information from TFT_eSPI as the APIs are not available.
+//
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  uint16_t  nTxtLen    = 0;
+  uint16_t  nTxtHeight = 0;
+  uint16_t  nTxtScale  = pFont->nSize;
+  // TFT_eSPI font API differs from Adafruit-GFX's setFont() API
+  if (pFont->pvFont == NULL) {
+    m_disp.setTextFont(1);
+  } else {
+    m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+  }
+  m_disp.setTextSize(nTxtScale);
+  nTxtLen = m_disp.textWidth((char*)pStr);
+  nTxtHeight = m_disp.fontHeight(1); // Use freefont "textfont" value
+  *pnTxtX = 0;  // Unused
+  *pnTxtY = 0;  // Unused
+  *pnTxtSzW = nTxtLen;
+  *pnTxtSzH = nTxtHeight;
+
+  return true;
+}
+
+bool gslc_DrvDrawTxtAlign(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,int8_t eTxtAlign,
+        gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  uint16_t nTxtScale = pFont->nSize;
+  // TODO: Support SMOOTH_FONT?
+  m_disp.setTextColor(nColRaw);
+  // TFT_eSPI font API differs from Adafruit-GFX's setFont() API
+  if (pFont->pvFont == NULL) {
+    m_disp.setTextFont(1);
+  } else {
+    m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+  }
+  m_disp.setTextSize(nTxtScale);
+
+  // Default to mid-mid datum
+  int8_t  nDatum = MC_DATUM;
+  int16_t nTxtX = nX0 + (nX1-nX0)/2;
+  int16_t nTxtY = nY0 + (nY1-nY0)/2;
+
+  // Override the datum depending on alignment mode
+  switch(eTxtAlign) {
+    case GSLC_ALIGN_TOP_LEFT:   nDatum = TL_DATUM; nTxtX = nX0; nTxtY = nY0; break;
+    case GSLC_ALIGN_TOP_MID:    nDatum = TC_DATUM; nTxtY = nY0; break;
+    case GSLC_ALIGN_TOP_RIGHT:  nDatum = TR_DATUM; nTxtX = nX1; nTxtY = nY0; break;
+    case GSLC_ALIGN_MID_LEFT:   nDatum = ML_DATUM; nTxtX = nX0; break;
+    case GSLC_ALIGN_MID_MID:    nDatum = MC_DATUM; break;
+    case GSLC_ALIGN_MID_RIGHT:  nDatum = MR_DATUM; nTxtX = nX1; break;
+    case GSLC_ALIGN_BOT_LEFT:   nDatum = BL_DATUM; nTxtX = nX0; nTxtY = nY1; break;
+    case GSLC_ALIGN_BOT_MID:    nDatum = BC_DATUM; nTxtY = nY1; break;
+    case GSLC_ALIGN_BOT_RIGHT:  nDatum = BR_DATUM; nTxtX = nX1; nTxtY = nY1; break;
+    default:                    nDatum = MC_DATUM; break;
+  }
+  m_disp.setTextDatum(nDatum);
+
+  m_disp.drawString(pStr,nTxtX,nTxtY);
+
+  // For now, always return true
+  return true;
+}
+
+// NOTE: As TFT_eSPI performs some complex logic in determining the font
+//       baseline and associated adjustments and these are not provided
+//       via an API, calling DrvGetTxtSize() is insufficient to determine
+//       the appropriate position corrections required (eg. when centering
+//       text). Therefore, DrvDrawTxt() will not result in proper text
+//       alignment in all cases. Instead, it is recommended that
+//       DrvDrawTxtAlign() is used instead, which will depend on the datum
+//       adjustment code within TFT_eSPI. This mode of operation is
+//       selected by default in GUIslice_drv_tft_espi.h by setting
+//       DRV_OVERRIDE_TXT_ALIGN to 1.
+
+// This method is not recommended for use with TFT_eSPI. DrvDrawTxtAlign()
+// should be used instead.
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t nTxtScale = pFont->nSize;
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  // TODO: Support SMOOTH_FONT?
+  m_disp.setTextColor(nColRaw);
+  // m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextSize(nTxtScale);
+
+  // Default to top-left datum
+  m_disp.setTextDatum(TL_DATUM);
+
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_RAM) {
+    // String in SRAM; can access buffer directly
+    // m_disp.println(pStr);
+    m_disp.drawString(pStr,nTxtX,nTxtY);
+  } else if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    // String in PROGMEM (flash); must access via pgm_* calls
+    char    ch;
+    int     nXOffset = 0;
+    while ((ch = pgm_read_byte(pStr++))) {
+      // m_disp.print(ch);
+      nXOffset += m_disp.drawChar(ch,nTxtX+nXOffset,nTxtY);
+    }
+    m_disp.println();
+  }
+
+  return true;
+}
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  // Nothing to do as we're not double-buffered
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+inline void gslc_DrvDrawPoint_base(int16_t nX, int16_t nY, uint16_t nColRaw)
+{
+  m_disp.drawPixel(nX,nY,nColRaw);
+}
+
+inline void gslc_DrvDrawLine_base(int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,uint16_t nColRaw)
+{
+  m_disp.drawLine(nX0,nY0,nX1,nY1,nColRaw);
+}
+
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipPt(&pDriver->rClipRect,nX,nY)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawPoint_base(nX, nY, nColRaw);
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+  return false;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipRect(&pDriver->rClipRect,&rRect)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FILL)
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  // - TODO: Optimize the following, perhaps with new ClipLineHV()
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  int16_t nX0, nY0, nX1, nY1;
+  // Top
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Bottom
+  nX0 = rRect.x;
+  nY0 = rRect.y + rRect.h - 1;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Left
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Right
+  nX0 = rRect.x + rRect.w - 1;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+#else
+  m_disp.drawRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  m_disp.drawRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipLine(&pDriver->rClipRect,&nX0,&nY0,&nX1,&nY1)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawLine_base(nX0,nY0,nX1,nY1,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFrameCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FILL)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FRAME)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FILL)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+
+
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Adafruit_GFX.cpp
+//   Original author:  Adafruit
+//   Function:         drawBitmap()
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer using the foreground color defined in the
+// header (unset bits are transparent).
+
+// GUIslice modified the raw memory format to add a header:
+// Image array format:
+// - Width[15:8],  Width[7:0],
+// - Height[15:8], Height[7:0],
+// - ColorR[7:0],  ColorG[7:0],
+// - ColorB[7:0],  0x00,
+// - Monochrome bitmap follows...
+//
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,
+ const unsigned char *pBitmap,bool bProgMem)
+ {
+  const unsigned char*  bmap_base = pBitmap;
+  int16_t         w,h;
+  gslc_tsColor    nCol;
+
+  // Read header
+  w       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  w      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  h       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  h      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  nCol.r  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.g  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.b  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  bmap_base++;
+
+  int16_t i, j, byteWidth = (w + 7) / 8;
+  uint8_t nByte = 0;
+
+  for(j=0; j<h; j++) {
+    for(i=0; i<w; i++) {
+      if(i & 7) nByte <<= 1;
+      else {
+        if (bProgMem) {
+          nByte = pgm_read_byte(bmap_base + j * byteWidth + i / 8);
+        } else {
+          nByte = bmap_base[j * byteWidth + i / 8];
+        }
+      }
+      if(nByte & 0x80) {
+        gslc_DrvDrawPoint(pGui,nDstX+i,nDstY+j,nCol);
+      }
+    }
+  }
+}
+// ----- REFERENCE CODE end
+
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem)
+{
+  const uint16_t* pImage = (const uint16_t*)pBitmap;
+  int16_t h = *(pImage++);
+  int16_t w = *(pImage++);
+  int row, col;
+  for (row=0; row<h; row++) { // For each scanline...
+    for (col=0; col<w; col++) { // For each pixel...
+      if (bProgMem) {
+        //To read from Flash Memory, pgm_read_XXX is required.
+        //Since image is stored as uint16_t, pgm_read_word is used as it uses 16bit address
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, pgm_read_word(pImage++));
+      } else {
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, *(pImage++));
+      }
+    } // end pixel
+  }
+}
+
+#if (GSLC_SD_EN)
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/spitftbitmap/spitftbitmap.ino
+//   Original author:  Adafruit
+//   Function:         bmpDraw()
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+uint16_t gslc_DrvRead16SD(File &f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t gslc_DrvRead32SD(File &f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+void gslc_DrvDrawBmp24FromSD(gslc_tsGui* pGui,const char *filename, uint16_t x, uint16_t y)
+{
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  uint8_t  sdbuffer[3*GSLC_SD_BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+  boolean  goodBmp = false;       // Set to true on valid header parse
+  boolean  flip    = true;        // BMP is stored bottom-to-top
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0, startTime = millis();
+  (void)startTime; // Unused
+
+  if((x >= pGui->nDispW) || (y >= pGui->nDispH)) return;
+
+  //Serial.println();
+  //Serial.print("Loading image '");
+  //Serial.print(filename);
+  //Serial.println('\'');
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(filename)) == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() file not found [%s]",filename);
+    return;
+  }
+  // Parse BMP header
+  if(gslc_DrvRead16SD(bmpFile) == 0x4D42) { // BMP signature
+    uint32_t nFileSize = gslc_DrvRead32SD(bmpFile);
+    (void)nFileSize; // Unused
+    //Serial.print("File size: "); Serial.println(nFileSize);
+    (void)gslc_DrvRead32SD(bmpFile); // Read & ignore creator bytes
+    bmpImageoffset = gslc_DrvRead32SD(bmpFile); // Start of image data
+    //Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
+    // Read DIB header
+    uint32_t nHdrSize = gslc_DrvRead32SD(bmpFile);
+    (void)nHdrSize; // Unused
+    //Serial.print("Header size: "); Serial.println(nHdrSize);
+    bmpWidth  = gslc_DrvRead32SD(bmpFile);
+    bmpHeight = gslc_DrvRead32SD(bmpFile);
+    if(gslc_DrvRead16SD(bmpFile) == 1) { // # planes -- must be '1'
+      bmpDepth = gslc_DrvRead16SD(bmpFile); // bits per pixel
+      //Serial.print("Bit Depth: "); Serial.println(bmpDepth);
+      if((bmpDepth == 24) && (gslc_DrvRead32SD(bmpFile) == 0)) { // 0 = uncompressed
+        goodBmp = true; // Supported BMP format -- proceed!
+        //Serial.print("Image size: ");
+        //Serial.print(bmpWidth);
+        //Serial.print('x');
+        //Serial.println(bmpHeight);
+
+        // BMP rows are padded (if needed) to 4-byte boundary
+        rowSize = (bmpWidth * 3 + 3) & ~3;
+
+        // If bmpHeight is negative, image is in top-down order.
+        // This is not canon but has been observed in the wild.
+        if(bmpHeight < 0) {
+          bmpHeight = -bmpHeight;
+          flip      = false;
+        }
+
+        // Crop area to be loaded
+        w = bmpWidth;
+        h = bmpHeight;
+        if((x+w-1) >= pGui->nDispW) w = pGui->nDispW  - x;
+        if((y+h-1) >= pGui->nDispH) h = pGui->nDispH - y;
+
+        // Set TFT address window to clipped image bounds
+        //xxx tft.setAddrWindow(x, y, x+w-1, y+h-1);
+
+        for (row=0; row<h; row++) { // For each scanline...
+
+          // Seek to start of scan line.  It might seem labor-
+          // intensive to be doing this on every line, but this
+          // method covers a lot of gritty details like cropping
+          // and scanline padding.  Also, the seek only takes
+          // place if the file position actually needs to change
+          // (avoids a lot of cluster math in SD library).
+          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
+            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
+          else     // Bitmap is stored top-to-bottom
+            pos = bmpImageoffset + row * rowSize;
+          if(bmpFile.position() != pos) { // Need seek?
+            bmpFile.seek(pos);
+            buffidx = sizeof(sdbuffer); // Force buffer reload
+          }
+
+          for (col=0; col<w; col++) { // For each pixel...
+            // Time to read more pixel data?
+            if (buffidx >= sizeof(sdbuffer)) { // Indeed
+              bmpFile.read(sdbuffer, sizeof(sdbuffer));
+              buffidx = 0; // Set index to beginning
+            }
+
+            // Convert pixel from BMP to TFT format, push to display
+            b = sdbuffer[buffidx++];
+            g = sdbuffer[buffidx++];
+            r = sdbuffer[buffidx++];
+            //xxx tft.pushColor(tft.Color565(r,g,b));
+            gslc_tsColor nCol = (gslc_tsColor){r,g,b};
+            bool bDrawBit = true;
+            if (GSLC_BMP_TRANS_EN) {
+              gslc_tsColor nColTrans = pGui->sTransCol;
+              if ((nCol.r == nColTrans.r) && (nCol.g == nColTrans.g) && (nCol.b == nColTrans.b)) {
+                bDrawBit = false;
+              }
+            }
+            if (bDrawBit) {
+              gslc_DrvDrawPoint(pGui,x+col,y+row,nCol);
+            }
+
+          } // end pixel
+        } // end scanline
+        //Serial.print("Loaded in ");
+        //Serial.print(millis() - startTime);
+        //Serial.println(" ms");
+      } // end goodBmp
+    }
+  }
+  bmpFile.close();
+  if(!goodBmp) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() BMP format unknown [%s]",filename);
+  }
+}
+// ----- REFERENCE CODE end
+#endif // GSLC_SD_EN
+
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  #if defined(DBG_DRIVER)
+  char addr[6];
+  GSLC_DEBUG_PRINT("DBG: DrvDrawImage() with ImgBuf address=","");
+  sprintf(addr,"%04X",(unsigned int)sImgRef.pImgBuf);
+  GSLC_DEBUG_PRINT("%s\n",addr);
+  #endif
+
+  // GUIslice adapter library for Adafruit-GFX does not pre-load
+  // image data into memory before calling DrvDrawImage(), so
+  // we to handle the loading now (when rendering).
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return true;  // Nothing to do
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return false; // Not supported
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from SRAM
+      // - Dimensions and output color are defined in arrray header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in ram
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // TODO: Probably need to fix this to work with PROGMEM,
+    //       but check (GSLC_USE_PROGMEM) first
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from program memory
+      // - Dimensions and output color are defined in array header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in flash
+      // FIXME: Should we be passing "true" as last param?
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD media
+    #if (GSLC_SD_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // 24-bit Bitmap
+        gslc_DrvDrawBmp24FromSD(pGui,sImgRef.pFname,nDstX,nDstY);
+        return true;
+      } else {
+        // Unsupported format
+        return false;
+      }
+    #else
+      // SD card access not enabled
+      return false;
+    #endif
+
+  } else {
+    // Unsupported source
+    GSLC_DEBUG2_PRINT("DBG: DrvDrawImage() unsupported source eImgFlags=%d\n", sImgRef.eImgFlags);
+    return false;
+  }
+}
+
+
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    // Check to see if an image has been assigned to the background
+    if (pGui->sImgRefBkgnd.eImgFlags == GSLC_IMGREF_NONE) {
+      // No image assigned, so assume flat color background
+      // TODO: Create a new eImgFlags enum to signal that the
+      //       background should be a flat color instead of
+      //       an image.
+
+      // NOTE: We don't call m_disp.fillScreen() here as
+      //       that API doesn't support clipping. Since
+      //       we may be redrawing the page with a clipping
+      //       region enabled, it is important that we don't
+      //       redraw the entire screen.
+      gslc_tsRect rRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+      gslc_DrvDrawFillRect(pGui, rRect, pDriver->nColBkgnd);
+    } else {
+      // An image should be loaded
+      // TODO: For now, re-use the DrvDrawImage(). Later, consider
+      //       extending to support different background drawing
+      //       capabilities such as stretching and tiling of background
+      //       image.
+      gslc_DrvDrawImage(pGui, 0, 0, pGui->sImgRefBkgnd);
+    }
+  }
+}
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (via display driver)
+// -----------------------------------------------------------------------
+
+
+#if defined(DRV_TOUCH_IN_DISP)
+
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // For M5stack, no extra initialization is required to support the buttons
+
+  // Nothing further to do with driver
+  return true;
+}
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  // As the touch driver instance is optional, we need to check for
+  // its existence before returning a pointer to it.
+  #if defined(DRV_TOUCH_INSTANCE)
+    return (void*)(&m_touch);
+  #else
+    return NULL;
+  #endif
+}
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+
+  if ((pGui == NULL) || (pGui->pvDriver == NULL)) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvGetTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // Assign defaults
+  *pnX = 0;
+  *pnY = 0;
+  *pnPress = 0;
+
+  *peInputEvent = GSLC_INPUT_NONE;
+  *pnInputVal = 0;
+
+  // Trigger the M5 update routine
+  M5.update();
+
+  // Btn.wasReleasefor() is only available in the latest M5stack versions.
+#if defined(M5STACK_TOUCH_PRESS_LONG)
+  if (M5.BtnA.wasReleasefor(M5STACK_TOUCH_PRESS_LONG)) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_A_LONG;
+  }  else if (M5.BtnB.wasReleasefor(M5STACK_TOUCH_PRESS_LONG)) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_B_LONG;
+  }  else if (M5.BtnC.wasReleasefor(M5STACK_TOUCH_PRESS_LONG)) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_C_LONG;
+  } else if (M5.BtnA.wasReleased()) {
+#else
+  if (M5.BtnA.wasReleased()) {
+#endif
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_A;
+  }  else if (M5.BtnB.wasReleased()) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_B;
+  }  else if (M5.BtnC.wasReleased()) {
+    *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+    *pnInputVal = GSLC_PIN_BTN_C;
+  } else {
+    return false; // No pin event detected
+  }
+
+  // If we reached here, then we had a button event
+  return true;
+}
+
+#endif // DRV_TOUCH_IN_DISP
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  bool bChange = true;
+
+  // Determine if the new orientation has swapped axes
+  // versus the native orientation (0)
+  bool bSwap = false;
+  if ((nRotation == 1) || (nRotation == 3)) {
+    bSwap = true;
+  }
+  (void)bSwap; // Unused
+
+  // Did the orientation change?
+  if (nRotation == pGui->nRotation) {
+    // Orientation did not change -- indicate this by returning
+    // false so that we can avoid a redraw
+    bChange = false;
+  }
+
+  // Update the GUI rotation member
+  pGui->nRotation = nRotation;
+
+  // Inform the display to adjust the orientation and
+  // update the saved display dimensions
+
+  // DRV_DISP_M5STACK
+  // Capture display dimensions in native orientation
+  m_disp.setRotation(0);
+  pGui->nDisp0W = m_disp.width();
+  pGui->nDisp0H = m_disp.height();
+  // Capture display dimensions in selected orientation
+  m_disp.setRotation(pGui->nRotation);
+  pGui->nDispW = m_disp.width();
+  pGui->nDispH = m_disp.height();
+
+  // Update the clipping region
+  gslc_tsRect rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  gslc_DrvSetClipRect(pGui,&rClipRect);
+
+  // Now update the touch remapping
+  #if !defined(DRV_TOUCH_NONE)
+    // Correct touch mapping according to current rotation mode
+    pGui->nSwapXY = TOUCH_ROTATION_SWAPXY(pGui->nRotation);
+    pGui->nFlipX = TOUCH_ROTATION_FLIPX(pGui->nRotation);
+    pGui->nFlipY = TOUCH_ROTATION_FLIPY(pGui->nRotation);
+  #endif // !DRV_TOUCH_NONE
+
+  // Mark the current page ask requiring redraw
+  // if the rotation value changed
+  if (bChange) {
+    gslc_PageRedrawSet( pGui, true );
+  }
+
+  return true;
+}
+
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+
+// Convert from RGB struct to native screen format
+// TODO: Use 32bit return type?
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol)
+{
+  uint16_t nColRaw = 0;
+
+  #if defined(DRV_COLORMODE_MONO)
+    // Monochrome
+    if ((nCol.r == 0) && (nCol.g == 0) && (nCol.b == 0)) { // GSLC_COL_BLACK
+      nColRaw = 0;  // BLACK
+    } else {
+      nColRaw = 1;  // WHITE
+    }
+
+  #elif defined(DRV_COLORMODE_BGR565)
+    nColRaw |= (((nCol.b & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.r & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #else
+    // Default to DRV_COLORMODE_RGB565
+    nColRaw |= (((nCol.r & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.b & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #endif // DRV_COLORMODE_*
+
+  return nColRaw;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // Compiler guard for requested driver
diff --git a/src/guislice/GUIslice_drv_m5stack.h b/src/guislice/GUIslice_drv_m5stack.h
new file mode 100644
index 0000000..4db04be
--- /dev/null
+++ b/src/guislice/GUIslice_drv_m5stack.h
@@ -0,0 +1,656 @@
+#ifndef _GUISLICE_DRV_M5STACK_H_
+#define _GUISLICE_DRV_M5STACK_H_
+
+// =======================================================================
+// GUIslice library (driver layer for m5stack/M5Stack)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_m5stack.h
+/// \brief GUIslice library (driver layer for M5stack)
+
+
+// =======================================================================
+// Driver Layer for m5stack/M5Stack
+// - https://github.com/m5stack/M5Stack
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+
+// ------------------------------------------------------------------------
+// Error Strings
+// ------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT             1 ///< Support gslc_DrvDrawPoint()
+
+#define DRV_HAS_DRAW_POINTS            0 ///< Support gslc_DrvDrawPoints()
+#define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+#define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+#define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FRAME  1 ///< Support gslc_DrvDrawFrameRoundRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FILL   1 ///< Support gslc_DrvDrawFillRoundRect()
+#define DRV_HAS_DRAW_CIRCLE_FRAME      1 ///< Support gslc_DrvDrawFrameCircle()
+#define DRV_HAS_DRAW_CIRCLE_FILL       1 ///< Support gslc_DrvDrawFillCircle()
+#define DRV_HAS_DRAW_TRI_FRAME         1 ///< Support gslc_DrvDrawFrameTriangle()
+#define DRV_HAS_DRAW_TRI_FILL          1 ///< Support gslc_DrvDrawFillTriangle()
+#define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+#define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+
+#define DRV_OVERRIDE_TXT_ALIGN         1 ///< Driver provides text alignment
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+  gslc_tsColor  nColBkgnd;      ///< Background color (if not image-based)
+
+  gslc_tsRect   rClipRect;      ///< Clipping rectangle
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit(). This can be done with gslc_DrvInitEnv()
+///   or manually in user function.
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTs(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(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_DrvGetDriverDisp(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_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// 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_DrvSetBkgndImage(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_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type (GSLC_FONTREF_PTR for Arduino)
+/// \param[in]  pvFontRef:      Font reference pointer (Pointer to the GFXFont array)
+/// \param[in]  nFontSz:        Typeface size to use
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in m5stack, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+///
+/// Draw a text string in a bounding box using the specified alignment
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X coordinate of top-left of bounding box
+/// \param[in]  nY0:         Y coordinate of top-left of bounding box
+/// \param[in]  nX1:         X coordinate of bot-right of bounding box
+/// \param[in]  nY1:         Y coordinate of bot-right of bounding box
+/// \param[in]  eTxtAlign:   Alignment mode]
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in m5stack, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxtAlign(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,int8_t eTxtAlign,
+        gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,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 true if success, false if error
+///
+bool gslc_DrvDrawFillRect(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 rounded corners
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,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 rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameCircle(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 of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillCircle(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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameTriangle(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 to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// Draw a monochrome bitmap from a memory array
+/// - Draw from the bitmap buffer using the foreground color
+///   defined in the header (unset bits are transparent)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY, const unsigned char *pBitmap,bool bProgMem);
+
+///
+/// Draw a color 24-bit depth bitmap from a memory array
+/// - Note that users must convert images from their native
+///   format (eg. BMP, PNG, etc.) into a C array. Please
+///   refer to the following guide for details:
+///   https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Images-from-FLASH
+/// - The converted file (c array) can then be included in the sketch.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       X coord for copy
+/// \param[in]  nDstY:       Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem);
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using display driver library)
+// -----------------------------------------------------------------------
+
+#if defined(DRV_TOUCH_IN_DISP)
+// Use M5stack's integrated button handler
+
+///
+/// Perform any touch-specific initialization
+/// - This function doesn't do anything in M5stack
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the internal button handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event (UNUSED)
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event (UNUSED)
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch) (UNUSED)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_IN_DISP
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_M5STACK_H_
diff --git a/src/guislice/GUIslice_drv_sdl.c b/src/guislice/GUIslice_drv_sdl.c
new file mode 100644
index 0000000..521e93b
--- /dev/null
+++ b/src/guislice/GUIslice_drv_sdl.c
@@ -0,0 +1,1470 @@
+// =======================================================================
+// GUIslice library (driver layer for SDL 1.2 & 2.0)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_sdl.c
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_SDL1) || defined(DRV_DISP_SDL2)
+
+// =======================================================================
+// Driver Layer for SDL
+// =======================================================================
+
+
+// GUIslice library
+#include "GUIslice_drv_sdl.h"
+
+#include <stdio.h>
+
+// ------------------------------------------------------------------------
+// Load display & touch drivers
+// ------------------------------------------------------------------------
+
+// Optionally enable SDL clean start VT workaround
+#if (DRV_SDL_FIX_START)
+  #include <fcntl.h>      // For O_RDONLY
+  #include <errno.h>      // For errno
+  #include <unistd.h>     // For close()
+  #include <sys/ioctl.h>  // For ioctl()
+  #include <sys/kd.h>     // for KDSETMODE
+  #include <sys/vt.h>     // for VT_UNLOCKSWITCH
+  #define DRV_SDL_FIX_TTY      "/dev/tty0"
+#endif
+
+// Define driver names
+#if defined(DRV_DISP_SDL1)
+  const char* m_acDrvDisp = "SDL1";
+#elif defined(DRV_DISP_SDL2)
+  const char* m_acDrvDisp = "SDL2";
+#endif
+
+#if defined(DRV_TOUCH_TSLIB)
+  const char* m_acDrvTouch = "TSLIB";
+#else
+  const char* m_acDrvTouch = "SDL";
+#endif
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+  // Report any debug info (before init) if enabled
+  #if defined(DBG_DRIVER)
+  gslc_DrvReportInfoPre();
+  #endif
+
+  // Primary surface definitions
+  pGui->sImgRefBkgnd = gslc_ResetImage();
+
+  // Initialize any SDL version-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    #if defined(DRV_DISP_SDL1)
+    pDriver->pSurfScreen = NULL;
+    pGui->bRedrawPartialEn = true;
+    #endif
+
+    #if defined(DRV_DISP_SDL2)
+    pDriver->pWind       = NULL;
+    pDriver->pRender     = NULL;
+    // In SDL2, always need full page redraw since backbuffer
+    // is treated as invalidated after every RenderPresent()
+    pGui->bRedrawPartialEn = false;
+    #endif
+  }
+
+
+#if (DRV_SDL_FIX_START)
+  // Force a clean start to SDL to workaround any bad state
+  // left behind by a previous SDL application's failure to
+  // clean up.
+  // TODO: Allow compiler option to skip this workaround
+  // TODO: Allow determination of the TTY to use
+  gslc_DrvCleanStart(DRV_SDL_FIX_TTY);
+#endif
+
+  // Setup SDL
+  if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInit() error in SDL_Init(): %s\n",SDL_GetError());
+    return false;
+  }
+  // Now that we have successfully initialized SDL
+  // we need to register an exit handler so that SDL_Quit()
+  // gets called at program termination. If we don't do this
+  // then some types of errors/aborts will result in
+  // the SDL environment being left in a bad state that
+  // affects the next SDL program execution.
+  atexit(SDL_Quit);
+
+  // Report any debug info (after init) if enabled
+  #if defined(DBG_DRIVER)
+  gslc_DrvReportInfoPost();
+  #endif
+
+
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+#if defined(DRV_DISP_SDL1)
+  // Set up pGui->pSurfScreen
+  const SDL_VideoInfo*  videoInfo = SDL_GetVideoInfo();
+  int16_t               nSystemX = videoInfo->current_w;
+  int16_t               nSystemY = videoInfo->current_h;
+  uint8_t               nBpp = videoInfo->vfmt->BitsPerPixel ;
+
+  // Save a copy of the display dimensions
+  pGui->nDispW      = nSystemX;
+  pGui->nDispH      = nSystemY;
+  pGui->nDispDepth  = nBpp;
+
+  #if defined(DBG_DRIVER)
+  GSLC_DEBUG_PRINT("DBG: Video mode: %u x %u x %u bit/pixel\n",
+          pGui->nDispW,pGui->nDispH,pGui->nDispDepth);
+  #endif
+
+  // SDL_SWSURFACE is apparently more reliable
+  pDriver->pSurfScreen = SDL_SetVideoMode(nSystemX,nSystemY,nBpp,SDL_SWSURFACE | SDL_FULLSCREEN);
+  if (!pDriver->pSurfScreen) {
+    GSLC_DEBUG_PRINT("ERROR: DrvInit() error in SDL_SetVideoMode(): %s\n",SDL_GetError());
+    return false;
+  }
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  // Default to using OpenGL rendering engine and full-screen
+  // When using SDL_WINDOW_FULLSCREEN, the width & height dimensions are ignored
+  pDriver->pWind = SDL_CreateWindow("GUIslice",SDL_WINDOWPOS_UNDEFINED,SDL_WINDOWPOS_UNDEFINED,
+          0,0,SDL_WINDOW_FULLSCREEN | SDL_WINDOW_OPENGL);
+  if (!pDriver->pWind) {
+    GSLC_DEBUG_PRINT("ERROR: DrvInit() error in SDL_CreateWindow(): %s\n",SDL_GetError());
+    return false;
+  }
+
+  // Save a copy of the display dimensions from the created fullscreen window
+  int nSystemX,nSystemY;
+  SDL_GetWindowSize(pDriver->pWind,&nSystemX,&nSystemY);
+  pGui->nDispW = nSystemX;
+  pGui->nDispH = nSystemY;
+
+  // Fetch the bit depth of the first display
+  SDL_DisplayMode sDispMode;
+  int nRet = SDL_GetCurrentDisplayMode(0,&sDispMode);
+  if (nRet != 0) {
+    // TODO: ERROR
+    return false;
+  }
+  pGui->nDispDepth = SDL_BITSPERPIXEL(sDispMode.format);
+
+  #if defined(DBG_DRIVER)
+  GSLC_DEBUG_PRINT("DBG: Video mode: %u x %u x %u bit/pixel\n",
+          pGui->nDispW,pGui->nDispH,pGui->nDispDepth);
+  #endif
+
+  // Create renderer
+  // TODO: Resolve performance with "accelerated" renderer (SDL_RENDERER_ACCELERATED.
+  //       For now, use software renderer (SDL_RENDERER_SOFTWARE) which appears
+  //       to be much faster.
+
+  // If we are sure that the OpenGL ES 2.0 driver has been installed, we
+  // can request that SDL use this as a renderer. Disable this for now.
+  // SDL_SetHint(SDL_HINT_RENDER_DRIVER,"opengles2");
+
+  #if (DRV_SDL_RENDER_ACCEL)
+  pDriver->pRender = SDL_CreateRenderer(pDriver->pWind,-1,SDL_RENDERER_ACCELERATED);
+  #else
+  pDriver->pRender = SDL_CreateRenderer(pDriver->pWind,-1,SDL_RENDERER_SOFTWARE);
+  #endif
+  if (!pDriver->pRender) {
+    GSLC_DEBUG_PRINT("ERROR: DrvInit() error in SDL_CreateRenderer(): %s\n",SDL_GetError());
+    return false;
+  }
+
+  #if defined(DBG_DRIVER)
+  SDL_RendererInfo  sRendInfo;
+  SDL_GetRendererInfo(pDriver->pRender,&sRendInfo);
+  GSLC_DEBUG_PRINT("DBG: Renderer selected: [%s]\n",
+          sRendInfo.name);
+  #endif
+
+  // If we wanted to support scaling of the renderer, we would call
+  // SDL_RenderSetLogicalSize() here. For now, don't scale.
+
+#endif
+
+  // Initialize font engine
+  if (TTF_Init() == -1) {
+    GSLC_DEBUG_PRINT("ERROR: DrvInit(%s) error in TTF_Init()\n","");
+    return false;
+  }
+
+  // Since the mouse cursor is based on SDL coords which are badly
+  // scaled when in touch mode, we will disable the mouse pointer.
+  // Note that the SDL coords seem to be OK when in actual mouse mode.
+  #if (!DRV_SDL_MOUSE_SHOW)
+  SDL_ShowCursor(SDL_DISABLE);
+  #endif
+
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (pGui->pvDriver);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pDriver->pRender) {
+    SDL_DestroyRenderer(pDriver->pRender);
+    pDriver->pRender = NULL;
+  }
+  if (pDriver->pWind) {
+    SDL_DestroyWindow(pDriver->pWind);
+    pDriver->pWind = NULL;
+  }
+#endif
+
+  // Close down SDL
+  SDL_Quit();
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD card
+    // TODO: Not yet supported
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    // Load image from RAM
+    // TODO: Not yet supported
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // Load image from FLASH
+    // TODO: Not yet supported
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    // Load image from file system
+    const char* pStrFname = sImgRef.pFname;
+
+    // Pointer to the surface image that was loaded
+    SDL_Surface* pSurfLoaded = NULL;
+
+    // Load the image
+    // - The SDL_LoadBMP() routine should be able to handle a multitude of
+    //   BMP format types.
+    // - TODO: Check (eImgFlags & GSLC_IMGREF_FMT) to ensure type is supported
+    pSurfLoaded = SDL_LoadBMP(pStrFname);
+
+    // Confirm that the image loaded correctly
+    if (pSurfLoaded == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: DrvLoadBmpFile(%s) failed: %s\n",pStrFname,SDL_GetError());
+      return NULL;
+    }
+
+    #if defined(DRV_DISP_SDL1)
+
+    //Create an optimized surface
+
+    //The optimized surface that will be used
+    SDL_Surface* pSurfOptimized = SDL_DisplayFormat( pSurfLoaded );
+
+    //Free the old surface
+    SDL_FreeSurface( pSurfLoaded );
+
+    //If the surface was optimized
+    if( pSurfOptimized != NULL ) {
+
+      // Support optional transparency
+      if (GSLC_BMP_TRANS_EN) {
+        // Color key surface
+        // - Use transparency color key defined in BMP_TRANS_RGB
+        SDL_SetColorKey( pSurfOptimized, SDL_SRCCOLORKEY,
+          SDL_MapRGB( pSurfOptimized->format, GSLC_BMP_TRANS_RGB ) );
+      } // GSLC_BMP_TRANS_EN
+    }
+
+    //Return the optimized surface
+    return (void*)(pSurfOptimized);
+
+    #endif
+
+    #if defined(DRV_DISP_SDL2)
+    gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    SDL_Texture*  pTex = NULL;
+
+    if( pSurfLoaded != NULL ) {
+
+      // Support optional transparency
+      if (GSLC_BMP_TRANS_EN) {
+        // Color key surface
+        // - Use transparency color key defined in BMP_TRANS_RGB
+        // - SDL2 passes SDL_TRUE instead of SDL_SRCCOLORKEY
+        SDL_SetColorKey( pSurfLoaded, SDL_TRUE,
+          SDL_MapRGB( pSurfLoaded->format, GSLC_BMP_TRANS_RGB ) );
+      } // GSLC_BMP_TRANS_EN
+    }
+
+    pTex = (void*)SDL_CreateTextureFromSurface(pDriver->pRender,pSurfLoaded);
+    if (pTex == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: DrvLoadBmp(%s) SDL_CreateTextureFromSurface() failed: %s\n",pStrFname,SDL_GetError());
+      return NULL;
+    }
+
+    // Dispose of surface
+    SDL_FreeSurface(pSurfLoaded);
+    pSurfLoaded = NULL;
+
+    //Return the texture
+    return (void*)pTex;
+
+    #endif
+
+  } // eImgFlags
+
+  // If reached here, it is an error
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  SDL_Surface* pSurfBkgnd = NULL;
+
+  uint16_t nScreenW = pGui->nDispW;
+  uint16_t nScreenH = pGui->nDispH;
+  uint8_t  nBpp     = pGui->nDispDepth;
+
+  // Create surface that we can draw into
+  // - For the masks, we can pass 0 to get defaults
+#if defined(DRV_DISP_SDL1)
+  pSurfBkgnd = SDL_CreateRGBSurface(SDL_SWSURFACE,nScreenW,nScreenH,nBpp,0,0,0,0);
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  // - In SDL2, the flags field is ignored, so set to 0
+  pSurfBkgnd = SDL_CreateRGBSurface(0,nScreenW,nScreenH,nBpp,0,0,0,0);
+#endif
+
+  if (pSurfBkgnd == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndColor() SDL_CreateRGBSurface failed: %s\n",SDL_GetError());
+    return false;
+  }
+
+  // Fill with requested color
+  SDL_FillRect(pSurfBkgnd,NULL,
+    SDL_MapRGB(pSurfBkgnd->format,nCol.r,nCol.g,nCol.b));
+
+#if defined(DRV_DISP_SDL1)
+  // Save surface into GUI struct
+  pGui->sImgRefBkgnd.pvImgRaw = (void*)(pSurfBkgnd);
+#endif
+#if defined(DRV_DISP_SDL2)
+  // Convert to texture and save into GUI struct
+  pGui->sImgRefBkgnd.pvImgRaw = (void*)SDL_CreateTextureFromSurface(pDriver->pRender,pSurfBkgnd);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndColor() SDL_CreateTextureFromSurface failed: %s\n",SDL_GetError());
+    return false;
+  }
+  // Dispose of temporary surface
+  SDL_FreeSurface(pSurfBkgnd);
+  pSurfBkgnd = NULL;
+#endif
+
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous image
+  if (pElem->sImgRefNorm.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pElem->sImgRefNorm.pvImgRaw);
+    pElem->sImgRefNorm = gslc_ResetImage();
+  }
+
+  pElem->sImgRefNorm = sImgRef;
+  pElem->sImgRefNorm.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pElem->sImgRefNorm.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetElemImageNorm(%s) failed\n","");
+    return false;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous image
+  if (pElem->sImgRefGlow.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pElem->sImgRefGlow.pvImgRaw);
+    pElem->sImgRefGlow = gslc_ResetImage();
+  }
+
+  pElem->sImgRefGlow = sImgRef;
+  pElem->sImgRefGlow.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pElem->sImgRefGlow.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetElemImageGlow(%s) failed\n","");
+    return false;
+  }
+  return true;
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+  if (pvImg == NULL) {
+    return;
+  }
+  #if defined(DRV_DISP_SDL1)
+  SDL_FreeSurface((SDL_Surface*)pvImg);
+  #endif
+  #if defined(DRV_DISP_SDL2)
+  SDL_DestroyTexture((SDL_Texture*)pvImg);
+  #endif
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+#if defined(DRV_DISP_SDL1)
+  SDL_Surface*  pScreen = pDriver->pSurfScreen;
+  if (pRect == NULL) {
+    SDL_SetClipRect(pScreen,NULL);
+  } else {
+    SDL_Rect  rSRect = gslc_DrvAdaptRect(*pRect);
+    SDL_SetClipRect(pScreen,&rSRect);
+  }
+  return true;
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer*  pRender = pDriver->pRender;
+  if (pRect == NULL) {
+    SDL_RenderSetClipRect(pRender,NULL);
+  } else {
+    SDL_Rect  rSRect = gslc_DrvAdaptRect(*pRect);
+    SDL_RenderSetClipRect(pRender,&rSRect);
+  }
+  return true;
+#endif
+
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz)
+{
+  // UNIX/SDL mode currently only supports font definitions from files
+  if (eFontRefType != GSLC_FONTREF_FNAME) {
+    GSLC_DEBUG_PRINT("ERROR: DrvFontAdd(%s) failed - SDL mode only supports file-based fonts\n","");
+    return NULL;
+  }
+  TTF_Font*   pFont;
+  // In the case of SDL, the pvFontRef is a string that defines the
+  // file path to the font file
+  pFont = TTF_OpenFont((const char*)pvFontRef,nFontSz);
+  if (pFont == NULL) {
+    GSLC_DEBUG_PRINT("ERROR: DrvFontAdd(%s) failed in TTF_OpenFont\n",pvFontRef);
+    return NULL;
+  }
+  return (const void*)pFont;
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  uint16_t  nFontInd;
+  TTF_Font* pFont = NULL;
+  for (nFontInd=0;nFontInd<pGui->nFontCnt;nFontInd++) {
+    if (pGui->asFont[nFontInd].pvFont != NULL) {
+      pFont = (TTF_Font*)(pGui->asFont[nFontInd].pvFont);
+      TTF_CloseFont(pFont);
+      pGui->asFont[nFontInd].pvFont = NULL;
+    }
+  }
+  pGui->nFontCnt = 0;
+  TTF_Quit();
+}
+
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  // NOTE: Shouldn't need to process eTxtFlags
+  int32_t nTxtSzW,nTxtSzH;
+  TTF_Font* pDrvFont = (TTF_Font*)(pFont->pvFont);
+  if (!pDrvFont) { return false; }
+  if ((eTxtFlags & GSLC_TXT_ENC) == GSLC_TXT_ENC_UTF8) {
+    TTF_SizeUTF8(pDrvFont,pStr,&nTxtSzW,&nTxtSzH);
+  } else {
+    TTF_SizeText(pDrvFont,pStr,&nTxtSzW,&nTxtSzH);
+  }
+  *pnTxtSzW = (uint16_t)nTxtSzW;
+  *pnTxtSzH = (uint16_t)nTxtSzH;
+  // No offset coordinates used
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+  return true;
+}
+
+
+// NOTE: SDL driver is compiled as pure C, so can't use default parameters.
+//       Other drivers have specified colBg as a default, but so far no callers
+//       are depending on the default.
+// TODO: Update DrvDrawTxt() and DrvDrawTxtAlign() APIs for all drivers to
+//       no longer use the default param for consistency.
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg)
+{
+  if ((pGui == NULL) || (pFont == NULL)) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawTxt(%s) with NULL ptr\n","");
+    return false;
+  }
+  if ((pStr == NULL) || (pStr[0] == '\0')) {
+    return true;
+  }
+
+  gslc_tsDriver*  pDriver   = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Surface*    pSurfTxt  = NULL;
+  TTF_Font*       pDrvFont  = (TTF_Font*)(pFont->pvFont);
+  if (!pDrvFont) { return false; }
+  if ((eTxtFlags & GSLC_TXT_ENC) == GSLC_TXT_ENC_UTF8) {
+    pSurfTxt = TTF_RenderUTF8_Blended(pDrvFont,pStr,gslc_DrvAdaptColor(colTxt));
+  } else {
+    pSurfTxt = TTF_RenderText_Blended(pDrvFont,pStr,gslc_DrvAdaptColor(colTxt));
+  }
+  if (pSurfTxt == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawTxt() failed in TTF_RenderText_Solid() (%s)\n",pStr);
+    return false;
+  }
+
+
+#if defined(DRV_DISP_SDL1)
+  gslc_DrvPasteSurface(pGui,nTxtX,nTxtY,pSurfTxt,pDriver->pSurfScreen);
+#endif
+#if defined(DRV_DISP_SDL2)
+  SDL_Rect rRect = (SDL_Rect){nTxtX,nTxtY,pSurfTxt->w,pSurfTxt->h};
+  SDL_Renderer* pRender = pDriver->pRender;
+  SDL_Texture* pTex = SDL_CreateTextureFromSurface(pRender,pSurfTxt);
+  if (pTex == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawTxt() error in SDL_CreateTextureFromSurface(): %s\n",SDL_GetError());
+    return false;
+  }
+  SDL_RenderCopy(pRender,pTex,NULL,&rRect);
+
+  // Destroy texture
+  // TODO: Consider if worth optimizing by retaining texture in case
+  //       we need to redraw it without changing content
+  SDL_DestroyTexture(pTex);
+  pTex = NULL;
+#endif
+
+  // Dispose of temporary surface
+  if (pSurfTxt != NULL) {
+    SDL_FreeSurface(pSurfTxt);
+    pSurfTxt = NULL;
+  }
+
+  return true;
+}
+
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+#if defined(DRV_DISP_SDL1)
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+  SDL_Flip(pScreen);
+#endif
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer* pRender = pDriver->pRender;
+  if (pRender) {
+    // Flip the offscreen buffer so we can display our drawing output
+    SDL_RenderPresent(pRender);
+    // Clear the drawing before any new drawing occurs
+    SDL_SetRenderDrawColor(pRender,0x00,0x00,0x00,0xFF);
+    SDL_RenderClear(pRender);
+  }
+#endif
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if defined(DRV_DISP_SDL1)
+  if (gslc_DrvScreenLock(pGui)) {
+    uint32_t nColRaw = gslc_DrvAdaptColorRaw(pGui,nCol);
+    gslc_DrvDrawSetPixelRaw(pGui,nX,nY,nColRaw);
+    gslc_DrvScreenUnlock(pGui);
+  }
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Renderer*  pRender = pDriver->pRender;
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_RenderDrawPoint(pRender,nX,nY);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+#if defined(DRV_DISP_SDL1)
+  uint16_t nIndPt;
+  if (gslc_DrvScreenLock(pGui)) {
+    uint32_t nColRaw = gslc_DrvAdaptColorRaw(pGui,nCol);
+    for (nIndPt=0;nIndPt<nNumPt;nIndPt++) {
+      gslc_DrvDrawSetPixelRaw(pGui,asPt[nIndPt].x,asPt[nIndPt].y,nColRaw);
+    }
+    gslc_DrvScreenUnlock(pGui);
+  }
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Renderer* pRender = pDriver->pRender;
+  // NOTE: gslc_tsPt is defined to have the same layout as SDL_Point
+  //       so we simply typecast it here. This saves us from having
+  //       to perform any malloc() and type conversion.
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_RenderDrawPoints(pRender,(SDL_Point*)asPt,(int)nNumPt);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+#if defined(DRV_DISP_SDL1)
+  // Typecast
+  SDL_Rect      rSRect  = gslc_DrvAdaptRect(rRect);
+  SDL_Surface*  pScreen = pDriver->pSurfScreen;
+
+  // Call SDL optimized routine
+  SDL_FillRect(pScreen,&rSRect,
+    SDL_MapRGB(pScreen->format,nCol.r,nCol.g,nCol.b));
+#endif
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer* pRender = pDriver->pRender;
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_Rect  rRectSdl;
+  rRectSdl = gslc_DrvAdaptRect(rRect);
+  SDL_RenderFillRect(pRender,&rRectSdl);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if defined(DRV_DISP_SDL1)
+  return false;
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Renderer* pRender  = pDriver->pRender;
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_Rect  rRectSdl;
+  rRectSdl = gslc_DrvAdaptRect(rRect);
+  SDL_RenderDrawRect(pRender,&rRectSdl);
+  return true;
+#endif
+}
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if defined(DRV_DISP_SDL1)
+  // ERROR
+  return false;
+#endif
+#if defined(DRV_DISP_SDL2)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Renderer* pRender  = pDriver->pRender;
+  SDL_SetRenderDrawColor(pRender,nCol.r,nCol.g,nCol.b,255);
+
+  // Call SDL optimized routine
+  SDL_RenderDrawLine(pRender,nX0,nY0,nX1,nY1);
+  return true;
+#endif
+}
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawImage(%s) with NULL ptr\n","");
+    return false;
+  }
+  // GUIslice adapter library for SDL always pre-loads
+  // surfaces / textures before calling DrvDrawImage(), so
+  // we just need to confirm that the raw image data is defined.
+  void* pImage = sImgRef.pvImgRaw;
+  if (pImage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawImage(%s) with NULL pvImgRaw\n","");
+    return false;
+  }
+
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+#if defined(DRV_DISP_SDL1)
+  gslc_DrvPasteSurface(pGui,nDstX,nDstY,pImage,pDriver->pSurfScreen);
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer* pRender = pDriver->pRender;
+  SDL_Texture*  pTex    = (SDL_Texture*)pImage;
+
+  // Determine dest rect based on source texture dimensions and parameterized offset
+  SDL_Rect  rDest;
+  rDest.x = nDstX;
+  rDest.y = nDstY;
+  SDL_QueryTexture(pTex,NULL,NULL,&rDest.w,&rDest.h);
+
+  // Default to copying all of source texture rect by specifying NULL
+  SDL_RenderCopy(pRender,pTex,NULL,&rDest);
+#endif
+
+  return true;
+}
+
+
+/// NOTE: Background image is stored in pGui->sImgRefBkgnd
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBkgnd(%s) with NULL ptr\n","");
+    return;
+  }
+  // GUIslice adapter library for SDL always pre-loads
+  // surfaces / textures before calling DrvDrawBkgnd(), so
+  // we just need to confirm that the raw image data is defined.
+  void* pImage = pGui->sImgRefBkgnd.pvImgRaw;
+  if (pImage == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBkgnd(%s) with NULL pvImgRaw\n","");
+
+    // Since the image load failed, resort to black background
+    gslc_DrvSetBkgndColor(pGui,GSLC_COL_BLACK);
+    return;
+  }
+
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+#if defined(DRV_DISP_SDL1)
+  gslc_DrvPasteSurface(pGui,0,0,pGui->sImgRefBkgnd.pvImgRaw,pDriver->pSurfScreen);
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  SDL_Renderer* pRender = pDriver->pRender;
+  SDL_Texture*  pTex    = (SDL_Texture*)(pGui->sImgRefBkgnd.pvImgRaw);
+
+  // Determine destination rect
+
+  // TODO: Support other background modes such as:
+  // - Single Corner Unscaled
+  // - Single Centered Unscaled
+  // - Single Centered Scaled
+  // - Tiled Corner Unscaled
+
+  // For "single centered scaled", we fetch entire viewport
+  SDL_Rect  rDest;
+  SDL_RenderGetViewport(pDriver->pRender,&rDest);
+  rDest.x = 0;
+  rDest.y = 0;
+
+  // Default to copying all of source texture rect by specifying NULL
+  SDL_RenderCopy(pRender,pTex,NULL,&rDest);
+#endif
+
+}
+
+
+
+// ------------------------------------------------------------------------
+// Touch Functions (via SDL)
+// ------------------------------------------------------------------------
+
+// POST:
+// - pDriver->pTsDev mapped to touchscreen device
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // Perform any driver-specific touchscreen init here
+
+  #if defined(DRV_TOUCH_TSLIB)
+    // Assign default
+    gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->pTsDev = NULL;
+  #endif
+
+  // Nothing further to do with SDL driver
+  return true;
+}
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  return NULL;
+}
+
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvGetTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // Use SDL for touch events
+  bool        bRet = false;
+  SDL_Event   sEvent;
+  int32_t     nX,nY;
+  int16_t     nKeyVal;
+
+  *peInputEvent = GSLC_INPUT_NONE;
+
+  if (SDL_PollEvent(&sEvent)) {
+    nKeyVal = (int16_t)(sEvent.key.keysym.sym);
+
+    // Handle Key presses
+    if (sEvent.type == SDL_KEYDOWN) {
+      #if (GSLC_FEATURE_INPUT)
+        *peInputEvent = GSLC_INPUT_KEY_DOWN;
+        *pnInputVal = nKeyVal;
+        bRet = true;
+      #endif
+    } else if (sEvent.type == SDL_KEYUP) {
+      #if (GSLC_FEATURE_INPUT)
+        *peInputEvent = GSLC_INPUT_KEY_UP;
+        *pnInputVal = nKeyVal;
+        bRet = true;
+      #endif
+
+    // Handle Touch / Mouse presses
+    } else if (sEvent.type == SDL_MOUSEMOTION) {
+      #if defined(DRV_DISP_SDL1)
+        SDL_GetMouseState(&nX,&nY);
+      #elif defined(DRV_DISP_SDL2)
+        nX = sEvent.button.x;
+        nY = sEvent.button.y;
+      #endif
+      *pnX = (int16_t)nX;
+      *pnY = (int16_t)nY;
+      // For MOUSEMOTION, we want to return the previous state of
+      // the touch pressure in pnPress as MOUSEMOTION is called during
+      // both mouse up and mouse down states.
+      // Note that we can't simply leave pnPress as-is since it
+      // doesn't retain its state in the caller.
+      *pnPress = pGui->nTouchLastPress;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    } else if (sEvent.type == SDL_MOUSEBUTTONDOWN) {
+      #if defined(DRV_DISP_SDL1)
+        SDL_GetMouseState(&nX,&nY);
+      #elif defined(DRV_DISP_SDL2)
+        nX = sEvent.button.x;
+        nY = sEvent.button.y;
+      #endif
+      *pnX = (int16_t)nX;
+      *pnY = (int16_t)nY;
+      (*pnPress) = 1;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    } else if (sEvent.type == SDL_MOUSEBUTTONUP) {
+      #if defined(DRV_DISP_SDL1)
+        SDL_GetMouseState(&nX,&nY);
+      #elif defined(DRV_DISP_SDL2)
+        nX = sEvent.motion.x;
+        nY = sEvent.motion.y;
+      #endif
+      *pnX = (int16_t)nX;
+      *pnY = (int16_t)nY;
+      (*pnPress) = 0;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+
+
+    // SDL2 defines touch events instead of reusing mouse events
+    #if defined(DRV_DISP_SDL2)
+
+    } else if (sEvent.type == SDL_FINGERMOTION) {
+      *pnX = (int16_t)(sEvent.tfinger.x);
+      *pnY = (int16_t)(sEvent.tfinger.y);
+      // For FINGERMOTION, we want to return the previous state of
+      // the touch pressure in pnPress as FINGERMOTION is called during
+      // both up and down states.
+      // Note that we can't simply leave pnPress as-is since it
+      // doesn't retain its state in the caller.
+      *pnPress = pGui->nTouchLastPress;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    } else if (sEvent.type == SDL_FINGERDOWN) {
+      *pnX = (int16_t)(sEvent.tfinger.x);
+      *pnY = (int16_t)(sEvent.tfinger.y);
+      (*pnPress) = 1;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    } else if (sEvent.type == SDL_FINGERUP) {
+      *pnX = (int16_t)(sEvent.tfinger.x);
+      *pnY = (int16_t)(sEvent.tfinger.y);
+      (*pnPress) = 0;
+      *peInputEvent = GSLC_INPUT_TOUCH;
+      bRet = true;
+    #endif  // DRV_DISP_SDL2
+
+    }
+  } // SDL_PollEvent()
+
+  return bRet;
+}
+
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  // TODO: Implement support for display rotation
+  GSLC_DEBUG2_PRINT("ERROR: DrvRotate(%s) not supported in current DRV_DISP_SDL* mode yet\n","");
+  return false;
+}
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+// Unfortunately, SDL has an issue wherein if a previous
+// SDL program execution aborts before cleaning up properly (eg.
+// with SDL_Quit) then the next time SDL_SetVideoMode
+// is called, it may hang.
+//
+// The following code attempts to work around this sensitivity
+// in SDL, making the SDL_SetVideoMode call more robust.
+//
+// DETAILS:
+// - If an SDL program exits without first calling the cleanup
+//   routines (ie. in SDL_Quit() ), the terminal may be left in
+//   KD_GRAPHICS mode.
+// - When another SDL program is started and attempts to call
+//   SDL_SetVideoMode(), program execution may hang in
+//   FB_EnterGraphicsMode() during the wait on switch to
+//   KD_GRAPHICS mode. Since we are already in KD_GRAPHICS
+//   this event never occurs.
+// - This workaround unlocks the switch (which was set at the
+//   end of a previous call to FB_EnterGraphicsMode) and then
+//   forces the terminal to KD_TEXT mode.
+// - By starting in text mode, we should then observe a VT
+//   switch event as we attempt to transition to graphics mode
+//   in the call to SDL_SetVideoMode().
+bool gslc_DrvCleanStart(const char* sTTY)
+{
+#if (DRV_SDL_FIX_START)
+    int     nFD = -1;
+    int     nRet = false;
+
+    nFD = open(sTTY, O_RDONLY, 0);
+    if (nFD < 0) {
+        GSLC_DEBUG2_PRINT( "ERROR: DrvCleanStart() failed to open console (%s): %s\n",
+            sTTY,strerror(errno));
+        return false;
+    }
+    nRet = ioctl(nFD, VT_UNLOCKSWITCH, 1);
+    if (nRet != false) {
+         GSLC_DEBUG2_PRINT( "ERROR: DrvCleanStart() failed to unlock console (%s): %s\n",
+            sTTY,strerror(errno));
+        return false;
+    }
+    nRet = ioctl(nFD, KDSETMODE, KD_TEXT);
+    if (nRet != 0) {
+         GSLC_DEBUG2_PRINT( "ERROR: DrvCleanStart() failed to set text mode (%s): %s\n",
+            sTTY,strerror(errno));
+        return false;
+    }
+    close(nFD);
+#endif
+    return true;
+}
+
+// Report some SDL debug info
+void gslc_DrvReportInfoPre()
+{
+
+
+#if defined(DRV_DISP_SDL1)
+
+#elif defined(DRV_DISP_SDL2)
+  int16_t           nDriverInd = 0;
+  int16_t           nNumDrivers = 0;
+
+  // Video driver info
+  const char*   pDriverName = NULL;
+  bool          bDriverOk = false;
+  nNumDrivers = SDL_GetNumVideoDrivers();
+  for (nDriverInd=0;nDriverInd<nNumDrivers;nDriverInd++) {
+    pDriverName = SDL_GetVideoDriver(nDriverInd);
+    GSLC_DEBUG_PRINT("DBG: Video driver #%d: [%s]\n",nDriverInd,pDriverName);
+
+    bDriverOk = false;
+    #if defined(DRV_DISP_SDL1)
+    if (SDL_VideoInit(pDriverName,0) == 0) {
+      SDL_VideoQuit();
+      bDriverOk = true;
+    }
+    #elif defined(DRV_DISP_SDL2)
+    if (SDL_VideoInit(pDriverName) == 0) {
+      SDL_VideoQuit();
+      bDriverOk = true;
+    }
+    #endif
+    if (bDriverOk) {
+      GSLC_DEBUG_PRINT("DBG: - OK\n");
+    } else {
+      GSLC_DEBUG_PRINT("DBG: - Failed [%s]\n",SDL_GetError());
+    }
+
+  }
+  #endif
+
+
+
+  #if defined(DRV_DISP_SDL2)
+  // Renderer info
+  SDL_RendererInfo  sRendInfo;
+  nNumDrivers = SDL_GetNumRenderDrivers();
+  char acStr[10];
+  for (nDriverInd=0;nDriverInd<nNumDrivers;nDriverInd++) {
+    SDL_GetRenderDriverInfo(nDriverInd,&sRendInfo);
+	
+    GSLC_DEBUG_PRINT("DBG: Render driver #%d: [%s]\n",nDriverInd,sRendInfo.name);
+    sprintf(acStr,"%08X",sRendInfo.flags);
+	GSLC_DEBUG_PRINT("DBG: - Flags         = 0x%s\n", acStr);
+    GSLC_DEBUG_PRINT("DBG: -  Software     = %u\n",(sRendInfo.flags & SDL_RENDERER_SOFTWARE)?1:0);
+    GSLC_DEBUG_PRINT("DBG: -  Accelerated  = %u\n",(sRendInfo.flags & SDL_RENDERER_ACCELERATED)?1:0);
+    GSLC_DEBUG_PRINT("DBG: -  PresentVSync = %u\n",(sRendInfo.flags & SDL_RENDERER_PRESENTVSYNC)?1:0);
+  }
+
+  #endif
+}
+
+// Report some SDL debug info
+void gslc_DrvReportInfoPost()
+{
+  #if defined(DRV_DISP_SDL1)
+  // Video driver info
+  char acDriverName[40];
+  SDL_VideoDriverName(acDriverName,40);
+  GSLC_DEBUG_PRINT("DBG: Video Driver [%s]\n",acDriverName);
+
+  #elif defined(DRV_DISP_SDL2)
+  // Display Modes
+  int16_t nDispCnt,nDispInd;
+  int16_t nModeInd = 0;
+  bool    bModeOk;
+  SDL_DisplayMode sMode = { SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
+
+  nDispCnt = SDL_GetNumVideoDisplays();
+  GSLC_DEBUG_PRINT("DBG: Display count = %u\n",nDispCnt);
+  for (nDispInd=0;nDispInd<nDispCnt;nDispInd++) {
+    const char* pDispName = NULL;
+    bModeOk = (SDL_GetDisplayMode(nDispInd, nModeInd, &sMode) == 0)? true : false;
+    pDispName = SDL_GetDisplayName(nDispInd);
+    GSLC_DEBUG_PRINT("DBG: Display #%d: [%s]\n",nDispInd,pDispName);
+    GSLC_DEBUG_PRINT("DBG: - OK = %u\n",bModeOk?1:0);
+    if (bModeOk) {
+      GSLC_DEBUG_PRINT("DBG: - %d x %d, %u bpp\n",sMode.w,sMode.h,SDL_BITSPERPIXEL(sMode.format));
+    }
+  }
+  #endif
+}
+
+// -----------------------------------------------------------------------
+// Conversion Functions
+// -----------------------------------------------------------------------
+
+// Simple typecasting for abstraction layer
+SDL_Rect  gslc_DrvAdaptRect(gslc_tsRect rRect)
+{
+  SDL_Rect  rSRect;
+  rSRect.x = rRect.x;
+  rSRect.y = rRect.y;
+  rSRect.h = rRect.h;
+  rSRect.w = rRect.w;
+  return rSRect;
+}
+
+// Simple typecasting for abstraction layer
+SDL_Color  gslc_DrvAdaptColor(gslc_tsColor sCol)
+{
+  SDL_Color  sSCol;
+  sSCol.r = sCol.r;
+  sSCol.g = sCol.g;
+  sSCol.b = sCol.b;
+#if defined(DRV_DISP_SDL1)
+  sSCol.unused = 0;
+#endif
+#if defined(DRV_DISP_SDL2)
+  //???
+#endif
+  return sSCol;
+}
+
+
+// -----------------------------------------------------------------------
+// Private Drawing Functions
+// -----------------------------------------------------------------------
+
+
+#if defined(DRV_DISP_SDL1)
+uint32_t gslc_DrvAdaptColorRaw(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvAdaptColorRaw(%s) called with NULL ptr\n","");
+    return 0;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+  return SDL_MapRGB(pScreen->format,nCol.r,nCol.g,nCol.b);
+}
+
+
+// SDL1 requires direct pixel access as there is no "draw point / pixel"
+// function. SDL2 has native access for point/pixel drawing so there is
+// no need to access the pixel map directly.
+
+bool gslc_DrvScreenLock(gslc_tsGui* pGui)
+{
+
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvScreenLock(%s) called with NULL ptr\n","");
+    return false;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  // Typecast
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+
+  if (SDL_MUSTLOCK(pScreen)) {
+    if (SDL_LockSurface(pScreen) < 0) {
+      GSLC_DEBUG2_PRINT("ERROR: DrvScreenLock() can't lock screen: %s\n",SDL_GetError());
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void gslc_DrvScreenUnlock(gslc_tsGui* pGui)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvScreenUnlock(%s) called with NULL ptr\n","");
+    return;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  // Typecast
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+
+  if (SDL_MUSTLOCK(pScreen)) {
+    SDL_UnlockSurface(pScreen);
+  }
+}
+
+
+// - Based on code from:
+// -   https://www.libsdl.org/release/SDL-1.2.15/docs/html/guidevideo.html
+uint32_t gslc_DrvDrawGetPixelRaw(gslc_tsGui* pGui, int16_t nX, int16_t nY)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawGetPixelRaw(%s) called with NULL ptr\n","");
+    return 0;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+  if (pScreen == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawGetPixelRaw(%s) screen surface NULL\n","");
+    return 0;
+  }
+  int nBpp = pScreen->format->BytesPerPixel;
+
+  // Handle any range violations for entire surface
+  if ( (nX < 0) || (nX >= pScreen->w) ||
+       (nY < 0) || (nY >= pScreen->h) ) {
+    // ERROR
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawGetPixelRaw() out of range (%i,%i)\n",nX,nY);
+    return 0;
+  }
+
+  // Here pPixel is the address to the pixel we want to get
+  uint8_t *pPixel = (uint8_t *)pScreen->pixels + nY * pScreen->pitch + nX * nBpp;
+
+  switch(nBpp) {
+    case 1:
+      return *pPixel;
+
+    case 2:
+      return *(uint16_t *)pPixel;
+
+    case 3:
+      if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
+        return pPixel[0] << 16 | pPixel[1] << 8 | pPixel[2];
+      else
+        return pPixel[0] | pPixel[1] << 8 | pPixel[2] << 16;
+
+    case 4:
+      return *(uint32_t *)pPixel;
+
+    default:
+      return 0;       // shouldn't happen, but avoids warnings
+  }
+
+}
+
+
+// - Based on code from:
+// -   https://www.libsdl.org/release/SDL-1.2.15/docs/html/guidevideo.html
+// - Added range checks from surface clipping rect
+void gslc_DrvDrawSetPixelRaw(gslc_tsGui* pGui,int16_t nX, int16_t nY, uint32_t nPixelVal)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawSetPixelRaw(%s) called with NULL ptr\n","");
+    return;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  SDL_Surface*   pScreen = pDriver->pSurfScreen;
+  if (pScreen == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawSetPixelRaw(%s) screen surface NULL\n","");
+    return;
+  }
+  uint8_t nBpp = pScreen->format->BytesPerPixel;
+
+  // Handle any clipping
+  if ( (nX < pScreen->clip_rect.x) || (nX >= pScreen->clip_rect.x+pScreen->clip_rect.w) ||
+       (nY < pScreen->clip_rect.y) || (nY >= pScreen->clip_rect.y+pScreen->clip_rect.h) ) {
+    return;
+  }
+
+  // Here pPixel is the address to the pixel we want to set
+  uint8_t *pPixel = (uint8_t *)pScreen->pixels + nY * pScreen->pitch + nX * nBpp;
+
+  switch(nBpp) {
+    case 1:
+      *pPixel = nPixelVal;
+      break;
+
+    case 2:
+      *(uint16_t *)pPixel = nPixelVal;
+      break;
+
+    case 3:
+      if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
+        pPixel[0] = (nPixelVal >> 16) & 0xff;
+        pPixel[1] = (nPixelVal >> 8) & 0xff;
+        pPixel[2] = nPixelVal & 0xff;
+      } else {
+        pPixel[0] = nPixelVal & 0xff;
+        pPixel[1] = (nPixelVal >> 8) & 0xff;
+        pPixel[2] = (nPixelVal >> 16) & 0xff;
+      }
+      break;
+
+    case 4:
+      *(uint32_t *)pPixel = nPixelVal;
+      break;
+  }
+
+}
+
+void gslc_DrvPasteSurface(gslc_tsGui* pGui,int16_t nX, int16_t nY, void* pvSrc, void* pvDest)
+{
+  if ((pGui == NULL) || (pvSrc == NULL) || (pvDest == NULL)) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvPasteSurface(%s) called with NULL ptr\n","");
+    return;
+  }
+  SDL_Surface*  pSrc  = (SDL_Surface*)(pvSrc);
+  SDL_Surface*  pDest = (SDL_Surface*)(pvDest);
+  SDL_Rect offset;
+  offset.x = nX;
+  offset.y = nY;
+  SDL_BlitSurface(pSrc,NULL,pDest,&offset);
+}
+
+#endif
+
+
+
+// ------------------------------------------------------------------------
+// Touch Functions (via external tslib)
+// ------------------------------------------------------------------------
+
+#if defined(DRV_TOUCH_TSLIB)
+
+// POST:
+// - pDriver->pTsDev mapped to touchscreen device
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+
+  // Perform any driver-specific touchscreen init here
+
+  // Assign default
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  pDriver->pTsDev = NULL;
+
+  // TODO: Consider using env "TSLIB_TSDEVICE" instead
+  //char* pDevName = NULL;
+  //pDevName = getenv("TSLIB_TSDEVICE");
+  //pDriver->pTsDev = ts_open(pDevName,1);
+
+  // Open in non-blocking mode
+  pDriver->pTsDev = ts_open(acDev,1);
+  if (!pDriver->pTsDev) {
+    GSLC_DEBUG2_PRINT("ERROR: TsOpen(%s) failed\n","");
+    return false;
+  }
+
+  if (ts_config(pDriver->pTsDev)) {
+    GSLC_DEBUG2_PRINT("ERROR: ts_config(%s) failed\n","");
+    // Clear the tslib pointer so we don't try to call it again
+    pDriver->pTsDev = NULL;
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: TDrvGetTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  // In case tslib was not loaded, exit now
+  if (pDriver->pTsDev == NULL) {
+    return false;
+  }
+  struct ts_sample   pSamp;
+  int32_t nRet = ts_read(pDriver->pTsDev,&pSamp,1);
+  // ts_read returns the number of samples actually fetched
+  // Since we are only requesting at most 1 sample, the return
+  // value should either be 0 (no samples) or 1 (sample success)
+
+  if (nRet > 0) {
+    // Sample successfully fetched
+    (*pnX)          = pSamp.x;
+    (*pnY)          = pSamp.y;
+    (*pnPress)      = pSamp.pressure;
+    (*peInputEvent) = GSLC_INPUT_TOUCH;
+    (*pnInputVal)   = 0;
+    return true;
+  } else {
+    // No sample returned
+    return false;
+  }
+}
+
+#endif // DRV_TOUCH_TSLIB
+
+#endif // Compiler guard for requested driver
diff --git a/src/guislice/GUIslice_drv_sdl.h b/src/guislice/GUIslice_drv_sdl.h
new file mode 100644
index 0000000..576143a
--- /dev/null
+++ b/src/guislice/GUIslice_drv_sdl.h
@@ -0,0 +1,722 @@
+#ifndef _GUISLICE_DRV_SDL_H_
+#define _GUISLICE_DRV_SDL_H_
+
+// =======================================================================
+// GUIslice library (driver layer for SDL 1.2 & 2.0)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_sdl.h
+/// \brief GUIslice library (driver layer for LINUX / SDL)
+
+
+// =======================================================================
+// Driver Layer for SDL
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+#if defined(DRV_DISP_SDL1)
+  #include <SDL/SDL.h>
+  #include <SDL/SDL_getenv.h>
+  #include <SDL/SDL_ttf.h>
+#endif
+#if defined(DRV_DISP_SDL2)
+  #include <SDL2/SDL.h>
+  #include <SDL2/SDL_ttf.h>
+#endif
+
+// Includes for optional tslib touch handling
+#if defined(DRV_TOUCH_TSLIB)
+  #include "tslib.h"
+#endif
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT          1 ///< Support gslc_DrvDrawPoint()
+
+#if defined(DRV_DISP_SDL1)
+  #define DRV_HAS_DRAW_POINTS            1 ///< Support gslc_DrvDrawPoints()
+  #define DRV_HAS_DRAW_LINE              0 ///< Support gslc_DrvDrawLine()
+  #define DRV_HAS_DRAW_RECT_FRAME        0 ///< Support gslc_DrvDrawFrameRect()
+  #define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0 ///< Support gslc_DrvDrawFrameRoundRect()
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0 ///< Support gslc_DrvDrawFillRoundRect()
+  #define DRV_HAS_DRAW_CIRCLE_FRAME      0 ///< Support gslc_DrvDrawFrameCircle()
+  #define DRV_HAS_DRAW_CIRCLE_FILL       0 ///< Support gslc_DrvDrawFillCircle()
+  #define DRV_HAS_DRAW_TRI_FRAME         0 ///< Support gslc_DrvDrawFrameTriangle()
+  #define DRV_HAS_DRAW_TRI_FILL          0 ///< Support gslc_DrvDrawFillTriangle()
+  #define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+  #define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+#endif
+
+#if defined(DRV_DISP_SDL2)
+  #define DRV_HAS_DRAW_POINTS            1 ///< Support gslc_DrvDrawPoints()
+  #define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+  #define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+  #define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+  #define DRV_HAS_DRAW_RECT_ROUND_FRAME  0 ///< Support gslc_DrvDrawFrameRoundRect()
+  #define DRV_HAS_DRAW_RECT_ROUND_FILL   0 ///< Support gslc_DrvDrawFillRoundRect()
+  #define DRV_HAS_DRAW_CIRCLE_FRAME      0 ///< Support gslc_DrvDrawFrameCircle()
+  #define DRV_HAS_DRAW_CIRCLE_FILL       0 ///< Support gslc_DrvDrawFillCircle()
+  #define DRV_HAS_DRAW_TRI_FRAME         0 ///< Support gslc_DrvDrawFrameTriangle()
+  #define DRV_HAS_DRAW_TRI_FILL          0 ///< Support gslc_DrvDrawFillTriangle()
+  #define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+  #define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+#endif
+
+#define DRV_OVERRIDE_TXT_ALIGN      0 ///< Driver provides text alignment
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+
+  #if defined(DRV_DISP_SDL1)
+  SDL_Surface*        pSurfScreen;      ///< Surface ptr for screen
+  #endif
+
+  #if defined(DRV_DISP_SDL2)
+  SDL_Window*         pWind;            ///< SDL2 Window
+  SDL_Renderer*       pRender;          ///< SDL2 Rendering engine
+  #endif
+
+  #if defined(DRV_TOUCH_TSLIB)
+  struct tsdev*       pTsDev;           ///< Ptr to touchscreen device
+  #endif
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit().
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(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_DrvGetDriverDisp(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_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture/path) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// 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_DrvSetBkgndImage(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_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type (GSLC_FONTREF_FNAME for SDL)
+/// \param[in]  pvFontRef:      Font reference pointer (Pointer to the font filename)
+/// \param[in]  nFontSz:        Typeface size to use
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in SDL, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,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 true if success, false if error
+///
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol);
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+// TODO: Add DrvDrawFrameCircle()
+// TODO: Add DrvDrawFillCircle()
+// TODO: Add DrvDrawFrameTriangle()
+// TODO: Add DrvDrawFillTriangle()
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+// TODO: Add DrvDrawMonoFromMem()
+// TODO: Add DrvDrawBmp24FromMem()
+
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions
+// -----------------------------------------------------------------------
+
+///
+/// Get the last touch event from the SDL_Event handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Private Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Ensure SDL initializes cleanly to workaround
+/// possible issues if previous SDL application
+/// failed to close down gracefully.
+///
+/// \param[in]  sTTY:       Terminal device (eg. "/dev/tty0")
+///
+/// \return true if success
+///
+bool gslc_DrvCleanStart(const char* sTTY);
+
+
+///
+/// Report driver debug info (before initialization)
+///
+/// \return none
+///
+void gslc_DrvReportInfoPre();
+
+///
+/// Report driver debug info (after initialization)
+///
+/// \return none
+///
+void gslc_DrvReportInfoPost();
+
+// -----------------------------------------------------------------------
+// Private Conversion Functions
+// -----------------------------------------------------------------------
+
+///
+/// Translate a gslc_tsRect into an SDL_Rect
+///
+/// \param[in]  rRect:    gslc_tsRect
+///
+/// \return Converted SDL_Rect
+///
+SDL_Rect  gslc_DrvAdaptRect(gslc_tsRect rRect);
+
+///
+/// Translate a gslc_tsColor into an SDL_Color
+///
+/// \param[in]  sCol:    gslc_tsColor
+///
+/// \return Converted SDL_Color
+///
+SDL_Color  gslc_DrvAdaptColor(gslc_tsColor sCol);
+
+
+// -----------------------------------------------------------------------
+// Private Drawing Functions
+// -----------------------------------------------------------------------
+
+#if defined(DRV_DISP_SDL1)
+///
+/// Lock an SDL surface so that direct pixel manipulation
+/// can be done safely. This function is called before any
+/// direct pixel updates.
+///
+/// POST:
+/// - Primary screen surface is locked
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false otherwise
+///
+bool gslc_DrvScreenLock(gslc_tsGui* pGui);
+
+
+///
+/// Unlock the SDL surface after pixel manipulation is
+/// complete. This function is called after all pixel updates
+/// are done.
+///
+/// POST:
+/// - Primary screen surface is unlocked
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvScreenUnlock(gslc_tsGui* pGui);
+
+
+///
+/// Convert an RGB color triplet into the surface pixel value.
+/// This is called to produce the native pixel value required by
+/// the raw pixel manipulation routines.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nCol:        RGB value for conversion
+///
+/// \return A pixel value for the current screen format
+///
+uint32_t gslc_DrvAdaptColorRaw(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+
+///
+/// Get the pixel at (X,Y) from the active screen
+///
+/// PRE:
+/// - Screen surface must be locked
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          Pixel X coordinate
+/// \param[in]  nY:          Pixel Y coordinate
+///
+/// \return Pixel color value from the coordinate or 0 if error
+///
+uint32_t gslc_DrvDrawGetPixelRaw(gslc_tsGui* pGui,int16_t nX,int16_t nY);
+
+
+///
+/// Set a pixel on the active screen to the given color
+///
+/// PRE:
+/// - Screen surface must be locked
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          Pixel X coordinate to set
+/// \param[in]  nY:          Pixel Y coordinate to set
+/// \param[in]  nPixelCol:   Raw color pixel value to assign
+///
+/// \return none
+///
+void gslc_DrvDrawSetPixelRaw(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint32_t nPixelCol);
+
+///
+/// Copy one image region to another.
+/// - This is typically used to copy an image to the main screen surface
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  nX:            Destination X coordinate of copy
+/// \param[in]  nY:            Destination Y coordinate of copy
+/// \param[in]  pvSrc:         Void Ptr to source surface (eg. a loaded image)
+/// \param[in]  pvDest:        Void Ptr to destination surface (typically the screen)
+///
+/// \return none
+///
+void gslc_DrvPasteSurface(gslc_tsGui* pGui,int16_t nX, int16_t nY, void* pvSrc, void* pvDest);
+
+#endif // DRV_DISP_SDL1
+
+
+
+// -----------------------------------------------------------------------
+// Private Touchscreen Functions (if using SDL)
+// -----------------------------------------------------------------------
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+// -----------------------------------------------------------------------
+// Touchscreen Functions (if using tslib)
+// -----------------------------------------------------------------------
+
+#if defined(DRV_TOUCH_TSLIB)
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the tslib handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, >0 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return non-zero if an event was detected or 0 otherwise
+///
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_TSLIB
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_SDL_H_
diff --git a/src/guislice/GUIslice_drv_tft_espi.cpp b/src/guislice/GUIslice_drv_tft_espi.cpp
new file mode 100644
index 0000000..4e75a03
--- /dev/null
+++ b/src/guislice/GUIslice_drv_tft_espi.cpp
@@ -0,0 +1,2188 @@
+// =======================================================================
+// GUIslice library (driver layer for bodmer/TFT_eSPI)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_tft_espi.cpp
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_TFT_ESPI)
+
+// =======================================================================
+// Driver Layer for bodmer/TFT_eSPI
+// - https://github.com/Bodmer/TFT_eSPI
+// =======================================================================
+
+// GUIslice library
+#include "GUIslice_drv_tft_espi.h"
+
+#include <stdio.h>
+
+#include <TFT_eSPI.h>
+
+// Optional SPIFFS support
+#if (GSLC_SPIFFS_EN)
+  // https://github.com/Bodmer/TFT_eFEX
+  #include <TFT_eFEX.h> // Include the extension graphics functions library
+#endif
+
+#include <SPI.h>
+
+
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #include <SPI.h>
+  #include <Wire.h>
+  #include "Adafruit_STMPE610.h"
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  #include <Wire.h>
+  #include "Adafruit_FT6206.h"
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  #include <stdint.h>
+  #include <TouchScreen.h>
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  // NOTE: This file is located in the Arduino_STM32 library:
+  //       Arduino_STM32/STM32F1/libraries/Serasidis_XPT2046_touch/src/XPT2046_touch.h
+  #include <XPT2046_touch.h>
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  #include <XPT2046_Touchscreen.h>
+#elif defined(DRV_TOUCH_HANDLER)
+  #include <GUIslice_th.h>
+#endif
+
+// ------------------------------------------------------------------------
+// Load storage drivers
+// - Support SD card interface
+// ------------------------------------------------------------------------
+#if (GSLC_SD_EN)
+  #if (GSLC_SD_EN == 1)
+    // Use built-in SD library
+    // - Only supports HW SPI
+    #include <FS.h>
+    #include <SD.h>
+  #elif (GSLC_SD_EN == 2)
+    // Use greiman/SdFat library
+    // TODO
+    #error "GSLC_SD_EN=2 not yet implemented in TFT_eSPI mode"
+  #endif
+#endif
+ 
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+  // Define display driver naming
+  const char* m_acDrvDisp = "TFT_eSPI";
+
+// ------------------------------------------------------------------------
+// Use default pin settings as defined in TFT_eSPI/User_Setup.h
+TFT_eSPI m_disp = TFT_eSPI();
+#if (GSLC_SPIFFS_EN)
+  // Create TFT_eFEX object "fex" with pointer to "m_disp" object
+  TFT_eFEX fex = TFT_eFEX(&m_disp);
+#endif
+
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #if (ADATOUCH_I2C_HW) // Use I2C
+    const char* m_acDrvTouch = "STMPE610(I2C-HW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610();
+  #elif (ADATOUCH_SPI_HW) // Use hardware SPI
+    const char* m_acDrvTouch = "STMPE610(SPI-HW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610(ADATOUCH_PIN_CS);
+  #elif (ADATOUCH_SPI_SW) // Use software SPI
+    const char* m_acDrvTouch = "STMPE610(SPI-SW)";
+    Adafruit_STMPE610 m_touch = Adafruit_STMPE610(ADATOUCH_PIN_CS, ADATOUCH_PIN_SDI, ADATOUCH_PIN_SDO, ADATOUCH_PIN_SCK);
+  #else // No interface flag set
+    #error "DRV_TOUCH_ADA_STMPE610 but no ADATOUCH_I2C_* or ADATOUCH_SPI_* set in config"
+  #endif
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  const char* m_acDrvTouch = "FT6206(I2C)";
+  // Always use I2C
+  Adafruit_FT6206 m_touch = Adafruit_FT6206();
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  const char* m_acDrvTouch = "SIMPLE(Analog)";
+  TouchScreen m_touch = TouchScreen(ADATOUCH_PIN_XP, ADATOUCH_PIN_YP, ADATOUCH_PIN_XM, ADATOUCH_PIN_YM, ADATOUCH_RX);
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  const char* m_acDrvTouch = "XPT2046_STM(SPI-HW)";
+  // Create an SPI class for XPT2046 access
+  XPT2046_DEFINE_DPICLASS;
+  // XPT2046 driver from Arduino_STM32 by Serasidis (<XPT2046_touch.h>)
+  XPT2046_touch m_touch(XPT2046_CS, XPT2046_spi); // Chip Select pin, SPI instance
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  const char* m_acDrvTouch = "XPT2046_PS(SPI-HW)";
+  // Use SPI, no IRQs
+  XPT2046_Touchscreen m_touch(XPT2046_CS); // Chip Select pin
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_TFT_ESPI)
+  const char* m_acDrvTouch = "TFT_eSPI(XPT2046)";
+  // Define the XPT2046 calibration data
+  uint16_t m_anCalData[5] = TFT_ESPI_TOUCH_CALIB;
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_HANDLER)
+  const char* m_acDrvTouch = "Handler";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_INPUT)
+  const char* m_acDrvTouch = "INPUT";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_NONE)
+  const char* m_acDrvTouch = "NONE";
+// ------------------------------------------------------------------------
+#endif // DRV_TOUCH_*
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+
+  // Report any debug info if enabled
+  #if defined(DBG_DRIVER)
+  // TODO
+  #endif
+
+  // Initialize any library-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    pDriver->nColBkgnd = GSLC_COL_BLACK;
+
+    // These displays can accept partial redraw as they retain the last
+    // image in the controller graphics RAM
+    pGui->bRedrawPartialEn = true;
+
+    m_disp.init();
+
+    // Now that we have initialized the display, we can assign
+    // the rotation parameters and clipping region
+    gslc_DrvRotate(pGui,GSLC_ROTATE);
+
+    // Initialize SD card usage
+    #if (GSLC_SD_EN)
+      #if (!defined(ADAGFX_PIN_SDCS))
+        #error "ERROR: ADAGFX_PIN_SDCS must be defined in config for SD support"
+      #endif
+      if (!SD.begin(ADAGFX_PIN_SDCS)) {
+        GSLC_DEBUG_PRINT("ERROR: DrvInit() SD init failed\n", 0);
+        return false;
+      }
+    #endif
+
+    #if (GSLC_SPIFFS_EN)
+      // Initialize SPIFFS file system
+      if (!SPIFFS.begin()) {
+        GSLC_DEBUG_PRINT("ERROR: DrvInit() SPIFFS init failed\n", 0);
+      }
+    #endif    
+  }
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (void*)(&m_disp);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // GUIslice adapter for Adafruit-GFX doesn't preload the
+  // images into RAM (to keep RAM requirements low), so we
+  // don't need to do any further processing here. Instead,
+  // the loading is done during render.
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    return NULL;  // No image preload done
+  }
+
+  // Default
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->nColBkgnd = nCol;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefNorm = sImgRef;
+  return true; // TODO
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefGlow = sImgRef;
+  return true; // TODO
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // NOTE: The clipping rect is currently saved in the
+  // driver struct, but the drawing code does not currently
+  // use it.
+  gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pRect == NULL) {
+    // Default to entire display
+    pDriver->rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  } else {
+    pDriver->rClipRect = *pRect;
+  }
+
+  // TODO: For ILI9341, perhaps we can leverage m_disp.setAddrWindow(x0, y0, x1, y1)?
+  return true;
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz)
+{
+  if (eFontRefType == GSLC_FONTREF_PTR  || eFontRefType  == GSLC_FONTREF_FNAME) {
+    // Return pointer to Adafruit-GFX GFXfont structure
+    return pvFontRef;
+  }
+  else {
+    // Arduino mode currently only supports font definitions from memory
+    GSLC_DEBUG2_PRINT("ERROR: DrvFontAdd(%s) failed - Arduino only supports memory-based fonts and fonts stored in SPIFFS\n","");
+    return NULL;
+  }
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  // Nothing to deallocate
+}
+
+
+// NOTE: Please see the comments associated with gslc_DrvDrawTxt().
+//       In summary, DrvGetTxtSize() is not able to gather the complete
+//       text sizing information from TFT_eSPI as the APIs are not available.
+//
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  uint16_t  nTxtLen    = 0;
+  uint16_t  nTxtHeight = 0;
+  uint16_t  nTxtScale  = pFont->nSize;
+  // TFT_eSPI font API differs from Adafruit-GFX's setFont() API
+  if (pFont->pvFont == NULL) {
+    m_disp.setTextFont(1);
+  } else {
+    m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+  }
+  m_disp.setTextSize(nTxtScale);
+  nTxtLen = m_disp.textWidth((char*)pStr);
+  nTxtHeight = m_disp.fontHeight(1); // Use freefont "textfont" value
+  *pnTxtX = 0;  // Unused
+  *pnTxtY = 0;  // Unused
+  *pnTxtSzW = nTxtLen;
+  *pnTxtSzH = nTxtHeight;
+
+  return true;
+}
+
+bool gslc_DrvDrawTxtAlign(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,int8_t eTxtAlign,
+        gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  uint16_t nColBgRaw = gslc_DrvAdaptColorToRaw(colBg);
+  uint16_t nTxtScale = pFont->nSize;
+
+  #ifdef SMOOTH_FONT
+    m_disp.setTextColor(nColRaw,nColBgRaw);
+  #else
+    m_disp.setTextColor(nColRaw);
+  #endif
+
+  // TFT_eSPI font API differs from Adafruit-GFX's setFont() API
+  if (pFont->pvFont == NULL) {
+    m_disp.setTextFont(1);
+  } else {
+    #ifdef SMOOTH_FONT
+      if (pFont->eFontRefType  == GSLC_FONTREF_FNAME){
+        m_disp.loadFont((const char*)pFont->pvFont);
+      } else {
+        m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+      }
+    #else
+      m_disp.setFreeFont((const GFXfont *)pFont->pvFont);
+    #endif
+  }
+  m_disp.setTextSize(nTxtScale);
+
+  // Default to mid-mid datum
+  int8_t  nDatum = MC_DATUM;
+  int16_t nTxtX = nX0 + (nX1-nX0)/2;
+  int16_t nTxtY = nY0 + (nY1-nY0)/2;
+
+  // Override the datum depending on alignment mode
+  switch(eTxtAlign) {
+    case GSLC_ALIGN_TOP_LEFT:   nDatum = TL_DATUM; nTxtX = nX0; nTxtY = nY0; break;
+    case GSLC_ALIGN_TOP_MID:    nDatum = TC_DATUM; nTxtY = nY0; break;
+    case GSLC_ALIGN_TOP_RIGHT:  nDatum = TR_DATUM; nTxtX = nX1; nTxtY = nY0; break;
+    case GSLC_ALIGN_MID_LEFT:   nDatum = ML_DATUM; nTxtX = nX0; break;
+    case GSLC_ALIGN_MID_MID:    nDatum = MC_DATUM; break;
+    case GSLC_ALIGN_MID_RIGHT:  nDatum = MR_DATUM; nTxtX = nX1; break;
+    case GSLC_ALIGN_BOT_LEFT:   nDatum = BL_DATUM; nTxtX = nX0; nTxtY = nY1; break;
+    case GSLC_ALIGN_BOT_MID:    nDatum = BC_DATUM; nTxtY = nY1; break;
+    case GSLC_ALIGN_BOT_RIGHT:  nDatum = BR_DATUM; nTxtX = nX1; nTxtY = nY1; break;
+    default:                    nDatum = MC_DATUM; break;
+  }
+  m_disp.setTextDatum(nDatum);
+
+  m_disp.drawString(pStr,nTxtX,nTxtY);
+
+  #ifdef SMOOTH_FONT
+    if (pFont->eFontRefType  == GSLC_FONTREF_FNAME){
+      m_disp.unloadFont();
+    }
+  #endif
+
+  // For now, always return true
+  return true;
+}
+
+// NOTE: As TFT_eSPI performs some complex logic in determining the font
+//       baseline and associated adjustments and these are not provided
+//       via an API, calling DrvGetTxtSize() is insufficient to determine
+//       the appropriate position corrections required (eg. when centering
+//       text). Therefore, DrvDrawTxt() will not result in proper text
+//       alignment in all cases. Instead, it is recommended that
+//       DrvDrawTxtAlign() is used instead, which will depend on the datum
+//       adjustment code within TFT_eSPI. This mode of operation is
+//       selected by default in GUIslice_drv_tft_espi.h by setting
+//       DRV_OVERRIDE_TXT_ALIGN to 1.
+
+// This method is not recommended for use with TFT_eSPI. DrvDrawTxtAlign()
+// should be used instead.
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  uint16_t nTxtScale = pFont->nSize;
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  uint16_t nColBgRaw = gslc_DrvAdaptColorToRaw(colBg);
+  #ifdef SMOOTH_FONT
+      if (pFont->eFontRefType  == GSLC_FONTREF_FNAME){
+        m_disp.loadFont((const char*)pFont->pvFont);
+        m_disp.setTextColor(nColRaw,nColBgRaw);
+      } else {
+        m_disp.setTextColor(nColRaw);
+      }
+  #else
+  m_disp.setTextColor(nColRaw);
+  #endif
+  // m_disp.setCursor(nTxtX,nTxtY);
+  m_disp.setTextSize(nTxtScale);
+
+  // Default to top-left datum
+  m_disp.setTextDatum(TL_DATUM);
+
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_RAM) {
+    // String in SRAM; can access buffer directly
+    // m_disp.println(pStr);
+    m_disp.drawString(pStr,nTxtX,nTxtY);
+  } else if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    // String in PROGMEM (flash); must access via pgm_* calls
+    char    ch;
+    int     nXOffset = 0;
+    while ((ch = pgm_read_byte(pStr++))) {
+      // m_disp.print(ch);
+      nXOffset += m_disp.drawChar(ch,nTxtX+nXOffset,nTxtY);
+    }
+    m_disp.println();
+  }
+  #ifdef SMOOTH_FONT
+    if (pFont->eFontRefType  == GSLC_FONTREF_FNAME){
+      m_disp.unloadFont();
+    }
+  #endif
+
+  return true;
+}
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  #if defined(DRV_DISP_ADAGFX_ILI9341) || defined(DRV_DISP_ADAGFX_ILI9341_8BIT) || \
+    defined(DRV_DISP_ADAGFX_ILI9341_STM) || defined(DRV_DISP_ADAGFX_ST7735) || \
+    defined(DRV_DISP_ADAGFX_HX8347) || defined(DRV_DISP_ADAGFX_HX8357)
+    // Nothing to do as we're not double-buffered
+
+  #elif defined(DRV_DISP_ADAGFX_SSD1306)
+    // Show the display buffer on the hardware.
+    // NOTE: You _must_ call display after making any drawing commands
+    // to make them visible on the display hardware!
+    m_disp.display();
+
+    // TODO: Might need to call m_disp.clearDisplay() now?
+
+  #endif
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+inline void gslc_DrvDrawPoint_base(int16_t nX, int16_t nY, uint16_t nColRaw)
+{
+  m_disp.drawPixel(nX,nY,nColRaw);
+}
+
+inline void gslc_DrvDrawLine_base(int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,uint16_t nColRaw)
+{
+  m_disp.drawLine(nX0,nY0,nX1,nY1,nColRaw);
+}
+
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipPt(&pDriver->rClipRect,nX,nY)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawPoint_base(nX, nY, nColRaw);
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+  return false;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipRect(&pDriver->rClipRect,&rRect)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FILL)
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  // - TODO: Optimize the following, perhaps with new ClipLineHV()
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  int16_t nX0, nY0, nX1, nY1;
+  // Top
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Bottom
+  nX0 = rRect.x;
+  nY0 = rRect.y + rRect.h - 1;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Left
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Right
+  nX0 = rRect.x + rRect.w - 1;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+#else
+  m_disp.drawRect(rRect.x,rRect.y,rRect.w,rRect.h,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  m_disp.drawRoundRect(rRect.x,rRect.y,rRect.w,rRect.h,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipLine(&pDriver->rClipRect,&nX0,&nY0,&nX1,&nY1)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawLine_base(nX0,nY0,nX1,nY1,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFrameCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FILL)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillCircle(nMidX,nMidY,nRadius,nColRaw);
+#endif
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FRAME)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.drawTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_TRI_FILL)
+
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.fillTriangle(nX0,nY0,nX1,nY1,nX2,nY2,nColRaw);
+#endif
+  return true;
+}
+
+
+
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Adafruit_GFX.cpp
+//   Original author:  Adafruit
+//   Function:         drawBitmap()
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer using the foreground color defined in the
+// header (unset bits are transparent).
+
+// GUIslice modified the raw memory format to add a header:
+// Image array format:
+// - Width[15:8],  Width[7:0],
+// - Height[15:8], Height[7:0],
+// - ColorR[7:0],  ColorG[7:0],
+// - ColorB[7:0],  0x00,
+// - Monochrome bitmap follows...
+//
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,
+ const unsigned char *pBitmap,bool bProgMem)
+ {
+  const unsigned char*  bmap_base = pBitmap;
+  int16_t         w,h;
+  gslc_tsColor    nCol;
+
+  // Read header
+  w       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  w      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  h       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  h      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  nCol.r  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.g  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.b  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  bmap_base++;
+
+  int16_t i, j, byteWidth = (w + 7) / 8;
+  uint8_t nByte = 0;
+
+  for(j=0; j<h; j++) {
+    for(i=0; i<w; i++) {
+      if(i & 7) nByte <<= 1;
+      else {
+        if (bProgMem) {
+          nByte = pgm_read_byte(bmap_base + j * byteWidth + i / 8);
+        } else {
+          nByte = bmap_base[j * byteWidth + i / 8];
+        }
+      }
+      if(nByte & 0x80) {
+        gslc_DrvDrawPoint(pGui,nDstX+i,nDstY+j,nCol);
+      }
+    }
+  }
+}
+// ----- REFERENCE CODE end
+
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem)
+{
+  const uint16_t* pImage = (const uint16_t*)pBitmap;
+  int16_t h = *(pImage++);
+  int16_t w = *(pImage++);
+  int row, col;
+  for (row=0; row<h; row++) { // For each scanline...
+    for (col=0; col<w; col++) { // For each pixel...
+      if (bProgMem) {
+        //To read from Flash Memory, pgm_read_XXX is required.
+        //Since image is stored as uint16_t, pgm_read_word is used as it uses 16bit address
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, pgm_read_word(pImage++));
+      } else {
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, *(pImage++));
+      }
+    } // end pixel
+  }
+}
+
+#if (GSLC_SD_EN)
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/spitftbitmap/spitftbitmap.ino
+//   Original author:  Adafruit
+//   Function:         bmpDraw()
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+uint16_t gslc_DrvRead16SD(fs::File &f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t gslc_DrvRead32SD(fs::File &f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+void gslc_DrvDrawBmp24FromSD(gslc_tsGui* pGui,const char *filename, uint16_t x, uint16_t y)
+{
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  uint8_t  sdbuffer[3*GSLC_SD_BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+  boolean  goodBmp = false;       // Set to true on valid header parse
+  boolean  flip    = true;        // BMP is stored bottom-to-top
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0, startTime = millis();
+  (void)startTime; // Unused
+
+  if((x >= pGui->nDispW) || (y >= pGui->nDispH)) return;
+
+  //Serial.println();
+  //Serial.print("Loading image '");
+  //Serial.print(filename);
+  //Serial.println('\'');
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(filename)) == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() file not found [%s]",filename);
+    return;
+  }
+  // Parse BMP header
+  if(gslc_DrvRead16SD(bmpFile) == 0x4D42) { // BMP signature
+    uint32_t nFileSize = gslc_DrvRead32SD(bmpFile);
+    (void)nFileSize; // Unused
+    //Serial.print("File size: "); Serial.println(nFileSize);
+    (void)gslc_DrvRead32SD(bmpFile); // Read & ignore creator bytes
+    bmpImageoffset = gslc_DrvRead32SD(bmpFile); // Start of image data
+    //Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
+    // Read DIB header
+    uint32_t nHdrSize = gslc_DrvRead32SD(bmpFile);
+    (void)nHdrSize; // Unused
+    //Serial.print("Header size: "); Serial.println(nHdrSize);
+    bmpWidth  = gslc_DrvRead32SD(bmpFile);
+    bmpHeight = gslc_DrvRead32SD(bmpFile);
+    if(gslc_DrvRead16SD(bmpFile) == 1) { // # planes -- must be '1'
+      bmpDepth = gslc_DrvRead16SD(bmpFile); // bits per pixel
+      //Serial.print("Bit Depth: "); Serial.println(bmpDepth);
+      if((bmpDepth == 24) && (gslc_DrvRead32SD(bmpFile) == 0)) { // 0 = uncompressed
+        goodBmp = true; // Supported BMP format -- proceed!
+        //Serial.print("Image size: ");
+        //Serial.print(bmpWidth);
+        //Serial.print('x');
+        //Serial.println(bmpHeight);
+
+        // BMP rows are padded (if needed) to 4-byte boundary
+        rowSize = (bmpWidth * 3 + 3) & ~3;
+
+        // If bmpHeight is negative, image is in top-down order.
+        // This is not canon but has been observed in the wild.
+        if(bmpHeight < 0) {
+          bmpHeight = -bmpHeight;
+          flip      = false;
+        }
+
+        // Crop area to be loaded
+        w = bmpWidth;
+        h = bmpHeight;
+        if((x+w-1) >= pGui->nDispW) w = pGui->nDispW  - x;
+        if((y+h-1) >= pGui->nDispH) h = pGui->nDispH - y;
+
+        // Set TFT address window to clipped image bounds
+        //xxx tft.setAddrWindow(x, y, x+w-1, y+h-1);
+
+        for (row=0; row<h; row++) { // For each scanline...
+
+          // Seek to start of scan line.  It might seem labor-
+          // intensive to be doing this on every line, but this
+          // method covers a lot of gritty details like cropping
+          // and scanline padding.  Also, the seek only takes
+          // place if the file position actually needs to change
+          // (avoids a lot of cluster math in SD library).
+          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
+            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
+          else     // Bitmap is stored top-to-bottom
+            pos = bmpImageoffset + row * rowSize;
+          if(bmpFile.position() != pos) { // Need seek?
+            bmpFile.seek(pos);
+            buffidx = sizeof(sdbuffer); // Force buffer reload
+          }
+
+          for (col=0; col<w; col++) { // For each pixel...
+            // Time to read more pixel data?
+            if (buffidx >= sizeof(sdbuffer)) { // Indeed
+              bmpFile.read(sdbuffer, sizeof(sdbuffer));
+              buffidx = 0; // Set index to beginning
+            }
+
+            // Convert pixel from BMP to TFT format, push to display
+            b = sdbuffer[buffidx++];
+            g = sdbuffer[buffidx++];
+            r = sdbuffer[buffidx++];
+            //xxx tft.pushColor(tft.Color565(r,g,b));
+            gslc_tsColor nCol = (gslc_tsColor){r,g,b};
+            bool bDrawBit = true;
+            if (GSLC_BMP_TRANS_EN) {
+              gslc_tsColor nColTrans = pGui->sTransCol;
+              if ((nCol.r == nColTrans.r) && (nCol.g == nColTrans.g) && (nCol.b == nColTrans.b)) {
+                bDrawBit = false;
+              }
+            }
+            if (bDrawBit) {
+              gslc_DrvDrawPoint(pGui,x+col,y+row,nCol);
+            }
+
+          } // end pixel
+        } // end scanline
+        //Serial.print("Loaded in ");
+        //Serial.print(millis() - startTime);
+        //Serial.println(" ms");
+      } // end goodBmp
+    }
+  }
+  bmpFile.close();
+  if(!goodBmp) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() BMP format unknown [%s]",filename);
+  }
+}
+// ----- REFERENCE CODE end
+#endif // GSLC_SD_EN
+
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  #if defined(DBG_DRIVER)
+  char addr[6];
+  GSLC_DEBUG_PRINT("DBG: DrvDrawImage() with ImgBuf address=","");
+  sprintf(addr,"%04X",(unsigned int)sImgRef.pImgBuf);
+  GSLC_DEBUG_PRINT("%s\n",addr);
+  #endif
+
+  // GUIslice adapter library for Adafruit-GFX does not pre-load
+  // image data into memory before calling DrvDrawImage(), so
+  // we to handle the loading now (when rendering).
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return true;  // Nothing to do
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    // Load image from SPIFFS
+    #if (GSLC_SPIFFS_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_JPG) {
+        // Draw Jpeg from SPIFFS file system
+        gslc_DrvDrawJpegFromFile(pGui,nDstX,nDstY,sImgRef);
+        return true;
+      } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // Draw Bitmap from SPIFFS file system
+        gslc_DrvDrawBmpFromFile(pGui,nDstX,nDstY,sImgRef);
+        return true;
+      } else {
+        return false; // TODO: not yet supported
+      }
+    #else
+      GSLC_DEBUG_PRINT("ERROR: GetImageFromFile() not supported as Config:GSLC_SPIFFS_EN=0\n", 0);
+      return false; // TODO: not yet supported
+    #endif // GSLC_SPIFFS_EN
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from SRAM
+      // - Dimensions and output color are defined in arrray header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in ram
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // TODO: Probably need to fix this to work with PROGMEM,
+    //       but check (GSLC_USE_PROGMEM) first
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from program memory
+      // - Dimensions and output color are defined in array header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in flash
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD media
+    #if (GSLC_SD_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // 24-bit Bitmap
+        gslc_DrvDrawBmp24FromSD(pGui,sImgRef.pFname,nDstX,nDstY);
+        return true;
+      } else {
+        // Unsupported format
+        return false;
+      }
+    #else
+      // SD card access not enabled
+      return false;
+    #endif
+
+  } else {
+    // Unsupported source
+    GSLC_DEBUG_PRINT("DBG: DrvDrawImage() unsupported source eImgFlags=%d\n", sImgRef.eImgFlags);
+    return false;
+  }
+}
+
+#if (GSLC_SPIFFS_EN)
+bool gslc_DrvDrawBmpFromFile(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  const char* pStrFname = sImgRef.pFname;
+
+  // Load BMP image from file system
+  fex.drawBmp(pStrFname, nDstX, nDstY);
+
+  return true;
+}
+
+bool gslc_DrvDrawJpegFromFile(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  const char* pStrFname = sImgRef.pFname;
+
+  // Load JPEG image from file system
+#if defined(ESP32)
+  // use optimized ESP32 native decoder
+  fex.drawJpgFile(SPIFFS, pStrFname, nDstX, nDstY);
+#else 
+  // use library decoder
+  fex.drawJpeg(pStrFname, nDstX, nDstY);
+#endif
+
+  return true;
+}
+#endif // GSLC_SPIFFS_EN
+
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    // Check to see if an image has been assigned to the background
+    if (pGui->sImgRefBkgnd.eImgFlags == GSLC_IMGREF_NONE) {
+      // No image assigned, so assume flat color background
+      // TODO: Create a new eImgFlags enum to signal that the
+      //       background should be a flat color instead of
+      //       an image.
+
+      // NOTE: We don't call m_disp.fillScreen() here as
+      //       that API doesn't support clipping. Since
+      //       we may be redrawing the page with a clipping
+      //       region enabled, it is important that we don't
+      //       redraw the entire screen.
+      gslc_tsRect rRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+      gslc_DrvDrawFillRect(pGui, rRect, pDriver->nColBkgnd);
+    } else {
+      // An image should be loaded
+      // TODO: For now, re-use the DrvDrawImage(). Later, consider
+      //       extending to support different background drawing
+      //       capabilities such as stretching and tiling of background
+      //       image.
+      gslc_DrvDrawImage(pGui, 0, 0, pGui->sImgRefBkgnd);
+    }
+  }
+}
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (via display driver)
+// -----------------------------------------------------------------------
+
+// Confirm that TOUCH_CS has been defined otherwise the
+// m_disp.getTouch() call won't be defined in TFT_eSPI
+#if defined(DRV_TOUCH_TFT_ESPI)
+  #if !defined(TOUCH_CS)
+    #error "To use DRV_TOUCH_TFT_ESPI, TOUCH_CS needs to be defined in TFT_eSPI User_Setup"
+  #endif
+#endif
+
+#if defined(DRV_TOUCH_IN_DISP)
+
+// Enable touch filtering from TFT_eSPI (comment to disable)
+#define DRV_TOUCH_TFT_ESPI_FILTER
+
+
+// Import touch filtering code from TFT_eSPI
+#if defined(DRV_TOUCH_TFT_ESPI_FILTER)
+  // - NOTE: We can't use TFT_eSPI's validTouch() as it is declared private
+  //   so instead we have replicated code here.
+  // ----- REFERENCE CODE begin
+  //   Reference code: https://github.com/Bodmer/TFT_eSPI/blob/master/Extensions/Touch.cpp
+  #define TFT_eSPI_RAWERR 20 // Deadband error allowed in successive position samples
+  uint8_t TFT_eSPI_validTouch(uint16_t *x, uint16_t *y, uint16_t threshold) {
+  uint16_t x_tmp, y_tmp, x_tmp2, y_tmp2;
+
+  // Wait until pressure stops increasing to debounce pressure
+  uint16_t z1 = 1;
+  uint16_t z2 = 0;
+  while (z1 > z2)
+  {
+    z2 = z1;
+    z1 = m_disp.getTouchRawZ();
+    delay(1);
+  }
+
+  //  Serial.print("Z = ");Serial.println(z1);
+
+  if (z1 <= threshold) return false;
+
+  m_disp.getTouchRaw(&x_tmp, &y_tmp);
+
+  //  Serial.print("Sample 1 x,y = "); Serial.print(x_tmp);Serial.print(",");Serial.print(y_tmp);
+  //  Serial.print(", Z = ");Serial.println(z1);
+
+  delay(1); // Small delay to the next sample
+  if (m_disp.getTouchRawZ() <= threshold) return false;
+
+  delay(2); // Small delay to the next sample
+  m_disp.getTouchRaw(&x_tmp2, &y_tmp2);
+
+  //  Serial.print("Sample 2 x,y = "); Serial.print(x_tmp2);Serial.print(",");Serial.println(y_tmp2);
+  //  Serial.print("Sample difference = ");Serial.print(abs(x_tmp - x_tmp2));Serial.print(",");Serial.println(abs(y_tmp - y_tmp2));
+
+  if (abs(x_tmp - x_tmp2) > TFT_eSPI_RAWERR) return false;
+  if (abs(y_tmp - y_tmp2) > TFT_eSPI_RAWERR) return false;
+
+  *x = x_tmp;
+  *y = y_tmp;
+
+  return true;
+  }
+  // ----- REFERENCE CODE end
+#endif // DRV_TOUCH_TFT_ESPI_FILTER
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  // As the touch driver instance is optional, we need to check for
+  // its existence before returning a pointer to it.
+  #if defined(DRV_TOUCH_INSTANCE)
+    return (void*)(&m_touch);
+  #else
+    return NULL;
+  #endif
+}
+
+
+bool gslc_DrvInitTouch(gslc_tsGui* pGui, const char* acDev) {
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n", "");
+    return false;
+  }
+
+  // Perform any driver-specific touchscreen init here
+
+  // Initialize the touch calibration data
+  #if defined(DRV_TOUCH_TFT_ESPI)
+    // NOTE: TFT_eSPI calibration unused as GUIslice calibration is used instead
+    m_disp.setTouch(m_anCalData);
+  #endif
+
+  // Load calibration settings for resistive displays from config
+  #if defined(DRV_TOUCH_TYPE_RES)
+    pGui->nTouchCalXMin = ADATOUCH_X_MIN;
+    pGui->nTouchCalXMax = ADATOUCH_X_MAX;
+    pGui->nTouchCalYMin = ADATOUCH_Y_MIN;
+    pGui->nTouchCalYMax = ADATOUCH_Y_MAX;
+  #endif // DRV_TOUCH_TYPE_RES
+
+  // Support touch controllers with swapped X & Y
+  #if defined(ADATOUCH_REMAP_YX)
+    // Capture swap setting from config file
+    pGui->bTouchRemapYX = ADATOUCH_REMAP_YX;
+  #else
+    // For backward compatibility with older config files
+    // that have not defined this config option
+    pGui->bTouchRemapYX = false;
+  #endif
+
+  // NOTE: TFT_eSPI constructor already initializes the touch
+  // driver if TOUCH_CS is defined in the TFT_eSPI library's "User_Setup.h"
+
+  // Nothing further to do with driver
+  return true;
+}
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal)
+{
+
+  if ((pGui == NULL) || (pGui->pvDriver == NULL)) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvGetTouch(%s) called with NULL ptr\n", "");
+    return false;
+  }
+
+  // Use TFT_eSPI's integrated XPT2046 touch handler
+  // - Note that the TFT_eSPI getTouch() calls are not used here because
+  //   they don't currently support dynamic rotation. Without dynamic rotation
+  //   support, the coordinate transform will not be correct after issuing a
+  //   setRotation() call to the TFT_eSPI display library.
+  // - Therefore, we will instead use the raw XPT2046 readings (from TFT_eSPI)
+  //   and let GUIslice perform the calibration and dynamic rotation.
+  // - Note that these readings will naturally be quite noisy w/o filtering.
+  // - Reference: https://github.com/Bodmer/TFT_eSPI/issues/365
+
+  // - TODO: Consider merging this logic with gslc_TDrvGetTouch() and remove
+  //         the special case for DRV_TOUCH_IN_DISP
+
+  // As some touch hardware drivers don't appear to return
+  // an indication of "touch released" with a coordinate, we
+  // must detect the release transition here and send the last
+  // known coordinate but with pressure=0. To do this, we are
+  // allocating a static variable to maintain the last touch
+  // coordinate.
+  // TODO: This code can be reworked / simplified
+  static int16_t  m_nLastRawX     = 0;
+  static int16_t  m_nLastRawY     = 0;
+  static uint16_t m_nLastRawPress = 0;
+  static bool     m_bLastTouched  = false;
+
+  bool bValid = false;  // Indicate a touch event to GUIslice core?
+
+  // Define maximum bounds for display in native orientation
+  int nDispOutMaxX,nDispOutMaxY;
+  nDispOutMaxX = pGui->nDisp0W-1;
+  nDispOutMaxY = pGui->nDisp0H-1;
+
+  uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+  uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+  // Retrieve the raw touch coordinates from the XPT2046
+
+  // Provide optional touch filtering
+  #if defined(DRV_TOUCH_TFT_ESPI_FILTER)
+    // Use touch filtering code from TFT_eSPI
+    uint8_t nSamples = 5;
+    uint8_t nSamplesValid = 0;
+    while (nSamples--) {
+      if (TFT_eSPI_validTouch(&nRawX, &nRawY, 20)) nSamplesValid++;
+    }
+    if (nSamplesValid < 1) {
+      nRawPress = 0; // Invalidate the reading
+    }
+    else {
+      // Force a value within range
+      nRawPress = ADATOUCH_PRESS_MIN + 1;
+    }
+  #else
+    // No additional touch filtering
+    // NOTE: On some displays this will lead to very noisy touch readings
+    nRawPress = m_disp.getTouchRawZ();
+    m_disp.getTouchRaw(&nRawX, &nRawY);
+  #endif // DRV_TOUCH_TFT_ESPI_FILTER
+
+  if ((nRawPress > ADATOUCH_PRESS_MIN) && (nRawPress < ADATOUCH_PRESS_MAX)) {
+
+    m_nLastRawX = nRawX;
+    m_nLastRawY = nRawY;
+    m_nLastRawPress = nRawPress;
+    m_bLastTouched = true;
+    bValid = true;
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+  }
+
+  // If an event was detected, signal it back to GUIslice
+  if (bValid) {
+
+    int nRawX,nRawY;
+    int nInputX,nInputY;
+    int nOutputX,nOutputY;
+
+    // Input assignment
+    nRawX = m_nLastRawX;
+    nRawY = m_nLastRawY;
+
+    // Handle any hardware swapping in native orientation
+    // This is done prior to any flip/swap as a result of
+    // rotation away from the native orientation.
+    // In most cases, the following is not used, but there
+    // may be touch modules that have swapped their X&Y convention.
+    if (pGui->bTouchRemapYX) {
+      nRawX = m_nLastRawY;
+      nRawY = m_nLastRawX;
+    }
+
+    nInputX = nRawX;
+    nInputY = nRawY;
+
+    // For resistive displays, perform constraint and scaling
+    #if defined(DRV_TOUCH_TYPE_RES)
+      if (pGui->bTouchRemapEn) {
+        // Perform scaling from input to output
+        // - Calibration done in native orientation (GSLC_ROTATE=0)
+        // - Input to map() is done with raw unswapped X,Y
+        // - map() and constrain() done with native dimensions and
+        //   native calibration
+        // - Swap & Flip done to output of map/constrain according
+        //   to GSLC_ROTATE
+        //
+        #if defined(DBG_TOUCH)
+          GSLC_DEBUG_PRINT("DBG: remapX: (%d,%d,%d,%d,%d)\n", nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+          GSLC_DEBUG_PRINT("DBG: remapY: (%d,%d,%d,%d,%d)\n", nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        #endif
+        nOutputX = map(nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+        nOutputY = map(nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        // Perform constraining to OUTPUT boundaries
+        // NOTE: TFT_eSPI's getTouch readings occasionally return spurious touch
+        //       events. These are often at the limit of the calibrated X/Y
+        //       space. Post constraint, this may appear as events with one
+        //       coordinate clipped to 0, for example. Bodmer provides
+        //       one additional check in that if the mapped coordinate
+        //       exceeds the positive bounds of the display (eg. 320px)
+        //       then he marks the touch event invalid. Doing this may
+        //       block some of the spurious events but not all (it would be
+        //       calibration dependent). If we do decide to add in a similar
+        //       check here, then we would want to force (bValid=false) here
+        //       and then only proceed after re-checking (bValid==true).
+        nOutputX = constrain(nOutputX, 0, nDispOutMaxX);
+        nOutputY = constrain(nOutputY, 0, nDispOutMaxY);
+      } else {
+        // No scaling from input to output
+        nOutputX = nInputX;
+        nOutputY = nInputY;
+      }
+    #else
+      // No scaling from input to output
+      nOutputX = nInputX;
+      nOutputY = nInputY;
+    #endif  // DRV_TOUCH_TYPE_RES
+  
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: PreRotate: x=%u y=%u\n", nOutputX, nOutputY);
+    GSLC_DEBUG_PRINT("DBG: RotateCfg: remap=%u nSwapXY=%u nFlipX=%u nFlipY=%u\n",
+      pGui->bTouchRemapEn,pGui->nSwapXY,pGui->nFlipX,pGui->nFlipY);
+    #endif // DBG_TOUCH
+
+    // Perform remapping due to current orientation
+    if (pGui->bTouchRemapEn) {
+      // Perform any requested swapping of input axes
+      if (pGui->nSwapXY) {
+        int16_t nOutputXTmp = nOutputX;
+        nOutputX = nOutputY;
+        nOutputY = nOutputXTmp;
+        // Perform any requested output axis flipping
+        // TODO: Collapse these cases
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxY - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxX - nOutputY;
+        }
+      } else {
+        // Perform any requested output axis flipping
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxX - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxY - nOutputY;
+        }
+      }
+    }
+
+    // Final assignment
+    *pnX          = nOutputX;
+    *pnY          = nOutputY;
+    *pnPress      = m_nLastRawPress;
+    *peInputEvent = GSLC_INPUT_TOUCH;
+    *pnInputVal   = 0;
+
+    // Print output for debug
+    #ifdef DBG_TOUCH
+    if (m_nLastRawPress > 0) {
+    GSLC_DEBUG_PRINT("DBG: Touch Press=%u Raw[%d,%d] Out[%d,%d]\n",
+        m_nLastRawPress,m_nLastRawX,m_nLastRawY,nOutputX,nOutputY);
+    }
+    #endif
+
+    // Return with indication of new value
+    return true;
+  }
+
+  // No new value
+  return false;
+}
+
+#endif // DRV_TOUCH_IN_DISP
+
+// ------------------------------------------------------------------------
+// Touch Functions (via external touch driver)
+// ------------------------------------------------------------------------
+
+
+#if defined(DRV_TOUCH_ADA_SIMPLE)
+
+  // --------------------------------------------------------------------------
+  // Enable Adafruit_TouchScreen workarounds
+  // --------------------------------------------------------------------------
+
+  // NOTE: The Adafruit_TouchScreen is not natively compatible with certain
+  //       devices (eg. ESP32) and also doesn't safeguard against pin-sharing
+  //       conflicts. For these and some other issues, the following workarounds
+  //       are optionally enabled.
+
+  // Enable workaround for ambiguity in Adafruit_TouchScreen pressure readings
+  // - See https://github.com/ImpulseAdventure/GUIslice/issues/96
+  #define FIX_4WIRE_Z // Comment out to disable
+
+  // Enable workaround for Adafruit_TouchScreen getPoint() altering
+  // the pin state and not restoring it. Without working around this,
+  // the touch handler may interfere with displays that share pins.
+  #define FIX_4WIRE_PIN_STATE // Comment out to disable
+
+  // For ESP32 devices, a workaround is required for the
+  // Adafruit_TouchScreen since it makes an assumption that
+  // the ADC resolution is 10-bit. This workaround enables the
+  // Adafruit library to operate the same was as for AVR devices.
+  #if defined(ESP32)
+    #define FIX_4WIRE_ADC_10 // Comment out to disable
+  #endif
+
+  // Enable workaround for TFT_eSPI with 8-bit parallel TFTs that share
+  // certain pins (eg. RDX, WRX) with the touch overlay. TFT_eSPI appears
+  // to force the TFT chip select low (permanently) in ESP32_PARALLEL mode
+  // which can cause unexpected TFT corruption during the analog read
+  // process. This workaround wraps the touch reads with a TFT chip-select
+  // disable.
+  // - Note that this workaround assumes that TFT_CS has been defined
+  //   in the TFT_eSPI library.
+  // - TFT_eSPI does not officially support UNO-style parallel shields
+  //   according to https://github.com/Bodmer/TFT_eSPI/issues/345
+  // - This workaround does enable successful operation with some of
+  //   these shields, but it is not guaranteed to work with all.
+  // - By default, this workaround has been disabled
+  //#define FIX_4WIRE_FORCE_CS // Comment out to disable
+
+  // --------------------------------------------------------------------------
+
+  // Disable certain workarounds for Adafruit_TouchScreen in STM32 mode
+  // as we haven't implemented the equivalent pin save/restore code yet.
+  #if defined(ARDUINO_ARCH_STM32) || defined(__STM32F1__)
+    #undef FIX_4WIRE_PIN_STATE
+    #undef FIX_4WIRE_FORCE_CS
+  #endif
+  
+  // --------------------------------------------------------------------------
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+  // NOTE: The Adafruit_TouchScreen library alters the state of several
+  //       pins during the course of reading the touch coordinates and
+  //       pressure. Unfortunately, it does not restore the prior state
+  //       which can impact other processes such as graphics drivers which
+  //       may share the same pins. The following routines are responsible
+  //       for saving and restoring the pin state and will wrap the
+  //       touch polling logic. If a future release of the Adafruit_TouchScreen
+  //       library addresses this issue, this wrapper logic can be removed.
+  //       For further reference, please refer to Issue #96.
+
+  /// Structure used to retain a port state (mode and level)
+  /// so that it can be restored later.
+  struct gslc_tsPinState
+  {
+    int     nMode;     // OUTPUT, INPUT, INPUT_PULLUP
+    bool    bIsHigh;   // Is an output and HIGH?
+  };
+
+  /// Return the current pinMode() for a pin
+  int gslc_TDrvGetPinMode(uint8_t nPin)
+  {
+    if (nPin >= NUM_DIGITAL_PINS) {
+      return (-1);
+    }
+#if defined(ESP32) || defined(ESP8266)
+    uint32_t nBit            = digitalPinToBitMask(nPin);
+    uint32_t nPort           = digitalPinToPort(nPin);
+    volatile uint32_t *nReg  = portModeRegister(nPort);
+#else
+    uint8_t nBit            = digitalPinToBitMask(nPin);
+    uint8_t nPort           = digitalPinToPort(nPin);
+    volatile uint8_t *nReg  = portModeRegister(nPort);
+#endif
+
+    // Determine if port is an output
+    if (*nReg & nBit) {
+      return (OUTPUT);
+    }
+
+    // Determine if port is an input and whether pullup is active
+#if defined(ESP32) || defined(ESP8266)
+    volatile  uint32_t *nOut = portOutputRegister(nPort);
+#else
+    volatile  uint8_t *nOut = portOutputRegister(nPort);
+#endif
+    return ((*nOut & nBit) ? INPUT_PULLUP : INPUT);
+  }
+
+  /// Fetch the current pin mode and level
+  inline void gslc_TDrvSavePinState(int nPin, gslc_tsPinState &sPinState)
+  {
+    sPinState.nMode = gslc_TDrvGetPinMode(nPin);
+    sPinState.bIsHigh = digitalRead(nPin);
+  }
+
+  /// Restore the pin mode and level
+  inline void gslc_TDrvRestorePinState(int nPin,gslc_tsPinState sPinState)
+  {
+    pinMode(nPin,sPinState.nMode);
+    if (sPinState.nMode == OUTPUT) digitalWrite(nPin,sPinState.bIsHigh);
+  }
+
+  #endif // FIX_4WIRE_PIN_STATE
+
+  // --------------------------------------------------------------------------
+
+#endif // DRV_TOUCH_ADA_SIMPLE
+
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+
+  // Capture default calibration settings for resistive displays
+  #if defined(DRV_TOUCH_TYPE_RES)
+    pGui->nTouchCalXMin = ADATOUCH_X_MIN;
+    pGui->nTouchCalXMax = ADATOUCH_X_MAX;
+    pGui->nTouchCalYMin = ADATOUCH_Y_MIN;
+    pGui->nTouchCalYMax = ADATOUCH_Y_MAX;
+  #endif // DRV_TOUCH_TYPE_RES
+
+  // Support touch controllers with swapped X & Y
+  #if defined(ADATOUCH_REMAP_YX)
+    // Capture swap setting from config file
+    pGui->bTouchRemapYX = ADATOUCH_REMAP_YX;
+  #else
+    // For backward compatibility with older config files
+    // that have not defined this config option
+    pGui->bTouchRemapYX = false;
+  #endif
+
+  #if defined(DRV_TOUCH_ADA_STMPE610)
+    #if (ADATOUCH_I2C_HW)
+    if (!m_touch.begin(ADATOUCH_I2C_ADDR)) {
+    #else
+    if (!m_touch.begin()) {
+    #endif
+      GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch() failed to init STMPE610\n",0);
+      return false;
+    } else {
+      return true;
+    }
+  #elif defined(DRV_TOUCH_ADA_FT6206)
+    if (!m_touch.begin(ADATOUCH_SENSITIVITY)) {
+      GSLC_DEBUG2_PRINT("ERROR: TDrvInitTouch() failed to init FT6206\n",0);
+      return false;
+    } else {
+      return true;
+    }
+  #elif defined(DRV_TOUCH_ADA_SIMPLE)
+    #if defined(ESP32)
+      // ESP32 defaults to 12-bit resolution whereas Adafruit_Touchscreen
+      // hardcodes a 10-bit range. Workaround for now is to change the
+      // ADC resolution to 10-bit.
+      // References:
+      // - https://github.com/adafruit/Adafruit_TouchScreen/issues/15
+      #if defined(FIX_4WIRE_ADC_10)
+        analogReadResolution(10);
+      #endif // FIX_4WIRE_ADC_10
+    #endif
+    return true;
+  #elif defined(DRV_TOUCH_XPT2046_STM)
+    m_touch.begin();
+    return true;
+  #elif defined(DRV_TOUCH_XPT2046_PS)
+    m_touch.begin();
+    // Since this XPT2046 library supports "touch rotation", and defaults
+    // to landscape orientation, rotate to traditional portrait orientation
+    // for consistency with other handlers.
+    //
+    // Unfortunately, this API (from 2018/01/04) is not available in the
+    // latest tagged release of XPT2046 in the Library Manager. Therefore,
+    // we can't use this API and instead need to hardcode the mapping
+    // during the DrvGetTouch() function.
+    //m_touch.setRotation(0);
+    return true;
+  #elif defined(DRV_TOUCH_INPUT)
+    // Nothing more to initialize for GPIO input control mode
+    return true;
+  #elif defined(DRV_TOUCH_HANDLER)
+    return true;
+  #else
+    // ERROR: Unsupported driver mode
+    GSLC_DEBUG_PRINT("ERROR: TDrvInitTouch() driver not supported yet\n",0);
+    return false;
+  #endif
+
+}
+
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+
+  #if defined(DRV_TOUCH_NONE)
+    return false;
+  #endif
+
+  // As the STMPE610 hardware driver doesn't appear to return
+  // an indication of "touch released" with a coordinate, we
+  // must detect the release transition here and send the last
+  // known coordinate but with pressure=0. To do this, we are
+  // allocating a static variable to maintain the last touch
+  // coordinate.
+  // TODO: This code can be reworked / simplified
+  static int16_t  m_nLastRawX     = 0;
+  static int16_t  m_nLastRawY     = 0;
+  static uint16_t m_nLastRawPress = 0;
+  static bool     m_bLastTouched  = false;
+
+  bool bValid = false;  // Indicate a touch event to GUIslice core?
+
+  // Define maximum bounds for display in native orientation
+  int nDispOutMaxX,nDispOutMaxY;
+  nDispOutMaxX = pGui->nDisp0W-1;
+  nDispOutMaxY = pGui->nDisp0H-1;
+
+  // ----------------------------------------------------------------
+  #if defined(DRV_TOUCH_ADA_STMPE610)
+
+  uint16_t  nRawX,nRawY;
+  uint8_t   nRawPress;
+
+  if (m_touch.touched()) {
+
+    if (m_touch.bufferEmpty()) {
+      // Nothing to do
+    } else {
+      while (!m_touch.bufferEmpty()) {
+        // Continued press; update next reading
+        // TODO: Is there a risk that the touch hardware could
+        //       maintain a non-empty state for an extended period of time?
+        m_touch.readData(&nRawX,&nRawY,&nRawPress);
+        m_nLastRawX = nRawX;
+        m_nLastRawY = nRawY;
+        m_nLastRawPress = nRawPress;
+        m_bLastTouched = true;
+        bValid = true;
+      }
+
+    }
+    // Clear interrupts
+    m_touch.writeRegister8(STMPE_INT_STA, 0xFF);
+
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+    // Flush the FIFO
+    while (!m_touch.bufferEmpty()) {
+      m_touch.readData(&nRawX,&nRawY,&nRawPress);
+    }
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_FT6206)
+
+  if (m_touch.touched()) {
+    TS_Point ptTouch = m_touch.getPoint();
+    // FT6206 coordinates appear to have flipped both axes vs other controllers
+    // - Confirmed by comments in Adafruit_FT6206 library example code:
+    //   "rotate coordinate system. flip it around to match the screen."
+    m_nLastRawX = nDispOutMaxX-ptTouch.x;
+    m_nLastRawY = nDispOutMaxY-ptTouch.y;
+    m_nLastRawPress = 255;  // Select arbitrary non-zero value
+    m_bLastTouched = true;
+    bValid = true;
+
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+      // Touch release
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+    }
+  }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_ADA_SIMPLE)
+
+  uint16_t  nRawX,nRawY;
+  int16_t   nRawPress;
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+    // Saved pin state
+    gslc_tsPinState   sPinStateXP, sPinStateXM, sPinStateYP, sPinStateYM;
+
+    // As Adafruit_TouchScreen polling will alter the pin state and some
+    // of these pins may be shared with the display, we need to save and
+    // then later restore the pin state.
+    gslc_TDrvSavePinState(ADATOUCH_PIN_XP, sPinStateXP);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_XM, sPinStateXM);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_YP, sPinStateYP);
+    gslc_TDrvSavePinState(ADATOUCH_PIN_YM, sPinStateYM);
+
+    #if defined(FIX_4WIRE_FORCE_CS)
+      // Preserve the TFT chip select and deassert it during touchscreen reads
+      gslc_tsPinState sPinStateCS;
+      gslc_TDrvSavePinState(TFT_CS, sPinStateCS);
+      digitalWrite(TFT_CS, HIGH);
+    #endif // FIX_4WIRE_FORCE_CS
+
+  #endif // FIX_4WIRE_PIN_STATE
+  
+  // Perform the polling of touch coordinate & pressure
+  TSPoint p = m_touch.getPoint();
+
+  // Select reasonable touch pressure threshold range.
+  // Note that the Adafruit_TouchScreen library appears to
+  // return the following:
+  // - 0:     If no touch (results from integer overflow, div/0)
+  // - 0:     If touch active but filtered due to noise
+  // - small: If touch active and hard
+  // - large: If touch active and soft
+  // Note that the "pressure" (z) value is inverted in interpretation
+  if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+    nRawX = p.x;
+    nRawY = p.y;
+    nRawPress = p.z;
+    m_nLastRawX = nRawX;
+    m_nLastRawY = nRawY;
+    m_nLastRawPress = nRawPress;
+    m_bLastTouched = true;
+    bValid = true;
+  } else {
+    if (!m_bLastTouched) {
+      // Wasn't touched before; do nothing
+    } else {
+
+      #if !defined(FIX_4WIRE_Z) // Original behavior without touch pressure workaround
+
+      // Indicate old coordinate but with pressure=0
+      m_nLastRawPress = 0;
+      m_bLastTouched = false;
+      bValid = true;
+      #ifdef DBG_TOUCH
+      GSLC_DEBUG_PRINT("DBG: Touch End  =%u Raw[%d,%d] *****\n",
+          m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+      #endif
+
+      #else // Apply touch pressure workaround
+
+      // Unfortunately, the Adafruit_TouchScreen has a few issues that
+      // make it hard to deal with reliably. The most difficult problem
+      // involves the ambiguous return state from getTouch().
+      // Without handling this in a special way, we might see spurious
+      // touch-release events.
+      //
+      // Upon entering this clause, we can infer Adafruit_TouchScreen returned z=0
+      // - This either means:
+      //   a) Touch was released (z is 0 due to integer overflow, div/0)
+      //   b) Touch still active but filtered due to noisy read
+      //
+      // Because of case (b) returning the same signature as case (a), we
+      // need to take an additional step to differentiate the two cases
+      // otherwise we might interpret spurious "touch release" events.
+      //
+      // In order to differentiate these cases, we can call the Adafruit
+      // getPressure() API since it does not include the filtering for (b).
+      // Therefore, if we see that the pressure is non-zero, and less than
+      // the max pressure threshold, we can re-interpret our original reading
+      // as (b), wherein we would still want to treat as a touch pressed event.
+
+      // Read the touch pressure
+      // Note that we will need to restore the pin status later
+      // once we are done with our polling.
+      uint16_t nPressCur = m_touch.pressure();
+
+      if ((nPressCur > ADATOUCH_PRESS_MIN) && (nPressCur < ADATOUCH_PRESS_MAX)) {
+        // The unfiltered result is that the display is still pressed
+        // Therefore we are likely in case (b) and should return our
+        // last saved result (with touch pressure still active)
+        bValid = true;
+        #ifdef DBG_TOUCH
+        // Give indication that workaround applied: continue press
+        GSLC_DEBUG_PRINT("DBG: Touch Cont =%u Raw[%d,%d]\n",
+            m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+        #endif
+      } else {
+        // The unfiltered result is that the display is not pressed
+        // Therefore we are likely in case (a) and should force
+        // the touch pressure to be deactivated
+
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+        #ifdef DBG_TOUCH
+        GSLC_DEBUG_PRINT("DBG: Touch End  =%u Raw[%d,%d] *****\n",
+            m_nLastRawPress,m_nLastRawX,m_nLastRawY);
+        #endif
+      } // nPressCur
+      #endif // FIX_4WIRE_Z
+
+      // TODO: Implement touch debouncing
+
+    } // m_bLastTouched
+  }
+
+  #if defined(FIX_4WIRE_PIN_STATE)
+    // Now that we have completed our polling into Adafruit_TouchScreen,
+    // we need to restore the original pin state.
+    gslc_TDrvRestorePinState(ADATOUCH_PIN_XP, sPinStateXP);
+    gslc_TDrvRestorePinState(ADATOUCH_PIN_XM, sPinStateXM);
+    gslc_TDrvRestorePinState(ADATOUCH_PIN_YP, sPinStateYP);
+    gslc_TDrvRestorePinState(ADATOUCH_PIN_YM, sPinStateYM);
+
+    #if defined(FIX_4WIRE_FORCE_CS)
+      // Restore TFT chip select
+      gslc_TDrvRestorePinState(TFT_CS, sPinStateCS);
+    #endif // FIX_4WIRE_FORCE_CS
+
+  #endif // FIX_4WIRE_PIN_STATE
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_XPT2046_STM)
+    // NOTE: XPT2046_STM returns pressure (z) values with a reversed
+    //       convention versus other touch libraries (ie. a small
+    //       non-zero z value means light touch, whereas a large
+    //       value means a hard / wide touch).
+
+    uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+    uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+    TS_Point p = m_touch.getPoint();
+
+    if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+      nRawX = p.x;
+      nRawY = p.y;
+      nRawPress = p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_XPT2046_PS)
+    uint16_t  nRawX,nRawY; //XPT2046 returns values up to 4095
+    uint16_t  nRawPress;   //XPT2046 returns values up to 4095
+
+    TS_Point p = m_touch.getPoint();
+
+    if ((p.z > ADATOUCH_PRESS_MIN) && (p.z < ADATOUCH_PRESS_MAX)) {
+      // PaulStoffregen/XPT2046 appears to use a different orientation
+      // than other libraries. Therefore, we will remap it here
+      // to match the default portrait orientation.
+      nRawX = 4095-p.y;
+      nRawY = p.x;
+
+      nRawPress = p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_HANDLER)
+
+    uint16_t  nRawX,nRawY;
+    uint16_t  nRawPress; 
+  
+    TouchHandler *pTH = gslc_getTouchHandler();
+    THPoint p(0,0,0);
+    //if no TouchHandler was defined use (0,0,0)
+    if (pTH!=NULL)
+        p = pTH->getPoint();
+    
+    if (p.z > 0) {
+      nRawX=p.x;
+      nRawY=p.y;
+      nRawPress=p.z;
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+      //Serial.print("pTH= ");Serial.print(p.x);Serial.print(" ");Serial.print(p.y);Serial.print(" ");Serial.println(p.z);
+    }
+    else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      } else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_INPUT)
+    // No more to do for GPIO-only mode since gslc_Update() already
+    // looks for GPIO inputs before calling TDrvGetTouch().
+    // bValid will default to false
+
+  // ----------------------------------------------------------------
+  #endif // DRV_TOUCH_*
+
+
+  // If an event was detected, signal it back to GUIslice
+  if (bValid) {
+
+    int nRawX,nRawY;
+    int nInputX,nInputY;
+    int nOutputX,nOutputY;
+
+    // Input assignment
+    nRawX = m_nLastRawX;
+    nRawY = m_nLastRawY;
+
+    // Handle any hardware swapping in native orientation
+    // This is done prior to any flip/swap as a result of
+    // rotation away from the native orientation.
+    // In most cases, the following is not used, but there
+    // may be touch modules that have swapped their X&Y convention.
+    if (pGui->bTouchRemapYX) {
+      nRawX = m_nLastRawY;
+      nRawY = m_nLastRawX;
+    }
+
+    nInputX = nRawX;
+    nInputY = nRawY;
+
+    // For resistive displays, perform constraint and scaling
+    #if defined(DRV_TOUCH_TYPE_RES)
+      if (pGui->bTouchRemapEn) {
+        // Perform scaling from input to output
+        // - Calibration done in native orientation (GSLC_ROTATE=0)
+        // - Input to map() is done with raw unswapped X,Y
+        // - map() and constrain() done with native dimensions and
+        //   native calibration
+        // - Swap & Flip done to output of map/constrain according
+        //   to GSLC_ROTATE
+        //
+        #if defined(DBG_TOUCH)
+          GSLC_DEBUG_PRINT("DBG: remapX: (%d,%d,%d,%d,%d)\n", nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+          GSLC_DEBUG_PRINT("DBG: remapY: (%d,%d,%d,%d,%d)\n", nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        #endif
+        nOutputX = map(nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+        nOutputY = map(nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        // Perform constraining to OUTPUT boundaries
+        nOutputX = constrain(nOutputX, 0, nDispOutMaxX);
+        nOutputY = constrain(nOutputY, 0, nDispOutMaxY);
+      } else {
+        // No scaling from input to output
+        nOutputX = nInputX;
+        nOutputY = nInputY;
+      }
+    #else
+      // No scaling from input to output
+      nOutputX = nInputX;
+      nOutputY = nInputY;
+    #endif  // DRV_TOUCH_TYPE_RES
+  
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: PreRotate: x=%u y=%u\n", nOutputX, nOutputY);
+    #if defined(DRV_TOUCH_TYPE_RES)
+      GSLC_DEBUG_PRINT("DBG: RotateCfg: remap=%u nSwapXY=%u nFlipX=%u nFlipY=%u\n",
+        pGui->bTouchRemapEn,pGui->nSwapXY,pGui->nFlipX,pGui->nFlipY);
+    #endif // DRV_TOUCH_TYPE_RES
+    #endif // DBG_TOUCH
+
+    // Perform remapping due to current orientation
+    if (pGui->bTouchRemapEn) {
+      // Perform any requested swapping of input axes
+      if (pGui->nSwapXY) {
+        int16_t nOutputXTmp = nOutputX;
+        nOutputX = nOutputY;
+        nOutputY = nOutputXTmp;
+        // Perform any requested output axis flipping
+        // TODO: Collapse these cases
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxY - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxX - nOutputY;
+        }
+      } else {
+        // Perform any requested output axis flipping
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxX - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxY - nOutputY;
+        }
+      }
+    }
+
+    // Final assignment
+    *pnX          = nOutputX;
+    *pnY          = nOutputY;
+    *pnPress      = m_nLastRawPress;
+    *peInputEvent = GSLC_INPUT_TOUCH;
+    *pnInputVal   = 0;
+
+    // Print output for debug
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: Touch Press=%u Raw[%d,%d] Out[%d,%d]\n",
+        m_nLastRawPress,m_nLastRawX,m_nLastRawY,nOutputX,nOutputY);
+    #endif
+
+    // Return with indication of new value
+    return true;
+  }
+
+  // No new value
+  return false;
+}
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  bool bChange = true;
+
+  // Determine if the new orientation has swapped axes
+  // versus the native orientation (0)
+  bool bSwap = false;
+  if ((nRotation == 1) || (nRotation == 3)) {
+    bSwap = true;
+  }
+  (void)bSwap; // Unused
+
+  // Did the orientation change?
+  if (nRotation == pGui->nRotation) {
+    // Orientation did not change -- indicate this by returning
+    // false so that we can avoid a redraw
+    bChange = false;
+  }
+
+  // Update the GUI rotation member
+  pGui->nRotation = nRotation;
+
+  // Inform the display to adjust the orientation and
+  // update the saved display dimensions
+
+  // DRV_DISP_TFT_ESPI
+  // Capture display dimensions in native orientation
+  m_disp.setRotation(0);
+  pGui->nDisp0W = m_disp.width();
+  pGui->nDisp0H = m_disp.height();
+  // Capture display dimensions in selected orientation
+  m_disp.setRotation(pGui->nRotation);
+  pGui->nDispW = m_disp.width();
+  pGui->nDispH = m_disp.height();
+
+  // Update the clipping region
+  gslc_tsRect rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  gslc_DrvSetClipRect(pGui,&rClipRect);
+
+  // Now update the touch remapping
+  #if !defined(DRV_TOUCH_NONE)
+    // Correct touch mapping according to current rotation mode
+    pGui->nSwapXY = TOUCH_ROTATION_SWAPXY(pGui->nRotation);
+    pGui->nFlipX = TOUCH_ROTATION_FLIPX(pGui->nRotation);
+    pGui->nFlipY = TOUCH_ROTATION_FLIPY(pGui->nRotation);
+  #endif // !DRV_TOUCH_NONE
+
+  // Mark the current page ask requiring redraw
+  // if the rotation value changed
+  if (bChange) {
+    gslc_PageRedrawSet( pGui, true );
+  }
+
+  return true;
+}
+
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+
+// Convert from RGB struct to native screen format
+// TODO: Use 32bit return type?
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol)
+{
+  uint16_t nColRaw = 0;
+
+  #if defined(DRV_COLORMODE_MONO)
+    // Monochrome
+    if ((nCol.r == 0) && (nCol.g == 0) && (nCol.b == 0)) { // GSLC_COL_BLACK
+      nColRaw = 0;  // BLACK
+    } else {
+      nColRaw = 1;  // WHITE
+    }
+
+  #elif defined(DRV_COLORMODE_BGR565)
+    nColRaw |= (((nCol.b & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.r & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #else
+    // Default to DRV_COLORMODE_RGB565
+    nColRaw |= (((nCol.r & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.b & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #endif // DRV_COLORMODE_*
+
+  return nColRaw;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // Compiler guard for requested driver
diff --git a/src/guislice/GUIslice_drv_tft_espi.h b/src/guislice/GUIslice_drv_tft_espi.h
new file mode 100644
index 0000000..a09966a
--- /dev/null
+++ b/src/guislice/GUIslice_drv_tft_espi.h
@@ -0,0 +1,755 @@
+#ifndef _GUISLICE_DRV_TFT_ESPI_H_
+#define _GUISLICE_DRV_TFT_ESPI_H_
+
+// =======================================================================
+// GUIslice library (driver layer for bodmer/TFT_eSPI)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_tft_espi.h
+/// \brief GUIslice library (driver layer for TFT-eSPI)
+
+
+// =======================================================================
+// Driver Layer for bodmer/TFT_eSPI
+// - https://github.com/Bodmer/TFT_eSPI
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+
+// Determine characteristics for configured touch driver
+// - DRV_TOUCH_TYPE_EXTERNAL: TDrv* external touch APIs are enabled
+// - DRV_TOUCH_TYPE_RES:      Resistive overlay
+// - DRV_TOUCH_TYPE_CAP:      Capacitive overlay
+// - DRV_TOUCH_TYPE_ANALOG:   Analog input
+#if defined(DRV_TOUCH_ADA_STMPE610)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_ADA_FT6206)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_CAP         // Capacitive
+#elif defined(DRV_TOUCH_ADA_SIMPLE)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+  #define DRV_TOUCH_TYPE_ANALOG      // Analog
+#elif defined(DRV_TOUCH_XPT2046_STM)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_XPT2046_PS)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_TFT_ESPI)
+  #define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_INPUT)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_HANDLER)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_NONE)
+#endif // DRV_TOUCH_*
+
+// Additional defines
+// - Provide default if not in config file
+#if !defined(GSLC_SPIFFS_EN)
+  #define GSLC_SPIFFS_EN 0
+#endif // GSLC_SPIFFS_EN
+
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT             1 ///< Support gslc_DrvDrawPoint()
+
+#define DRV_HAS_DRAW_POINTS            0 ///< Support gslc_DrvDrawPoints()
+#define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+#define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+#define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FRAME  1 ///< Support gslc_DrvDrawFrameRoundRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FILL   1 ///< Support gslc_DrvDrawFillRoundRect()
+#define DRV_HAS_DRAW_CIRCLE_FRAME      1 ///< Support gslc_DrvDrawFrameCircle()
+#define DRV_HAS_DRAW_CIRCLE_FILL       1 ///< Support gslc_DrvDrawFillCircle()
+#define DRV_HAS_DRAW_TRI_FRAME         1 ///< Support gslc_DrvDrawFrameTriangle()
+#define DRV_HAS_DRAW_TRI_FILL          1 ///< Support gslc_DrvDrawFillTriangle()
+#define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+#define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+
+#define DRV_OVERRIDE_TXT_ALIGN         1 ///< Driver provides text alignment
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+  gslc_tsColor  nColBkgnd;      ///< Background color (if not image-based)
+
+  gslc_tsRect   rClipRect;      ///< Clipping rectangle
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit(). This can be done with gslc_DrvInitEnv()
+///   or manually in user function.
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTs(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(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_DrvGetDriverDisp(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_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// 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_DrvSetBkgndImage(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_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type:
+///                             - GSLC_FONTREF_PTR for Standard TFT_eSPI Fonts
+///                             - GSLC_FONTREF_FNAME for antialiased Font in SPIFFS
+/// \param[in]  pvFontRef:      Font reference pointer / SPIFFS font filename without ext.
+/// \param[in]  nFontSz:        Typeface size to use, ignored for SPIFFS font
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       Color of Background for antialias blending
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+///
+/// Draw a text string in a bounding box using the specified alignment
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         X coordinate of top-left of bounding box
+/// \param[in]  nY0:         Y coordinate of top-left of bounding box
+/// \param[in]  nX1:         X coordinate of bot-right of bounding box
+/// \param[in]  nY1:         Y coordinate of bot-right of bounding box
+/// \param[in]  eTxtAlign:   Alignment mode]
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       Color of Background for antialias blending
+//⁠
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxtAlign(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,int8_t eTxtAlign,
+        gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,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 true if success, false if error
+///
+bool gslc_DrvDrawFillRect(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 rounded corners
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,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 rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameCircle(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 of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillCircle(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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameTriangle(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 to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// Draw a monochrome bitmap from a memory array
+/// - Draw from the bitmap buffer using the foreground color
+///   defined in the header (unset bits are transparent)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY, const unsigned char *pBitmap,bool bProgMem);
+
+
+///
+/// Draw a color 24-bit depth bitmap from a memory array
+/// - Note that users must convert images from their native
+///   format (eg. BMP, PNG, etc.) into a C array. Please
+///   refer to the following guide for details:
+///   https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Images-from-FLASH
+/// - The converted file (c array) can then be included in the sketch.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       X coord for copy
+/// \param[in]  nDstY:       Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem);
+
+#if (GSLC_SPIFFS_EN)
+///
+/// This routine uses TFT_eFEX library to draw a BMP file stored in SPIFFS file system
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawBmpFromFile(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// This routine uses TFT_eFEX library to draw a JPEG file stored in SPIFFS file system
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawJpegFromFile(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+#endif // end GSLC_SPIFFS_EN
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using display driver library)
+// -----------------------------------------------------------------------
+
+#if defined(DRV_TOUCH_IN_DISP)
+// Use TFT_eSPI's integrated XPT2046 touch driver
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the internal XPT2046 touch handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_IN_DISP
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using external touch driver library)
+// -----------------------------------------------------------------------
+
+// Check for deprecated config option
+// - This check will be removed in future releases
+#if defined(DRV_TOUCH_XPT2046)
+  #error "NOTE: DRV_TOUCH_XPT2046 has been renamed to DRV_TOUCH_XPT2046_STM. Please update your config."
+#endif
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the SDL_Event handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_TFT_ESPI_H_
diff --git a/src/guislice/GUIslice_drv_utft.cpp b/src/guislice/GUIslice_drv_utft.cpp
new file mode 100644
index 0000000..f36f251
--- /dev/null
+++ b/src/guislice/GUIslice_drv_utft.cpp
@@ -0,0 +1,1361 @@
+// =======================================================================
+// GUIslice library (driver layer for UTFT)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_utft.cpp
+
+
+// Compiler guard for requested driver
+#include "GUIslice_config.h" // Sets DRV_DISP_*
+#if defined(DRV_DISP_UTFT)
+
+// =======================================================================
+// Driver Layer for UTFT
+// =======================================================================
+
+// GUIslice library
+#include "GUIslice_drv_utft.h"
+
+#include <stdio.h>
+
+// ------------------------------------------------------------------------
+// Load display drivers
+// ------------------------------------------------------------------------
+#if defined(DRV_DISP_UTFT)
+  #include <UTFT.h>
+#else
+  #error "CONFIG: Need to enable a supported DRV_DISP_* option in GUIslice config"
+#endif
+
+
+// ------------------------------------------------------------------------
+// Load touch drivers
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_URTOUCH)
+  #if defined(DRV_TOUCH_URTOUCH_OLD)
+    #include <UTouch.h> // Select old version of URTouch
+  #else
+    #include <URTouch.h>
+  #endif
+#endif
+
+// ------------------------------------------------------------------------
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+// ------------------------------------------------------------------------
+#if defined(DRV_DISP_UTFT)
+  const char* m_acDrvDisp = "UTFT";
+  UTFT m_disp(DRV_DISP_UTFT_INIT);
+
+// ------------------------------------------------------------------------
+#endif // DRV_DISP_*
+
+// ------------------------------------------------------------------------
+#if defined(DRV_TOUCH_URTOUCH)
+  #if defined(DRV_TOUCH_URTOUCH_OLD)
+    const char* m_acDrvTouch = "URTOUCH_OLD";
+    UTouch m_touch(DRV_TOUCH_URTOUCH_INIT);
+  #else
+    const char* m_acDrvTouch = "URTOUCH";
+    URTouch m_touch(DRV_TOUCH_URTOUCH_INIT);
+  #endif
+  #define DRV_TOUCH_INSTANCE
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_INPUT)
+  const char* m_acDrvTouch = "INPUT";
+// ------------------------------------------------------------------------
+#elif defined(DRV_TOUCH_NONE)
+  const char* m_acDrvTouch = "NONE";
+// ------------------------------------------------------------------------
+#endif // DRV_TOUCH_*
+
+// -----------------------------------------------------------------------
+// Font Definitions
+// -----------------------------------------------------------------------
+  extern uint8_t SmallFont[];
+  extern uint8_t BigFont[];
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// =======================================================================
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+bool gslc_DrvInit(gslc_tsGui* pGui)
+{
+
+  // Report any debug info if enabled
+  #if defined(DBG_DRIVER)
+  // TODO
+  #endif
+
+  // Initialize any library-specific members
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    pDriver->nColBkgnd = GSLC_COL_BLACK;
+
+    // These displays can accept partial redraw as they retain the last
+    // image in the controller graphics RAM
+    pGui->bRedrawPartialEn = true;
+
+    // Support any additional initialization prior to display init
+
+    // Perform any display initialization
+    #if defined(DRV_DISP_UTFT)
+      m_disp.InitLCD();
+      m_disp.clrScr();
+
+    #endif
+
+    // Now that we have initialized the display, we can assign
+    // the rotation parameters and clipping region
+    gslc_DrvRotate(pGui,GSLC_ROTATE);
+
+
+    // Initialize SD card usage
+    #if (GSLC_SD_EN)
+    if (!SD.begin(ADAGFX_PIN_SDCS)) {
+      GSLC_DEBUG_PRINT("ERROR: DrvInit() SD init failed\n",0);
+      return false;
+    }
+    #endif
+
+  }
+  return true;
+}
+
+void* gslc_DrvGetDriverDisp(gslc_tsGui* pGui)
+{
+  return (void*)(&m_disp);
+}
+
+void gslc_DrvDestruct(gslc_tsGui* pGui)
+{
+}
+
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui)
+{
+  return m_acDrvDisp;
+}
+
+const char* gslc_DrvGetNameTouch(gslc_tsGui* pGui)
+{
+  return m_acDrvTouch;
+}
+
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // GUIslice adapter for Adafruit-GFX doesn't preload the
+  // images into RAM (to keep RAM requirements low), so we
+  // don't need to do any further processing here. Instead,
+  // the loading is done during render.
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return NULL;
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    return NULL;  // No image preload done
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    return NULL;  // No image preload done
+  }
+
+  // Default
+  return NULL;
+}
+
+
+bool gslc_DrvSetBkgndImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef)
+{
+  // Dispose of previous background
+  if (pGui->sImgRefBkgnd.eImgFlags != GSLC_IMGREF_NONE) {
+    gslc_DrvImageDestruct(pGui->sImgRefBkgnd.pvImgRaw);
+    pGui->sImgRefBkgnd = gslc_ResetImage();
+  }
+
+  pGui->sImgRefBkgnd = sImgRef;
+  pGui->sImgRefBkgnd.pvImgRaw = gslc_DrvLoadImage(pGui,sImgRef);
+  if (pGui->sImgRefBkgnd.pvImgRaw == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvSetBkgndImage(%s) failed\n","");
+    return false;
+  }
+
+  return true;
+}
+
+
+bool gslc_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+    pDriver->nColBkgnd = nCol;
+  }
+  return true;
+}
+
+
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefNorm = sImgRef;
+  return true; // TODO
+}
+
+
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef)
+{
+  // This driver doesn't preload the image to memory,
+  // so we just save the reference for loading upon render
+  pElem->sImgRefGlow = sImgRef;
+  return true; // TODO
+}
+
+
+void gslc_DrvImageDestruct(void* pvImg)
+{
+}
+
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect)
+{
+  // NOTE: The clipping rect is currently saved in the
+  // driver struct, but the drawing code does not currently
+  // use it.
+  gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (pRect == NULL) {
+    // Default to entire display
+    pDriver->rClipRect = {0,0,pGui->nDispW,pGui->nDispH};
+  } else {
+    pDriver->rClipRect = *pRect;
+  }
+
+  // TODO: For ILI9341, perhaps we can leverage m_disp.setAddrWindow(x0, y0, x1, y1)?
+  return true;
+}
+
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType, const void* pvFontRef, uint16_t nFontSz)
+{
+  // Arduino mode currently only supports font definitions from memory
+  if (eFontRefType != GSLC_FONTREF_PTR) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvFontAdd(%s) failed - Arduino only supports memory-based fonts\n", "");
+    return NULL;
+  }
+  // For UTFT, we will force "SmallFont" to be the "default" font
+  // - The Adafruit-GFX convention for default/built-in font is to pass NULL font pointer
+  //   along with a size specifier
+  if (pvFontRef == NULL) {
+    //GSLC_DEBUG2_PRINT("DBG: DrvFontAdd() forcing SmallFont\n", "");
+    pvFontRef = SmallFont;
+  }
+  return pvFontRef;
+}
+
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui)
+{
+  // Nothing to deallocate
+}
+
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH)
+{
+  //uint16_t  nTxtScale = 0;
+  m_disp.setFont((uint8_t*)pFont->pvFont);
+  uint16_t nTxtLen = 0;
+
+  // Get length
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_RAM) {
+    // Fetch the text bounds
+    nTxtLen = strlen((char*)pStr);
+  } else if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+#if (GSLC_USE_PROGMEM)
+    nTxtLen = strlen_P(pStr);
+#else
+    // NOTE: Should not get here
+    // - The text string has been marked as being stored in
+    //   FLASH via PROGMEM (typically for Arduino) but
+    //   the current device does not support the PROGMEM
+    //   methodology.
+    // - Degrade back to using SRAM directly
+
+    // Fetch the text bounds
+    nTxtLen = strlen((char*)pStr);
+#endif
+  }
+
+  // Estimate the length of the monospaced font
+  *pnTxtSzW = nTxtLen * m_disp.getFontXsize();
+  *pnTxtSzH = 1 * m_disp.getFontYsize(); // TODO: Handle multi-line
+
+  // No baseline info available
+  *pnTxtX = 0;
+  *pnTxtY = 0;
+
+  // TODO m_disp.setFont();
+  return true;
+
+}
+
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt, gslc_tsColor colBg=GSLC_COL_BLACK)
+{
+  //uint16_t  nTxtScale = pFont->nSize;
+  uint16_t  nColRaw = gslc_DrvAdaptColorToRaw(colTxt);
+  char      ch;
+  int16_t   nTxtXStart;
+
+  // Initialize the font and positioning
+  m_disp.setFont((uint8_t*)pFont->pvFont);
+  m_disp.setColor(nColRaw);
+  // Default to transparent text rendering
+  m_disp.setBackColor(VGA_TRANSPARENT);
+
+  // TODO m_disp.setCursor(nTxtX,nTxtY);
+  // TODO m_disp.setTextSize(nTxtScale);
+
+  // Driver-specific overrides
+
+  // Default to accessing RAM directly (GSLC_TXT_MEM_RAM)
+  bool bProg = false;
+  if ((eTxtFlags & GSLC_TXT_MEM) == GSLC_TXT_MEM_PROG) {
+    bProg = true;
+  }
+
+  // Save the original starting X coordinate for line wraps
+  nTxtXStart = nTxtX;
+
+  while (1) {
+    // Fetch the next character
+    if (!bProg) {
+      // String in SRAM; can access buffer directly
+      ch = *(pStr++);
+    } else {
+      // String in PROGMEM (flash); must access via pgm_* calls
+      ch = pgm_read_byte(pStr++);
+    }
+
+    // Detect string terminator
+    if (ch == 0) {
+      break;
+    }
+
+    // Render the character
+    // Call UTFT for rendering
+    // Note that UTFT:printChar() is public but not documented
+    m_disp.printChar(ch,nTxtX,nTxtY);
+    // Advance the current position
+    nTxtX += m_disp.getFontXsize();
+
+    // Handle multi-line text:
+    // If we just output a newline, Adafruit-GFX will automatically advance
+    // the Y cursor but reset the X cursor to 0. Therefore we need to
+    // readjust the X cursor to our aligned bounding box.
+    if (ch == '\n') {
+      nTxtX = nTxtXStart;
+      nTxtY += m_disp.getFontYsize();
+    }
+
+  } // while(1)
+
+  // Restore the font
+  // TODO m_disp.setFont();
+
+  return true;
+}
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui)
+{
+  #if defined(DRV_DISP_ADAGFX_SSD1306)
+    // Show the display buffer on the hardware.
+    // NOTE: You _must_ call display after making any drawing commands
+    // to make them visible on the display hardware!
+    m_disp.display();
+    // TODO: Might need to call m_disp.clearDisplay() now?
+
+  #else
+    // Nothing to do as we're not double-buffered
+
+  #endif
+}
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+inline void gslc_DrvDrawPoint_base(int16_t nX, int16_t nY, uint16_t nColRaw)
+{
+  m_disp.setColor(nColRaw);
+  m_disp.drawPixel(nX, nY);
+}
+
+inline void gslc_DrvDrawLine_base(int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,uint16_t nColRaw)
+{
+  m_disp.setColor(nColRaw);
+  m_disp.drawLine(nX0,nY0,nX1,nY1);
+}
+
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipPt(&pDriver->rClipRect,nX,nY)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawPoint_base(nX, nY, nColRaw);
+  return true;
+}
+
+
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,gslc_tsColor nCol)
+{
+  return false;
+}
+
+bool gslc_DrvDrawFillRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipRect(&pDriver->rClipRect,&rRect)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.setColor(nColRaw);
+  m_disp.fillRect(rRect.x, rRect.y, rRect.x + rRect.w - 1, rRect.y + rRect.h - 1);
+  return true;
+}
+
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.setColor(nColRaw);
+  // TODO: Handle radius?
+  m_disp.fillRoundRect(rRect.x, rRect.y, rRect.x + rRect.w - 1, rRect.y + rRect.h - 1);
+  return true;
+}
+
+
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,gslc_tsColor nCol)
+{
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+#if (GSLC_CLIP_EN)
+  // Perform clipping
+  // - TODO: Optimize the following, perhaps with new ClipLineHV()
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  int16_t nX0, nY0, nX1, nY1;
+  // Top
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Bottom
+  nX0 = rRect.x;
+  nY0 = rRect.y + rRect.h - 1;
+  nX1 = rRect.x + rRect.w - 1;
+  nY1 = nY0;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Left
+  nX0 = rRect.x;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+  // Right
+  nX0 = rRect.x + rRect.w - 1;
+  nY0 = rRect.y;
+  nX1 = nX0;
+  nY1 = rRect.y + rRect.h - 1;
+  if (gslc_ClipLine(&pDriver->rClipRect, &nX0, &nY0, &nX1, &nY1)) { gslc_DrvDrawLine_base(nX0, nY0, nX1, nY1, nColRaw); }
+#else
+  m_disp.setColor(nColRaw);
+  m_disp.drawRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol)
+{
+#if (DRV_HAS_DRAW_RECT_ROUND_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+
+  // TODO: Support GSLC_CLIP_EN
+  // - Would need to determine how to clip the rounded corners
+  m_disp.setColor(nColRaw);
+  // TODO: Handle radius?
+  m_disp.drawRoundRect(rRect.x,rRect.y,rRect.x+rRect.w-1,rRect.y+rRect.h-1);
+#endif
+  return true;
+}
+
+
+
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  gslc_tsDriver* pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+  if (!gslc_ClipLine(&pDriver->rClipRect,&nX0,&nY0,&nX1,&nY1)) { return true; }
+#endif
+
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  gslc_DrvDrawLine_base(nX0,nY0,nX1,nY1,nColRaw);
+  return true;
+}
+
+bool gslc_DrvDrawFrameCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FRAME)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.setColor(nColRaw);
+  m_disp.drawCircle(nMidX, nMidY, nRadius);
+#endif
+  return true;
+}
+
+bool gslc_DrvDrawFillCircle(gslc_tsGui*,int16_t nMidX,int16_t nMidY,uint16_t nRadius,gslc_tsColor nCol)
+{
+#if (GSLC_CLIP_EN)
+  // TODO
+#endif
+
+#if (DRV_HAS_DRAW_CIRCLE_FILL)
+  uint16_t nColRaw = gslc_DrvAdaptColorToRaw(nCol);
+  m_disp.setColor(nColRaw);
+  m_disp.fillCircle(nMidX, nMidY, nRadius);
+#endif
+  return true;
+}
+
+
+
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit-GFX-Library/blob/master/Adafruit_GFX.cpp
+//   Original author:  Adafruit
+//   Function:         drawBitmap()
+
+// Draw a 1-bit image (bitmap) at the specified (x,y) position from the
+// provided bitmap buffer using the foreground color defined in the
+// header (unset bits are transparent).
+
+// GUIslice modified the raw memory format to add a header:
+// Image array format:
+// - Width[15:8],  Width[7:0],
+// - Height[15:8], Height[7:0],
+// - ColorR[7:0],  ColorG[7:0],
+// - ColorB[7:0],  0x00,
+// - Monochrome bitmap follows...
+//
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,
+ const unsigned char *pBitmap,bool bProgMem)
+ {
+  const unsigned char*  bmap_base = pBitmap;
+  int16_t         w,h;
+  gslc_tsColor    nCol;
+
+  // Read header
+  w       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  w      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  h       = ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 8;
+  h      |= ( (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++) ) << 0;
+  nCol.r  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.g  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  nCol.b  =   (bProgMem)? pgm_read_byte(bmap_base++) : *(bmap_base++);
+  bmap_base++;
+
+  int16_t i, j, byteWidth = (w + 7) / 8;
+  uint8_t nByte = 0;
+
+  for(j=0; j<h; j++) {
+    for(i=0; i<w; i++) {
+      if(i & 7) nByte <<= 1;
+      else {
+        if (bProgMem) {
+          nByte = pgm_read_byte(bmap_base + j * byteWidth + i / 8);
+        } else {
+          nByte = bmap_base[j * byteWidth + i / 8];
+        }
+      }
+      if(nByte & 0x80) {
+        gslc_DrvDrawPoint(pGui,nDstX+i,nDstY+j,nCol);
+      }
+    }
+  }
+}
+// ----- REFERENCE CODE end
+
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem)
+{
+  // AdaFruit GFX doesn't have a routine for this so we output pixel by pixel
+  const uint16_t* pImage = (const uint16_t*)pBitmap;
+  int16_t h, w;
+  if (bProgMem) {
+    h = pgm_read_word(pImage++);
+    w = pgm_read_word(pImage++);
+  } else {
+    h = *(pImage++);
+    w = *(pImage++);
+  }
+  #if defined(DBG_DRIVER)
+  GSLC_DEBUG_PRINT("DBG: DrvDrawBmp24FromMem() w=%d h=%d\n", w, h);
+  #endif
+  int row, col;
+  for (row=0; row<h; row++) { // For each scanline...
+    for (col=0; col<w; col++) { // For each pixel...
+      if (bProgMem) {
+        //To read from Flash Memory, pgm_read_XXX is required.
+        //Since image is stored as uint16_t, pgm_read_word is used as it uses 16bit address
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, pgm_read_word(pImage++));
+      } else {
+        gslc_DrvDrawPoint_base(nDstX+col, nDstY+row, *(pImage++));
+      }
+    } // end pixel
+  }
+}
+
+#if (GSLC_SD_EN)
+// ----- REFERENCE CODE begin
+// The following code was based upon the following reference code but modified to
+// adapt for use in GUIslice.
+//
+//   URL:              https://github.com/adafruit/Adafruit_ILI9341/blob/master/examples/spitftbitmap/spitftbitmap.ino
+//   Original author:  Adafruit
+//   Function:         bmpDraw()
+
+// These read 16- and 32-bit types from the SD card file.
+// BMP data is stored little-endian, Arduino is little-endian too.
+// May need to reverse subscript order if porting elsewhere.
+uint16_t gslc_DrvRead16SD(File &f) {
+  uint16_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read(); // MSB
+  return result;
+}
+
+uint32_t gslc_DrvRead32SD(File &f) {
+  uint32_t result;
+  ((uint8_t *)&result)[0] = f.read(); // LSB
+  ((uint8_t *)&result)[1] = f.read();
+  ((uint8_t *)&result)[2] = f.read();
+  ((uint8_t *)&result)[3] = f.read(); // MSB
+  return result;
+}
+
+void gslc_DrvDrawBmp24FromSD(gslc_tsGui* pGui,const char *filename, uint16_t x, uint16_t y)
+{
+  File     bmpFile;
+  int      bmpWidth, bmpHeight;   // W+H in pixels
+  uint8_t  bmpDepth;              // Bit depth (currently must be 24)
+  uint32_t bmpImageoffset;        // Start of image data in file
+  uint32_t rowSize;               // Not always = bmpWidth; may have padding
+  uint8_t  sdbuffer[3*GSLC_SD_BUFFPIXEL]; // pixel buffer (R+G+B per pixel)
+  uint8_t  buffidx = sizeof(sdbuffer); // Current position in sdbuffer
+  boolean  goodBmp = false;       // Set to true on valid header parse
+  boolean  flip    = true;        // BMP is stored bottom-to-top
+  int      w, h, row, col;
+  uint8_t  r, g, b;
+  uint32_t pos = 0, startTime = millis();
+  (void)startTime; // Unused
+
+  if((x >= pGui->nDispW) || (y >= pGui->nDispH)) return;
+
+  //Serial.println();
+  //Serial.print("Loading image '");
+  //Serial.print(filename);
+  //Serial.println('\'');
+
+  // Open requested file on SD card
+  if ((bmpFile = SD.open(filename)) == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() file not found [%s]",filename);
+    return;
+  }
+  // Parse BMP header
+  if(gslc_DrvRead16SD(bmpFile) == 0x4D42) { // BMP signature
+    uint32_t nFileSize = gslc_DrvRead32SD(bmpFile);
+    (void)nFileSize; // Unused
+    //Serial.print("File size: "); Serial.println(nFileSize);
+    (void)gslc_DrvRead32SD(bmpFile); // Read & ignore creator bytes
+    bmpImageoffset = gslc_DrvRead32SD(bmpFile); // Start of image data
+    //Serial.print("Image Offset: "); Serial.println(bmpImageoffset, DEC);
+    // Read DIB header
+    uint32_t nHdrSize = gslc_DrvRead32SD(bmpFile);
+    (void)nHdrSize; // Unused
+    //Serial.print("Header size: "); Serial.println(nHdrSize);
+    bmpWidth  = gslc_DrvRead32SD(bmpFile);
+    bmpHeight = gslc_DrvRead32SD(bmpFile);
+    if(gslc_DrvRead16SD(bmpFile) == 1) { // # planes -- must be '1'
+      bmpDepth = gslc_DrvRead16SD(bmpFile); // bits per pixel
+      //Serial.print("Bit Depth: "); Serial.println(bmpDepth);
+      if((bmpDepth == 24) && (gslc_DrvRead32SD(bmpFile) == 0)) { // 0 = uncompressed
+        goodBmp = true; // Supported BMP format -- proceed!
+        //Serial.print("Image size: ");
+        //Serial.print(bmpWidth);
+        //Serial.print('x');
+        //Serial.println(bmpHeight);
+
+        // BMP rows are padded (if needed) to 4-byte boundary
+        rowSize = (bmpWidth * 3 + 3) & ~3;
+
+        // If bmpHeight is negative, image is in top-down order.
+        // This is not canon but has been observed in the wild.
+        if(bmpHeight < 0) {
+          bmpHeight = -bmpHeight;
+          flip      = false;
+        }
+
+        // Crop area to be loaded
+        w = bmpWidth;
+        h = bmpHeight;
+        if((x+w-1) >= pGui->nDispW) w = pGui->nDispW  - x;
+        if((y+h-1) >= pGui->nDispH) h = pGui->nDispH - y;
+
+        // Set TFT address window to clipped image bounds
+        //xxx tft.setAddrWindow(x, y, x+w-1, y+h-1);
+
+        for (row=0; row<h; row++) { // For each scanline...
+
+          // Seek to start of scan line.  It might seem labor-
+          // intensive to be doing this on every line, but this
+          // method covers a lot of gritty details like cropping
+          // and scanline padding.  Also, the seek only takes
+          // place if the file position actually needs to change
+          // (avoids a lot of cluster math in SD library).
+          if(flip) // Bitmap is stored bottom-to-top order (normal BMP)
+            pos = bmpImageoffset + (bmpHeight - 1 - row) * rowSize;
+          else     // Bitmap is stored top-to-bottom
+            pos = bmpImageoffset + row * rowSize;
+          if(bmpFile.position() != pos) { // Need seek?
+            bmpFile.seek(pos);
+            buffidx = sizeof(sdbuffer); // Force buffer reload
+          }
+
+          for (col=0; col<w; col++) { // For each pixel...
+            // Time to read more pixel data?
+            if (buffidx >= sizeof(sdbuffer)) { // Indeed
+              bmpFile.read(sdbuffer, sizeof(sdbuffer));
+              buffidx = 0; // Set index to beginning
+            }
+
+            // Convert pixel from BMP to TFT format, push to display
+            b = sdbuffer[buffidx++];
+            g = sdbuffer[buffidx++];
+            r = sdbuffer[buffidx++];
+            //xxx tft.pushColor(tft.Color565(r,g,b));
+            gslc_tsColor nCol = (gslc_tsColor){r,g,b};
+            bool bDrawBit = true;
+            if (GSLC_BMP_TRANS_EN) {
+              gslc_tsColor nColTrans = pGui->sTransCol;
+              if ((nCol.r == nColTrans.r) && (nCol.g == nColTrans.g) && (nCol.b == nColTrans.b)) {
+                bDrawBit = false;
+              }
+            }
+            if (bDrawBit) {
+              gslc_DrvDrawPoint(pGui,x+col,y+row,nCol);
+            }
+
+          } // end pixel
+        } // end scanline
+        //Serial.print("Loaded in ");
+        //Serial.print(millis() - startTime);
+        //Serial.println(" ms");
+      } // end goodBmp
+    }
+  }
+  bmpFile.close();
+  if(!goodBmp) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvDrawBmp24FromSD() BMP format unknown [%s]",filename);
+  }
+}
+// ----- REFERENCE CODE end
+#endif // GSLC_SD_EN
+
+
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef)
+{
+  #if defined(DBG_DRIVER)
+  char addr[6];
+  GSLC_DEBUG_PRINT("DBG: DrvDrawImage() with ImgBuf address=","");
+  sprintf(addr,"%04X",(unsigned int)sImgRef.pImgBuf);
+  GSLC_DEBUG_PRINT("%s\n",addr);
+  #endif
+
+  // GUIslice adapter library for Adafruit-GFX does not pre-load
+  // image data into memory before calling DrvDrawImage(), so
+  // we to handle the loading now (when rendering).
+  if (sImgRef.eImgFlags == GSLC_IMGREF_NONE) {
+    return true;  // Nothing to do
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_FILE) {
+    return false; // Not supported
+
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_RAM) {
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from SRAM
+      // - Dimensions and output color are defined in arrray header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in ram
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,false);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+#if (GSLC_USE_PROGMEM)
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_PROG) {
+    // TODO: Probably need to fix this to work with PROGMEM,
+    //       but check (GSLC_USE_PROGMEM) first
+    if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_RAW1) {
+      // Draw a monochrome bitmap from program memory
+      // - Dimensions and output color are defined in array header
+      gslc_DrvDrawMonoFromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+      // 24-bit Bitmap in flash
+      gslc_DrvDrawBmp24FromMem(pGui,nDstX,nDstY,sImgRef.pImgBuf,true);
+      return true;
+    } else {
+      return false; // TODO: not yet supported
+    }
+#endif
+  } else if ((sImgRef.eImgFlags & GSLC_IMGREF_SRC) == GSLC_IMGREF_SRC_SD) {
+    // Load image from SD media
+    #if (GSLC_SD_EN)
+      if ((sImgRef.eImgFlags & GSLC_IMGREF_FMT) == GSLC_IMGREF_FMT_BMP24) {
+        // 24-bit Bitmap
+        gslc_DrvDrawBmp24FromSD(pGui,sImgRef.pFname,nDstX,nDstY);
+        return true;
+      } else {
+        // Unsupported format
+        return false;
+      }
+    #else
+      // SD card access not enabled
+      return false;
+    #endif
+
+  } else {
+    // Unsupported source
+    GSLC_DEBUG2_PRINT("DBG: DrvDrawImage() unsupported source eImgFlags=%d\n", sImgRef.eImgFlags);
+    return false;
+  }
+}
+
+
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui)
+{
+  if (pGui->pvDriver) {
+    gslc_tsDriver*  pDriver = (gslc_tsDriver*)(pGui->pvDriver);
+
+    // Check to see if an image has been assigned to the background
+    if (pGui->sImgRefBkgnd.eImgFlags == GSLC_IMGREF_NONE) {
+      // No image assigned, so assume flat color background
+      // TODO: Create a new eImgFlags enum to signal that the
+      //       background should be a flat color instead of
+      //       an image.
+
+      // NOTE: We don't call m_disp.fillScreen() here as
+      //       that API doesn't support clipping. Since
+      //       we may be redrawing the page with a clipping
+      //       region enabled, it is important that we don't
+      //       redraw the entire screen.
+      gslc_tsRect rRect = (gslc_tsRect) { 0, 0, pGui->nDispW, pGui->nDispH };
+      gslc_DrvDrawFillRect(pGui, rRect, pDriver->nColBkgnd);
+    } else {
+      // An image should be loaded
+      // TODO: For now, re-use the DrvDrawImage(). Later, consider
+      //       extending to support different background drawing
+      //       capabilities such as stretching and tiling of background
+      //       image.
+      gslc_DrvDrawImage(pGui,0,0,pGui->sImgRefBkgnd);
+    }
+  }
+}
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (via display driver)
+// -----------------------------------------------------------------------
+
+
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+  if (pGui == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: DrvInitTouch(%s) called with NULL ptr\n","");
+    return false;
+  }
+  // TODO
+  // Perform any driver-specific touchscreen init here
+  return true;
+}
+
+void* gslc_DrvGetDriverTouch(gslc_tsGui* pGui)
+{
+  // As the touch driver instance is optional, we need to check for
+  // its existence before returning a pointer to it.
+  #if defined(DRV_TOUCH_INSTANCE)
+    return (void*)(&m_touch);
+  #else
+    return NULL;
+  #endif
+}
+
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+  // TODO
+  return false;
+}
+
+// ------------------------------------------------------------------------
+// Touch Functions (via external touch driver)
+// ------------------------------------------------------------------------
+
+
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev) {
+
+  // Capture default calibration settings for resistive displays
+  #if defined(DRV_TOUCH_TYPE_RES)
+    pGui->nTouchCalXMin = ADATOUCH_X_MIN;
+    pGui->nTouchCalXMax = ADATOUCH_X_MAX;
+    pGui->nTouchCalYMin = ADATOUCH_Y_MIN;
+    pGui->nTouchCalYMax = ADATOUCH_Y_MAX;
+  #endif // DRV_TOUCH_TYPE_RES
+
+  // Support touch controllers with swapped X & Y
+  #if defined(ADATOUCH_REMAP_YX)
+    // Capture swap setting from config file
+    pGui->bTouchRemapYX = ADATOUCH_REMAP_YX;
+  #else
+    // For backward compatibility with older config files
+    // that have not defined this config option
+    pGui->bTouchRemapYX = false;
+  #endif
+
+  #if defined(DRV_TOUCH_URTOUCH)
+    m_touch.InitTouch();
+    m_touch.setPrecision(PREC_MEDIUM);
+    // Disable touch remapping since URTouch handles it
+    gslc_SetTouchRemapEn(pGui, false);
+    return true;
+  #elif defined(DRV_TOUCH_INPUT)
+    // Nothing more to initialize for GPIO input control mode
+    return true;
+  #elif defined(DRV_TOUCH_HANDLER)
+    return true;
+  #else
+    // ERROR: Unsupported driver mode
+    GSLC_DEBUG_PRINT("ERROR: TDrvInitTouch() driver not supported yet\n",0);
+    return false;
+  #endif
+
+}
+
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal)
+{
+
+  #if defined(DRV_TOUCH_NONE)
+    return false;
+  #endif
+
+  // As the STMPE610 hardware driver doesn't appear to return
+  // an indication of "touch released" with a coordinate, we
+  // must detect the release transition here and send the last
+  // known coordinate but with pressure=0. To do this, we are
+  // allocating a static variable to maintain the last touch
+  // coordinate.
+  // TODO: This code can be reworked / simplified
+  static int16_t  m_nLastRawX     = 0;
+  static int16_t  m_nLastRawY     = 0;
+  static uint16_t m_nLastRawPress = 0;
+  static bool     m_bLastTouched  = false;
+
+  bool bValid = false;  // Indicate a touch event to GUIslice core?
+
+  // Define maximum bounds for display in native orientation
+  int nDispOutMaxX,nDispOutMaxY;
+  nDispOutMaxX = pGui->nDisp0W-1;
+  nDispOutMaxY = pGui->nDisp0H-1;
+
+  // ----------------------------------------------------------------
+  #if defined(DRV_TOUCH_URTOUCH)
+
+    // Note that we rely on URTouch's calibration
+    // - This is detected by URTouch / URTouch_Calibration
+    // - The calibration settings are stored in URTouch/URTouchCD.h
+
+    int16_t   nRawX,nRawY;
+    uint16_t  nRawPress = 0;
+    bool bTouchOk = true;
+
+    if (!m_touch.dataAvailable()) {
+      bTouchOk = false;
+    }
+
+    if (bTouchOk) {
+      m_touch.read();
+      nRawX = m_touch.getX();
+      nRawY = m_touch.getY();
+      if ((nRawX == -1) || (nRawY == -1)) {
+        bTouchOk = false;
+      }
+    }
+
+    if (bTouchOk) {
+      nRawPress = 255; // Dummy non-zero value
+      m_nLastRawX = nRawX;
+      m_nLastRawY = nRawY;
+      m_nLastRawPress = nRawPress;
+      m_bLastTouched = true;
+      bValid = true;
+    } else {
+      if (!m_bLastTouched) {
+        // Wasn't touched before; do nothing
+      }
+      else {
+        // Touch release
+        // Indicate old coordinate but with pressure=0
+        m_nLastRawPress = 0;
+        m_bLastTouched = false;
+        bValid = true;
+      }
+    }
+
+  // ----------------------------------------------------------------
+  #elif defined(DRV_TOUCH_INPUT)
+    // No more to do for GPIO-only mode since gslc_Update() already
+    // looks for GPIO inputs before calling TDrvGetTouch().
+    // bValid will default to false
+
+
+  // Assign defaults
+  *pnX = 0;
+  *pnY = 0;
+  *pnPress = 0;
+
+  *peInputEvent = GSLC_INPUT_NONE;
+  *pnInputVal = 0;
+
+  #ifdef DRV_DISP_ADAGFX_SEESAW
+    // Keep track of last value to support simple debouncing
+    static uint32_t nButtonsLast = 0xFFFFFFFF;     // Saved last value (static to preserve b/w calls)
+    uint32_t nButtonsCur = m_seesaw.readButtons(); // Current value (note active low)
+    if ((nButtonsLast & TFTSHIELD_BUTTON_UP) && !(nButtonsCur & TFTSHIELD_BUTTON_UP)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_UP;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_DOWN) && !(nButtonsCur & TFTSHIELD_BUTTON_DOWN)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_DOWN;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_LEFT) && !(nButtonsCur & TFTSHIELD_BUTTON_LEFT)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_LEFT;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_RIGHT) && !(nButtonsCur & TFTSHIELD_BUTTON_RIGHT)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_RIGHT;
+    } else if ((nButtonsLast & TFTSHIELD_BUTTON_IN) && !(nButtonsCur & TFTSHIELD_BUTTON_IN)) {
+      *peInputEvent = GSLC_INPUT_PIN_ASSERT;
+      *pnInputVal = GSLC_PIN_BTN_SEL;
+    }
+    // Save button state so that transitions can be detected
+    // during the next pass.
+    nButtonsLast = nButtonsCur;
+  #endif
+
+
+  // If we reached here, then we had a button event
+  return true;
+
+  // ----------------------------------------------------------------
+  #endif // DRV_TOUCH_*
+
+
+  // If an event was detected, signal it back to GUIslice
+  if (bValid) {
+
+    int nRawX,nRawY;
+    int nInputX,nInputY;
+    int nOutputX,nOutputY;
+
+    // Input assignment
+    nRawX = m_nLastRawX;
+    nRawY = m_nLastRawY;
+
+    // Handle any hardware swapping in native orientation
+    // This is done prior to any flip/swap as a result of
+    // rotation away from the native orientation.
+    // In most cases, the following is not used, but there
+    // may be touch modules that have swapped their X&Y convention.
+    if (pGui->bTouchRemapYX) {
+      nRawX = m_nLastRawY;
+      nRawY = m_nLastRawX;
+    }
+
+    nInputX = nRawX;
+    nInputY = nRawY;
+
+    // For resistive displays, perform constraint and scaling
+    #if defined(DRV_TOUCH_TYPE_RES)
+      if (pGui->bTouchRemapEn) {
+        // Perform scaling from input to output
+        // - Calibration done in native orientation (GSLC_ROTATE=0)
+        // - Input to map() is done with raw unswapped X,Y
+        // - map() and constrain() done with native dimensions and
+        //   native calibration
+        // - Swap & Flip done to output of map/constrain according
+        //   to GSLC_ROTATE
+        //
+        #if defined(DBG_TOUCH)
+          GSLC_DEBUG_PRINT("DBG: remapX: (%d,%d,%d,%d,%d)\n", nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+          GSLC_DEBUG_PRINT("DBG: remapY: (%d,%d,%d,%d,%d)\n", nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        #endif
+        nOutputX = map(nInputX, pGui->nTouchCalXMin, pGui->nTouchCalXMax, 0, nDispOutMaxX);
+        nOutputY = map(nInputY, pGui->nTouchCalYMin, pGui->nTouchCalYMax, 0, nDispOutMaxY);
+        // Perform constraining to OUTPUT boundaries
+        nOutputX = constrain(nOutputX, 0, nDispOutMaxX);
+        nOutputY = constrain(nOutputY, 0, nDispOutMaxY);
+      } else {
+        // No scaling from input to output
+        nOutputX = nInputX;
+        nOutputY = nInputY;
+      }
+    #else
+      // No scaling from input to output
+      nOutputX = nInputX;
+      nOutputY = nInputY;
+    #endif  // DRV_TOUCH_TYPE_RES
+  
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: PreRotate: x=%u y=%u\n", nOutputX, nOutputY);
+    #if defined(DRV_TOUCH_TYPE_RES)
+      GSLC_DEBUG_PRINT("DBG: RotateCfg: remap=%u nSwapXY=%u nFlipX=%u nFlipY=%u\n",
+        pGui->bTouchRemapEn,pGui->nSwapXY,pGui->nFlipX,pGui->nFlipY);
+    #endif // DRV_TOUCH_TYPE_RES
+    #endif // DBG_TOUCH
+
+    // Perform remapping due to current orientation
+    if (pGui->bTouchRemapEn) {
+      // Perform any requested swapping of input axes
+      if (pGui->nSwapXY) {
+        int16_t nOutputXTmp = nOutputX;
+        nOutputX = nOutputY;
+        nOutputY = nOutputXTmp;
+        // Perform any requested output axis flipping
+        // TODO: Collapse these cases
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxY - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxX - nOutputY;
+        }
+      } else {
+        // Perform any requested output axis flipping
+        if (pGui->nFlipX) {
+          nOutputX = nDispOutMaxX - nOutputX;
+        }
+        if (pGui->nFlipY) {
+          nOutputY = nDispOutMaxY - nOutputY;
+        }
+      }
+    }
+
+    // Final assignment
+    *pnX          = nOutputX;
+    *pnY          = nOutputY;
+    *pnPress      = m_nLastRawPress;
+    *peInputEvent = GSLC_INPUT_TOUCH;
+    *pnInputVal   = 0;
+
+    // Print output for debug
+    #ifdef DBG_TOUCH
+    GSLC_DEBUG_PRINT("DBG: Touch Press=%u Raw[%d,%d] Out[%d,%d]\n",
+        m_nLastRawPress,m_nLastRawX,m_nLastRawY,nOutputX,nOutputY);
+    #endif
+
+    // Return with indication of new value
+    return true;
+  }
+
+  // No new value
+  return false;
+}
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+/// Change display rotation and any associated touch orientation
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation)
+{
+  bool bChange = true;
+  bool bSupportRotation = true;
+
+  // Determine if the new orientation has swapped axes
+  // versus the native orientation (0)
+  bool bSwap = false;
+  if ((nRotation == 1) || (nRotation == 3)) {
+    bSwap = true;
+  }
+  (void)bSwap; // May be Unused in some driver modes
+
+  // Did the orientation change?
+  if (nRotation == pGui->nRotation) {
+    // Orientation did not change -- indicate this by returning
+    // false so that we can avoid a redraw
+    bChange = false;
+  }
+
+  // Update the GUI rotation member
+  pGui->nRotation = nRotation;
+
+  // Inform the display to adjust the orientation and
+  // update the saved display dimensions
+  #if defined(DRV_DISP_UTFT)
+    pGui->nDisp0W = m_disp.getDisplayXSize();
+    pGui->nDisp0H = m_disp.getDisplayYSize();
+    // Temporarily disable support for rotation
+    // TODO m_disp.setRotation(pGui->nRotation);
+    pGui->nDispW = m_disp.getDisplayXSize();
+    pGui->nDispH = m_disp.getDisplayYSize();
+
+  #else
+    // Report error for unsupported display mode
+    // - If we don't trap this condition, the GUI dimensions will be incorrect
+    #error "ERROR: DRV_DISP_* mode not supported in DrvRotate initialization"
+
+  #endif
+
+  // Update the clipping region
+  gslc_tsRect rClipRect = { 0,0,pGui->nDispW,pGui->nDispH };
+  gslc_DrvSetClipRect(pGui, &rClipRect);
+
+  if (!bSupportRotation) {
+    // No support for rotation, so override rotation indicator to 0
+    // This will also ensure that nSwapXY / nFlipX / nFlipY all remain 0
+    pGui->nRotation = 0;
+    // Ensure no redraw forced due to change in rotation value
+    bChange = false;
+  }
+
+  // Now update the touch remapping
+  #if !defined(DRV_TOUCH_NONE)
+    // Correct touch mapping according to current rotation mode
+    pGui->nSwapXY = TOUCH_ROTATION_SWAPXY(pGui->nRotation);
+    pGui->nFlipX = TOUCH_ROTATION_FLIPX(pGui->nRotation);
+    pGui->nFlipY = TOUCH_ROTATION_FLIPY(pGui->nRotation);
+  #endif // !DRV_TOUCH_NONE
+
+  // Mark the current page ask requiring redraw
+  // if the rotation value changed
+  if (bChange) {
+    gslc_PageRedrawSet( pGui, true );
+  }
+
+  return true;
+}
+
+
+// =======================================================================
+// Private Functions
+// =======================================================================
+
+
+// Convert from RGB struct to native screen format
+// TODO: Use 32bit return type?
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol)
+{
+  uint16_t nColRaw = 0;
+
+  #if defined(DRV_COLORMODE_MONO)
+    // Monochrome
+    if ((nCol.r == 0) && (nCol.g == 0) && (nCol.b == 0)) { // GSLC_COL_BLACK
+      nColRaw = 0;  // BLACK
+    } else {
+      nColRaw = 1;  // WHITE
+    }
+
+  #elif defined(DRV_COLORMODE_BGR565)
+    nColRaw |= (((nCol.b & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.r & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #else
+    // Default to DRV_COLORMODE_RGB565
+    nColRaw |= (((nCol.r & 0xF8) >> 3) << 11); // Mask: 1111 1000 0000 0000
+    nColRaw |= (((nCol.g & 0xFC) >> 2) <<  5); // Mask: 0000 0111 1110 0000
+    nColRaw |= (((nCol.b & 0xF8) >> 3) <<  0); // Mask: 0000 0000 0001 1111
+
+  #endif // DRV_COLORMODE_*
+
+  return nColRaw;
+}
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+
+#endif // Compiler guard for requested driver
diff --git a/src/guislice/GUIslice_drv_utft.h b/src/guislice/GUIslice_drv_utft.h
new file mode 100644
index 0000000..3f7abd7
--- /dev/null
+++ b/src/guislice/GUIslice_drv_utft.h
@@ -0,0 +1,672 @@
+#ifndef _GUISLICE_DRV_UTFT_H_
+#define _GUISLICE_DRV_UTFT_H_
+
+// =======================================================================
+// GUIslice library (driver layer for UTFT)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_drv_utft.h
+/// \brief GUIslice library (driver layer for UTFT)
+
+
+// =======================================================================
+// Driver Layer for UTFT
+// =======================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#include "GUIslice.h"
+
+#include <stdio.h>
+
+
+// Determine characteristics for configured touch driver
+// - DRV_TOUCH_TYPE_EXTERNAL: TDrv* external touch APIs are enabled
+// - DRV_TOUCH_TYPE_RES:      Resistive overlay
+// - DRV_TOUCH_TYPE_CAP:      Capacitive overlay
+// - DRV_TOUCH_TYPE_ANALOG:   Analog input
+#if defined(DRV_TOUCH_URTOUCH)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+  // Don't set DRV_TOUCH_TYPE_RES since URTouch provides its own calibration
+  //#define DRV_TOUCH_TYPE_RES         // Resistive
+#elif defined(DRV_TOUCH_INPUT)
+  #define DRV_TOUCH_TYPE_EXTERNAL
+#elif defined(DRV_TOUCH_NONE)
+#endif // DRV_TOUCH_*
+
+
+// =======================================================================
+// API support definitions
+// - These defines indicate whether the driver includes optimized
+//   support for various APIs. If a define is set to 0, then the
+//   GUIslice core emulation will be used instead.
+// - At the very minimum, the point draw routine must be available:
+//   gslc_DrvDrawPoint()
+// =======================================================================
+
+#define DRV_HAS_DRAW_POINT             1 ///< Support gslc_DrvDrawPoint()
+
+#define DRV_HAS_DRAW_POINTS            0 ///< Support gslc_DrvDrawPoints()
+#define DRV_HAS_DRAW_LINE              1 ///< Support gslc_DrvDrawLine()
+#define DRV_HAS_DRAW_RECT_FRAME        1 ///< Support gslc_DrvDrawFrameRect()
+#define DRV_HAS_DRAW_RECT_FILL         1 ///< Support gslc_DrvDrawFillRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FRAME  1 ///< Support gslc_DrvDrawFrameRoundRect()
+#define DRV_HAS_DRAW_RECT_ROUND_FILL   1 ///< Support gslc_DrvDrawFillRoundRect()
+#define DRV_HAS_DRAW_CIRCLE_FRAME      1 ///< Support gslc_DrvDrawFrameCircle()
+#define DRV_HAS_DRAW_CIRCLE_FILL       1 ///< Support gslc_DrvDrawFillCircle()
+#define DRV_HAS_DRAW_TRI_FRAME         0 ///< Support gslc_DrvDrawFrameTriangle()
+#define DRV_HAS_DRAW_TRI_FILL          0 ///< Support gslc_DrvDrawFillTriangle()
+#define DRV_HAS_DRAW_TEXT              1 ///< Support gslc_DrvDrawTxt()
+#define DRV_HAS_DRAW_BMP_MEM           0 ///< Support gslc_DrvDrawBmp24FromMem()
+
+#define DRV_OVERRIDE_TXT_ALIGN         0 ///< Driver provides text alignment
+
+// =======================================================================
+// Driver-specific members
+// =======================================================================
+typedef struct {
+  gslc_tsColor  nColBkgnd;      ///< Background color (if not image-based)
+
+  gslc_tsRect   rClipRect;      ///< Clipping rectangle
+
+} gslc_tsDriver;
+
+
+
+// =======================================================================
+// Public APIs to GUIslice core library
+// - These functions define the renderer / driver-dependent
+//   implementations for the core drawing operations within
+//   GUIslice.
+// =======================================================================
+
+
+// -----------------------------------------------------------------------
+// Configuration Functions
+// -----------------------------------------------------------------------
+
+///
+/// Initialize the SDL library
+/// - Performs clean startup workaround (if enabled)
+/// - Configures video mode
+/// - Initializes font support
+///
+/// PRE:
+/// - The environment variables should be configured before
+///   calling gslc_DrvInit(). This can be done with gslc_DrvInitEnv()
+///   or manually in user function.
+///
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvInit(gslc_tsGui* pGui);
+
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTs(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Free up any members associated with the driver
+/// - Eg. renderers, windows, background surfaces, etc.
+///
+/// \param[in]  pGui:         Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the display driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameDisp(gslc_tsGui* pGui);
+
+
+///
+/// Get the touch driver name
+///
+/// \param[in]  pGui:      Pointer to GUI
+///
+/// \return String containing driver name
+///
+const char* gslc_DrvGetNameTouch(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_DrvGetDriverDisp(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_DrvGetDriverTouch(gslc_tsGui* pGui);
+
+// -----------------------------------------------------------------------
+// Image/surface handling Functions
+// -----------------------------------------------------------------------
+
+
+///
+/// Load a bitmap (*.bmp) and create a new image resource.
+/// Transparency is enabled by GSLC_BMP_TRANS_EN
+/// through use of color (GSLC_BMP_TRANS_RGB).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return Image pointer (surface/texture) or NULL if error
+///
+void* gslc_DrvLoadImage(gslc_tsGui* pGui,gslc_tsImgRef sImgRef);
+
+
+///
+/// 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_DrvSetBkgndImage(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_DrvSetBkgndColor(gslc_tsGui* pGui,gslc_tsColor nCol);
+
+///
+/// Set an element's normal-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageNorm(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+///
+/// Set an element's glow-state image
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElem:       Pointer to Element to update
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetElemImageGlow(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsImgRef sImgRef);
+
+
+///
+/// Release an image surface
+///
+/// \param[in]  pvImg:          Void ptr to image
+///
+/// \return none
+///
+void gslc_DrvImageDestruct(void* pvImg);
+
+
+///
+/// Set the clipping rectangle for future drawing updates
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pRect:         Rectangular region to constrain edits
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvSetClipRect(gslc_tsGui* pGui,gslc_tsRect* pRect);
+
+
+// -----------------------------------------------------------------------
+// Font handling Functions
+// -----------------------------------------------------------------------
+
+///
+/// Load a font from a resource and return pointer to it
+///
+/// \param[in]  eFontRefType:   Font reference type (GSLC_FONTREF_PTR for Arduino)
+/// \param[in]  pvFontRef:      Font reference pointer (Pointer to the GFXFont array)
+/// \param[in]  nFontSz:        Typeface size to use
+///
+/// \return Void ptr to driver-specific font if load was successful, NULL otherwise
+///
+const void* gslc_DrvFontAdd(gslc_teFontRefType eFontRefType,const void* pvFontRef,uint16_t nFontSz);
+
+///
+/// Release all fonts defined in the GUI
+///
+/// \param[in]  pGui:          Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvFontsDestruct(gslc_tsGui* pGui);
+
+
+///
+/// Get the extent (width and height) of a text string
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pFont:       Ptr to Font structure
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[out] pnTxtX:      Ptr to offset X of text
+/// \param[out] pnTxtY:      Ptr to offset Y of text
+/// \param[out] pnTxtSzW:    Ptr to width of text
+/// \param[out] pnTxtSzH:    Ptr to height of text
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvGetTxtSize(gslc_tsGui* pGui,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,
+        int16_t* pnTxtX,int16_t* pnTxtY,uint16_t* pnTxtSzW,uint16_t* pnTxtSzH);
+
+
+///
+/// Draw a text string at the given coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nTxtX:       X coordinate of top-left text string
+/// \param[in]  nTxtY:       Y coordinate of top-left text string
+/// \param[in]  pFont:       Ptr to Font
+/// \param[in]  pStr:        String to display
+/// \param[in]  eTxtFlags:   Flags associated with text string
+/// \param[in]  colTxt:      Color to draw text
+/// \param[in]  colBg:       unused in ADAGFX, defaults to black
+///
+/// \return true if success, false if failure
+///
+bool gslc_DrvDrawTxt(gslc_tsGui* pGui,int16_t nTxtX,int16_t nTxtY,gslc_tsFont* pFont,const char* pStr,gslc_teTxtFlags eTxtFlags,gslc_tsColor colTxt,gslc_tsColor colBg);
+
+
+// -----------------------------------------------------------------------
+// Screen Management Functions
+// -----------------------------------------------------------------------
+
+///
+/// Force a page flip to occur. This generally copies active
+/// screen surface to the display.
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return none
+///
+void gslc_DrvPageFlipNow(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Graphics Primitives Functions
+// -----------------------------------------------------------------------
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX:          X coordinate of point
+/// \param[in]  nY:          Y coordinate of point
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoint(gslc_tsGui* pGui,int16_t nX,int16_t nY,gslc_tsColor nCol);
+
+///
+/// Draw a point
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  asPt:        Array of points to draw
+/// \param[in]  nNumPt:      Number of points in array
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawPoints(gslc_tsGui* pGui,gslc_tsPt* asPt,uint16_t nNumPt,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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRect(gslc_tsGui* pGui,gslc_tsRect rRect,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 true if success, false if error
+///
+bool gslc_DrvDrawFillRect(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 rounded corners
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,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 rounded corners
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillRoundRect(gslc_tsGui* pGui,gslc_tsRect rRect,int16_t nRadius,gslc_tsColor nCol);
+
+
+
+///
+/// Draw a line
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nX0:         Line start (X coordinate)
+/// \param[in]  nY0:         Line start (Y coordinate)
+/// \param[in]  nX1:         Line finish (X coordinate)
+/// \param[in]  nY1:         Line finish (Y coordinate)
+/// \param[in]  nCol:        Color RGB value to draw
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawLine(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,int16_t nX1,int16_t nY1,gslc_tsColor nCol);
+
+
+///
+/// Draw a framed circle
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nMidX:       Center of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameCircle(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 of circle (X coordinate)
+/// \param[in]  nMidY:       Center of circle (Y coordinate)
+/// \param[in]  nRadius:     Radius of circle
+/// \param[in]  nCol:        Color RGB value to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillCircle(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 to frame
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFrameTriangle(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 to fill
+///
+/// \return true if success, false if error
+///
+bool gslc_DrvDrawFillTriangle(gslc_tsGui* pGui,int16_t nX0,int16_t nY0,
+        int16_t nX1,int16_t nY1,int16_t nX2,int16_t nY2,gslc_tsColor nCol);
+
+
+///
+/// Copy all of source image to destination screen at specified coordinate
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  sImgRef:     Image reference
+///
+/// \return true if success, false if fail
+///
+bool gslc_DrvDrawImage(gslc_tsGui* pGui,int16_t nDstX,int16_t nDstY,gslc_tsImgRef sImgRef);
+
+
+///
+/// Draw a monochrome bitmap from a memory array
+/// - Draw from the bitmap buffer using the foreground color
+///   defined in the header (unset bits are transparent)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       Destination X coord for copy
+/// \param[in]  nDstY:       Destination Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawMonoFromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY, const unsigned char *pBitmap,bool bProgMem);
+
+
+///
+/// Draw a color 24-bit depth bitmap from a memory array
+/// - Note that users must convert images from their native
+///   format (eg. BMP, PNG, etc.) into a C array. Please
+///   refer to the following guide for details:
+///   https://github.com/ImpulseAdventure/GUIslice/wiki/Display-Images-from-FLASH
+/// - The converted file (c array) can then be included in the sketch.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nDstX:       X coord for copy
+/// \param[in]  nDstY:       Y coord for copy
+/// \param[in]  pBitmap:     Pointer to bitmap buffer
+/// \param[in]  bProgMem:    Bitmap is stored in Flash if true, RAM otherwise
+///
+/// \return none
+///
+void gslc_DrvDrawBmp24FromMem(gslc_tsGui* pGui,int16_t nDstX, int16_t nDstY,const unsigned char* pBitmap,bool bProgMem);
+
+///
+/// Copy the background image to destination screen
+///
+/// \param[in]  pGui:        Pointer to GUI
+///
+/// \return true if success, false if fail
+///
+void gslc_DrvDrawBkgnd(gslc_tsGui* pGui);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using display driver library)
+// -----------------------------------------------------------------------
+
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_DrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the internal touch handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_DrvGetTouch(gslc_tsGui* pGui,int16_t* pnX,int16_t* pnY,uint16_t* pnPress,gslc_teInputRawEvent* peInputEvent,int16_t* pnInputVal);
+
+
+// -----------------------------------------------------------------------
+// Touch Functions (if using external touch driver library)
+// -----------------------------------------------------------------------
+
+
+#if defined(DRV_TOUCH_TYPE_EXTERNAL)
+///
+/// Perform any touchscreen-specific initialization
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  acDev:       Device path to touchscreen
+///                          eg. "/dev/input/touchscreen"
+///
+/// \return true if successful
+///
+bool gslc_TDrvInitTouch(gslc_tsGui* pGui,const char* acDev);
+
+
+///
+/// Get the last touch event from the SDL_Event handler
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[out] pnX:         Ptr to X coordinate of last touch event
+/// \param[out] pnY:         Ptr to Y coordinate of last touch event
+/// \param[out] pnPress:     Ptr to Pressure level of last touch event (0 for none, 1 for touch)
+/// \param[out] peInputEvent Indication of event type
+/// \param[out] pnInputVal   Additional data for event type
+///
+/// \return true if an event was detected or false otherwise
+///
+bool gslc_TDrvGetTouch(gslc_tsGui* pGui, int16_t* pnX, int16_t* pnY, uint16_t* pnPress, gslc_teInputRawEvent* peInputEvent, int16_t* pnInputVal);
+
+#endif // DRV_TOUCH_*
+
+
+// -----------------------------------------------------------------------
+// Dynamic Screen rotation and Touch axes swap/flip functions
+// -----------------------------------------------------------------------
+
+///
+/// Change rotation, automatically adapt touchscreen axes swap/flip
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nRotation:   Screen Rotation value (0, 1, 2 or 3)
+///
+/// \return true if successful
+///
+bool gslc_DrvRotate(gslc_tsGui* pGui, uint8_t nRotation);
+
+
+// =======================================================================
+// Private Functions
+// - These functions are not included in the scope of APIs used by
+//   the core GUIslice library. Instead, these functions are used
+//   to support the operations within this driver layer.
+// =======================================================================
+
+uint16_t gslc_DrvAdaptColorToRaw(gslc_tsColor nCol);
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_DRV_ADAGFX_H_
diff --git a/src/guislice/GUIslice_ex.h b/src/guislice/GUIslice_ex.h
new file mode 100644
index 0000000..a0e18a8
--- /dev/null
+++ b/src/guislice/GUIslice_ex.h
@@ -0,0 +1,52 @@
+#ifndef _GUISLICE_EX_H_
+#define _GUISLICE_EX_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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_ex.h
+
+// Provide backwards compatibility until we have removed GUIslice_ex
+#include "XCheckbox.h"
+#include "XGauge.h"
+#include "XGraph.h"
+#include "XSelNum.h"
+#include "XSlider.h"
+#include "XTextbox.h"
+
+// Warn users that they should update their includes
+// #warning "NOTE: Please replace `GUIslice_ex` per https://github.com/ImpulseAdventure/GUIslice/wiki/Note-_-Include-Extended-Elements"
+
+
+#endif // _GUISLICE_EX_H_
+
diff --git a/src/guislice/GUIslice_th.cpp b/src/guislice/GUIslice_th.cpp
new file mode 100644
index 0000000..47e72d9
--- /dev/null
+++ b/src/guislice/GUIslice_th.cpp
@@ -0,0 +1,119 @@
+// Abstract touch handler (TH) class
+// This is the abstract base class for creating specific touch handlers 
+// The touch handler performs the adaption in between the GUIslice framework and any touch driver
+// The touch handler used is specified in the main program by calling gslc_InitTouchHandler(&touchHandler);
+
+/// \file GUIslice_th.cpp
+
+#include "GUIslice_th.h"
+
+
+///////////////////////////////////////////////////
+// Point x,y,z Class for usage in the touch handler
+
+THPoint::THPoint(void) {
+  x = y = z = 0;
+}
+
+THPoint::THPoint(uint16_t x0, uint16_t y0, uint16_t z0) {
+  x = x0;
+  y = y0;
+  z = z0;
+}
+
+bool THPoint::operator==(THPoint p1) {
+  return  ((p1.x == x) && (p1.y == y) && (p1.z == z));
+}
+
+bool THPoint::operator!=(THPoint p1) {
+  return  ((p1.x != x) || (p1.y != y) || (p1.z != z));
+}
+
+
+///////////////////////////////////////////////////
+// Abstract TouchHandler - you have to inherit this 
+
+void TouchHandler::setSize(uint16_t _disp_xSize, uint16_t _disp_ySize)
+{
+    disp_xSize = _disp_xSize;
+    disp_ySize = _disp_ySize;
+}    
+
+void TouchHandler::setCalibration(uint16_t _ts_xMin, uint16_t _ts_xMax, uint16_t _ts_yMin, uint16_t _ts_yMax)
+{
+    ts_xMin = _ts_xMin;
+    ts_xMax = _ts_xMax;
+    ts_yMin = _ts_yMin;
+    ts_yMax = _ts_yMax;
+}    
+
+void TouchHandler::setSwapFlip(bool _swapXY,bool _flipX,bool _flipY)
+{
+    swapXY = _swapXY;
+    flipX = _flipX;
+    flipY = _flipY;
+}
+
+THPoint TouchHandler::scale(THPoint pIn)
+{
+    THPoint pOut;
+    
+    pOut.x = map(pIn.x, ts_xMin,ts_xMax, 0,disp_xSize);
+    pOut.y = map(pIn.y, ts_yMin,ts_yMax, 0,disp_ySize);
+    pOut.z = pIn.z;
+
+    pOut.x = constrain(pOut.x,0,disp_xSize-1);
+    pOut.y = constrain(pOut.y,0,disp_ySize-1);
+    pOut.z = constrain(pOut.z,0,4095);
+
+    if (swapXY)
+    {
+        uint16_t x = pOut.x;
+        pOut.x = pOut.y;
+        pOut.y = x;
+    }
+
+    if (flipX)
+        pOut.x = ( (!swapXY) ? disp_xSize-1 : disp_ySize-1 ) - pOut.x;
+        
+    if (flipY)
+        pOut.y = ( (!swapXY) ? disp_ySize-1 : disp_xSize-1 ) - pOut.y;
+        
+    //Serial.print("disp_xSize= ");Serial.println(disp_xSize);
+        
+    return pOut;
+}
+
+
+// overwrite this with your code to add initialisation of the touch driver used
+void TouchHandler::begin(void) {
+   return;
+}
+
+
+// overwrite this with your code to return the scaled touch coordinates
+THPoint TouchHandler::getPoint(void) {
+   return THPoint();
+}
+
+
+/////////////////////////////////
+// init and set the touch handler 
+
+// Pointer to touch handler used by GUIslice 
+TouchHandler *pTouchHandler = NULL;  // NULL => no handler is available
+
+// Init and set the touch hander
+void gslc_InitTouchHandler(TouchHandler *pTH) {
+    //begin
+    pTH->begin();
+    //set the touch handler to be used by GUIslice_drv_...
+    pTouchHandler = pTH;
+}
+
+// Get the touch handler
+TouchHandler* gslc_getTouchHandler(void)
+{
+    return pTouchHandler;
+}
+
diff --git a/src/guislice/GUIslice_th.h b/src/guislice/GUIslice_th.h
new file mode 100644
index 0000000..a29e9e6
--- /dev/null
+++ b/src/guislice/GUIslice_th.h
@@ -0,0 +1,71 @@
+// Abstract touch handler (TH) class
+// This is the abstract base class for creating specific touch handlers 
+// The touch handler performs the adaption in between the GUIslice framework and any touch driver
+// The touch handler used is specified in the main program by calling gslc_InitTouchHandler(&touchHandler);
+
+/// \file GUIslice_th.h
+
+#ifndef _GUISLICE_TH_H_
+#define _GUISLICE_TH_H_
+
+#include <Arduino.h>
+
+///////////////////////////////////////////////////
+// Point x,y,z Class for usage in the touch handler
+
+class THPoint {
+ public:
+  THPoint(void);
+  THPoint(uint16_t x, uint16_t y, uint16_t z);
+  
+  bool operator==(THPoint);
+  bool operator!=(THPoint);
+
+  uint16_t x, y, z;
+};
+
+
+///////////////////////////////////////////////////
+// Abstract TouchHandler - you have to inherit this 
+
+class TouchHandler {
+ public:
+  //in order to create a specific touch handler you have to write your own constructor
+  TouchHandler() {};
+
+  void setSize(uint16_t _disp_xSize, uint16_t _disp_ySize);
+  void setCalibration(uint16_t ts_xMin, uint16_t ts_xMax, uint16_t ts_yMin, uint16_t ts_yMax);
+  //order of operations: map, swap, constraint, flip 
+  void setSwapFlip(bool _swapXY,bool _flipX,bool _flipY);
+
+  THPoint scale(THPoint pIn);
+  
+  //in order to create a specific touch handler you have to overwrite this methods
+  virtual void begin(void);
+  virtual THPoint getPoint(void);
+
+private:
+    //landscape perspective: x: width, y: heigth
+    uint16_t disp_xSize = 320;
+    uint16_t disp_ySize = 240;
+
+    uint16_t ts_xMin = 0;
+    uint16_t ts_xMax = 4095;
+    uint16_t ts_yMin = 0;
+    uint16_t ts_yMax = 4095;
+    
+    bool swapXY = false;    
+    bool flipX = false;    
+    bool flipY = false;    
+};
+
+
+
+/////////////////////////////////
+// init and set the touch handler 
+
+void gslc_InitTouchHandler(TouchHandler *pTHO);     
+TouchHandler* gslc_getTouchHandler(void);     
+
+
+#endif
diff --git a/src/guislice/GUIslice_th_XPT2046.h b/src/guislice/GUIslice_th_XPT2046.h
new file mode 100644
index 0000000..a74fcfc
--- /dev/null
+++ b/src/guislice/GUIslice_th_XPT2046.h
@@ -0,0 +1,52 @@
+// touch handler (TH) for XPT2046 using the arduino built in driver <XPT2046_touch.h>
+
+// The touch handler performs the adaption in between the GUIslice framework and any touch driver
+// The touch handler used is specified in the main program by calling gslc_InitTouchHandler(&touchHandler);
+
+/// \file GUIslice_th_XPT2046.h
+
+#ifndef _GUISLICE_TH_XPT2046_H_
+#define _GUISLICE_TH_XPT2046_H_
+
+#include <Arduino.h>
+#include <GUIslice_th.h>
+#include <XPT2046_touch.h>
+
+class TouchHandler_XPT2046: public TouchHandler {
+    public:
+        // parameters:
+        //   spi object to be used
+        //   chip select pin for spi
+        TouchHandler_XPT2046(SPIClass &spi, uint8_t spi_cs_pin) : spi(spi), touchDriver(XPT2046_touch(spi_cs_pin, spi)) {
+            //empirical calibration values, can be updated by calling setCalibration in the user program
+            setCalibration(398,3877,280,3805);
+            //swapping and flipping to adopt to default GUIslice orientation
+            setSwapFlip(true,false,true);
+        }            
+   
+        //begin is called by gslc_InitTouchHandler
+        void begin(void) {
+            //init the touch driver
+            touchDriver.begin();
+        }
+                   
+        //this method returns the scaled point provided by the touch driver 
+        THPoint getPoint(void) {
+            //get the coordinates from the touch driver
+            TS_Point pt = touchDriver.getPoint();
+            //Serial.print("pt= ");Serial.print(pt.x);Serial.print(",");Serial.print(pt.y);Serial.print(",");Serial.println(pt.z);
+    
+            //perform scaling (this includes swapping and flipping)
+            THPoint ps = scale( THPoint(pt.x,pt.y,pt.z) );
+            //Serial.print("ps= ");Serial.print(ps.x);Serial.print(",");Serial.print(ps.y);Serial.print(",");Serial.println(ps.z);
+            
+            return ps;
+        };
+
+      SPIClass spi; 
+      XPT2046_touch touchDriver;
+            
+};
+
+
+#endif
diff --git a/src/guislice/GUIslice_version.h b/src/guislice/GUIslice_version.h
new file mode 100644
index 0000000..8366e85
--- /dev/null
+++ b/src/guislice/GUIslice_version.h
@@ -0,0 +1,42 @@
+#ifndef _GUISLICE_VERSION_H_
+#define _GUISLICE_VERSION_H_
+
+// =======================================================================
+// GUIslice library (version control)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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.
+//
+// =======================================================================
+
+// =======================================================================
+// Define current release (X.Y.Z) & build number
+// =======================================================================
+
+#define GUISLICE_VER "0.15.0"
+
+#endif // _GUISLICE_VERSION_H_
+
diff --git a/src/guislice/NotoMono8pt7b.h b/src/guislice/NotoMono8pt7b.h
new file mode 100644
index 0000000..3021b9e
--- /dev/null
+++ b/src/guislice/NotoMono8pt7b.h
@@ -0,0 +1,185 @@
+const uint8_t NotoMono8pt7bBitmaps[] PROGMEM = {
+  0x00, 0xFF, 0xFD, 0x0F, 0xCF, 0x3C, 0xF3, 0x08, 0x86, 0x61, 0x11, 0xFF,
+  0x11, 0x0C, 0xC2, 0x23, 0xFE, 0x22, 0x08, 0x84, 0x41, 0x10, 0x10, 0x21,
+  0xFE, 0x89, 0x1A, 0x1C, 0x0E, 0x16, 0x26, 0x5F, 0xE1, 0x02, 0x00, 0x71,
+  0xA2, 0x48, 0xB2, 0x28, 0x74, 0x01, 0x00, 0x80, 0x2E, 0x14, 0x4D, 0x12,
+  0x45, 0x8E, 0x38, 0x36, 0x11, 0x08, 0x82, 0x81, 0x89, 0xE5, 0x96, 0x86,
+  0x63, 0x33, 0xCF, 0x30, 0xFF, 0x11, 0x98, 0x8C, 0x63, 0x10, 0xC6, 0x30,
+  0x86, 0x18, 0x40, 0x43, 0x0C, 0x21, 0x8C, 0x61, 0x18, 0xC6, 0x23, 0x31,
+  0x00, 0x10, 0x22, 0x4F, 0xF2, 0x8D, 0x99, 0x00, 0x10, 0x20, 0x47, 0xF1,
+  0x02, 0x04, 0x00, 0x6F, 0x60, 0xFC, 0xF0, 0x0C, 0x20, 0x86, 0x10, 0xC3,
+  0x08, 0x61, 0x04, 0x30, 0x3C, 0x66, 0x42, 0xC3, 0xC3, 0x81, 0x81, 0xC3,
+  0xC3, 0x42, 0x66, 0x3C, 0x37, 0xD1, 0x11, 0x11, 0x11, 0x11, 0x3C, 0xE3,
+  0x03, 0x01, 0x03, 0x02, 0x04, 0x08, 0x10, 0x20, 0xC0, 0xFF, 0x7E, 0xC3,
+  0x03, 0x03, 0x06, 0x38, 0x06, 0x03, 0x01, 0x03, 0x86, 0xFC, 0x06, 0x07,
+  0x02, 0x83, 0x43, 0x21, 0x11, 0x09, 0x84, 0xFF, 0x81, 0x00, 0x80, 0x40,
+  0xFE, 0xC0, 0xC0, 0x80, 0x80, 0xFC, 0x06, 0x03, 0x01, 0x03, 0x86, 0xFC,
+  0x1E, 0x30, 0x40, 0xC0, 0xFC, 0xE2, 0xC3, 0x81, 0xC1, 0xC3, 0x66, 0x3C,
+  0xFF, 0x03, 0x02, 0x02, 0x06, 0x04, 0x0C, 0x0C, 0x18, 0x18, 0x10, 0x30,
+  0x3C, 0xC3, 0x81, 0xC3, 0x46, 0x3C, 0x66, 0xC3, 0x81, 0xC3, 0xC2, 0x3C,
+  0x3C, 0x66, 0xC3, 0x83, 0x81, 0xC3, 0x47, 0x3F, 0x03, 0x02, 0x04, 0x78,
+  0xF0, 0x03, 0xC0, 0x6C, 0x00, 0x03, 0x7B, 0x00, 0x01, 0x06, 0x38, 0xE0,
+  0xE0, 0x38, 0x06, 0x01, 0xFF, 0x00, 0x00, 0x00, 0xFF, 0x80, 0x60, 0x1C,
+  0x07, 0x07, 0x1C, 0x60, 0x80, 0x7C, 0xC3, 0x03, 0x01, 0x03, 0x06, 0x18,
+  0x10, 0x30, 0x00, 0x30, 0x30, 0x1E, 0x08, 0x64, 0x09, 0x79, 0x92, 0x68,
+  0x9A, 0x26, 0x89, 0xA6, 0xF7, 0x64, 0x00, 0x80, 0x1F, 0x00, 0x0C, 0x03,
+  0x01, 0xE0, 0x48, 0x12, 0x0C, 0xC2, 0x10, 0xFC, 0x61, 0x90, 0x24, 0x0B,
+  0x03, 0xFE, 0x87, 0x83, 0x83, 0x83, 0xFC, 0x86, 0x83, 0x83, 0x83, 0x86,
+  0xFC, 0x1F, 0x73, 0x60, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0x60, 0x71,
+  0x1F, 0xF8, 0x8E, 0x82, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x86, 0x8C,
+  0xF8, 0xFF, 0x02, 0x04, 0x08, 0x1F, 0xE0, 0x40, 0x81, 0x02, 0x07, 0xF0,
+  0xFF, 0x02, 0x04, 0x08, 0x1F, 0xE0, 0x40, 0x81, 0x02, 0x04, 0x00, 0x1E,
+  0x72, 0x40, 0xC0, 0xC0, 0xC7, 0xC1, 0xC1, 0xC1, 0x41, 0x73, 0x3F, 0x81,
+  0x81, 0x81, 0x81, 0x81, 0xFF, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xFC,
+  0x82, 0x08, 0x20, 0x82, 0x08, 0x20, 0x82, 0x3F, 0x02, 0x04, 0x08, 0x10,
+  0x20, 0x40, 0x81, 0x02, 0x0E, 0x37, 0xC0, 0x81, 0xC1, 0xA1, 0x91, 0x89,
+  0x85, 0x83, 0x61, 0x18, 0x84, 0x43, 0x20, 0xD0, 0x30, 0x80, 0x80, 0x80,
+  0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xFF, 0xC3, 0xC3, 0xC3,
+  0xC3, 0xA5, 0xA5, 0xA5, 0xA5, 0x99, 0x99, 0x99, 0x91, 0xC1, 0xC1, 0xA1,
+  0xA1, 0x91, 0x91, 0x89, 0x89, 0x85, 0x85, 0x83, 0x83, 0x3C, 0x66, 0x42,
+  0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x42, 0x66, 0x3C, 0xFC, 0x86, 0x83,
+  0x83, 0x83, 0x82, 0xFC, 0x80, 0x80, 0x80, 0x80, 0x80, 0x3C, 0x66, 0x42,
+  0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x42, 0x66, 0x3C, 0x04, 0x02, 0x01,
+  0xFC, 0x43, 0x20, 0xD0, 0x68, 0x34, 0x13, 0xF1, 0x18, 0x86, 0x41, 0x20,
+  0xD0, 0x30, 0x3F, 0xE3, 0xC0, 0xC0, 0xC0, 0x78, 0x0E, 0x03, 0x01, 0x03,
+  0x86, 0xFC, 0xFF, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+  0x10, 0x10, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xC3, 0xC3,
+  0x66, 0x3C, 0xC0, 0xD0, 0x24, 0x09, 0x86, 0x21, 0x08, 0x43, 0x30, 0x48,
+  0x12, 0x07, 0x80, 0xC0, 0x30, 0x80, 0x70, 0x1C, 0x0F, 0x03, 0x4C, 0x93,
+  0x24, 0xC9, 0x4A, 0x52, 0x94, 0xA6, 0x18, 0x84, 0xC0, 0xD8, 0x62, 0x10,
+  0xCC, 0x1E, 0x03, 0x00, 0xC0, 0x78, 0x33, 0x08, 0x44, 0x1B, 0x03, 0xC0,
+  0x90, 0x66, 0x10, 0x88, 0x12, 0x05, 0x00, 0xC0, 0x20, 0x08, 0x02, 0x00,
+  0x80, 0x20, 0xFF, 0x03, 0x02, 0x04, 0x0C, 0x08, 0x10, 0x30, 0x20, 0x40,
+  0xC0, 0xFF, 0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0xF0, 0xC1, 0x04,
+  0x18, 0x20, 0xC3, 0x04, 0x18, 0x20, 0x83, 0xF1, 0x11, 0x11, 0x11, 0x11,
+  0x11, 0x11, 0xF0, 0x18, 0x18, 0x24, 0x24, 0x46, 0x42, 0x83, 0xFF, 0xC0,
+  0xC8, 0x80, 0x7E, 0x43, 0x03, 0x01, 0x3F, 0xC1, 0x83, 0xC7, 0x7D, 0x80,
+  0x80, 0x80, 0x80, 0xBC, 0xE6, 0xC3, 0x83, 0x81, 0x83, 0xC3, 0xE6, 0xBC,
+  0x3F, 0x61, 0xC0, 0xC0, 0x80, 0xC0, 0xC0, 0x61, 0x3F, 0x01, 0x01, 0x01,
+  0x01, 0x3D, 0x67, 0xC3, 0xC1, 0x81, 0xC1, 0xC3, 0x67, 0x3D, 0x3C, 0x66,
+  0xC3, 0xC1, 0xFF, 0x80, 0xC0, 0x61, 0x3E, 0x1E, 0x60, 0x81, 0x0F, 0xC4,
+  0x08, 0x10, 0x20, 0x40, 0x81, 0x02, 0x00, 0x3F, 0xB1, 0x90, 0x48, 0x26,
+  0x31, 0xF1, 0x80, 0x80, 0x7F, 0x60, 0xE0, 0x38, 0x37, 0xE0, 0x80, 0x80,
+  0x80, 0x80, 0xBE, 0xE3, 0xC3, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x10,
+  0x20, 0x00, 0x07, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x8F, 0xE0, 0x0C,
+  0x30, 0x00, 0x7C, 0x10, 0x41, 0x04, 0x10, 0x41, 0x04, 0x10, 0x43, 0xF8,
+  0x80, 0x80, 0x80, 0x80, 0x84, 0x88, 0x90, 0xA0, 0xE0, 0x90, 0x88, 0x84,
+  0x86, 0x70, 0x20, 0x40, 0x81, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x8F,
+  0xE0, 0xB6, 0xDB, 0xD9, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0xBE, 0xE3,
+  0xC3, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x3C, 0x66, 0xC3, 0xC3, 0x81,
+  0xC3, 0xC3, 0x66, 0x3C, 0xBC, 0xE6, 0xC3, 0x83, 0x81, 0x83, 0xC3, 0xE6,
+  0xBC, 0x80, 0x80, 0x80, 0x80, 0x3D, 0x67, 0xC3, 0xC1, 0x81, 0xC1, 0xC3,
+  0x67, 0x3D, 0x01, 0x01, 0x01, 0x01, 0x9F, 0x47, 0x04, 0x08, 0x10, 0x20,
+  0x40, 0x80, 0x7F, 0x18, 0x38, 0x38, 0x30, 0x63, 0xF8, 0x20, 0x43, 0xF9,
+  0x02, 0x04, 0x08, 0x10, 0x20, 0x60, 0x78, 0x81, 0x81, 0x81, 0x81, 0x81,
+  0x81, 0xC3, 0xC7, 0x7D, 0xC3, 0x42, 0x42, 0x66, 0x24, 0x24, 0x3C, 0x18,
+  0x18, 0x8C, 0x73, 0x34, 0xC9, 0x7A, 0x52, 0x94, 0xA5, 0x28, 0x8C, 0x21,
+  0x00, 0x43, 0x66, 0x24, 0x18, 0x18, 0x3C, 0x24, 0x66, 0xC3, 0xC3, 0x42,
+  0x42, 0x66, 0x24, 0x24, 0x3C, 0x18, 0x18, 0x18, 0x10, 0x30, 0xE0, 0xFC,
+  0x30, 0x84, 0x30, 0x84, 0x30, 0xFC, 0x1C, 0xC2, 0x08, 0x20, 0x82, 0x30,
+  0x60, 0x82, 0x08, 0x20, 0xC1, 0xC0, 0xFF, 0xFF, 0x80, 0xE0, 0xC1, 0x04,
+  0x10, 0x41, 0x03, 0x18, 0x41, 0x04, 0x10, 0xCE, 0x00, 0x70, 0x99, 0x0E };
+
+const GFXglyph NotoMono8pt7bGlyphs[] PROGMEM = {
+  {     0,   1,   1,  10,    0,    0 },   // 0x20 ' '
+  {     1,   2,  12,  10,    4,  -11 },   // 0x21 '!'
+  {     4,   6,   4,  10,    2,  -11 },   // 0x22 '"'
+  {     7,  10,  12,  10,    0,  -11 },   // 0x23 '#'
+  {    22,   7,  14,  10,    2,  -12 },   // 0x24 '$'
+  {    35,  10,  12,  10,    0,  -11 },   // 0x25 '%'
+  {    50,   9,  12,  10,    1,  -11 },   // 0x26 '&'
+  {    64,   2,   4,  10,    4,  -11 },   // 0x27 '''
+  {    65,   5,  15,  10,    3,  -11 },   // 0x28 '('
+  {    75,   5,  15,  10,    2,  -11 },   // 0x29 ')'
+  {    85,   7,   7,  10,    1,  -12 },   // 0x2A '*'
+  {    92,   7,   7,  10,    1,   -8 },   // 0x2B '+'
+  {    99,   3,   4,  10,    3,   -1 },   // 0x2C ','
+  {   101,   6,   1,  10,    2,   -4 },   // 0x2D '-'
+  {   102,   2,   2,  10,    4,   -1 },   // 0x2E '.'
+  {   103,   6,  12,  10,    2,  -11 },   // 0x2F '/'
+  {   112,   8,  12,  10,    1,  -11 },   // 0x30 '0'
+  {   124,   4,  12,  10,    2,  -11 },   // 0x31 '1'
+  {   130,   8,  12,  10,    1,  -11 },   // 0x32 '2'
+  {   142,   8,  12,  10,    1,  -11 },   // 0x33 '3'
+  {   154,   9,  12,  10,    1,  -11 },   // 0x34 '4'
+  {   168,   8,  12,  10,    1,  -11 },   // 0x35 '5'
+  {   180,   8,  12,  10,    1,  -11 },   // 0x36 '6'
+  {   192,   8,  12,  10,    1,  -11 },   // 0x37 '7'
+  {   204,   8,  12,  10,    1,  -11 },   // 0x38 '8'
+  {   216,   8,  12,  10,    1,  -11 },   // 0x39 '9'
+  {   228,   2,   9,  10,    4,   -8 },   // 0x3A ':'
+  {   231,   3,  11,  10,    3,   -8 },   // 0x3B ';'
+  {   236,   8,   8,  10,    1,   -9 },   // 0x3C '<'
+  {   244,   8,   5,  10,    1,   -7 },   // 0x3D '='
+  {   249,   8,   8,  10,    1,   -9 },   // 0x3E '>'
+  {   257,   8,  12,  10,    1,  -11 },   // 0x3F '?'
+  {   269,  10,  13,  10,    0,  -11 },   // 0x40 '@'
+  {   286,  10,  12,  10,    0,  -11 },   // 0x41 'A'
+  {   301,   8,  12,  10,    1,  -11 },   // 0x42 'B'
+  {   313,   8,  12,  10,    1,  -11 },   // 0x43 'C'
+  {   325,   8,  12,  10,    1,  -11 },   // 0x44 'D'
+  {   337,   7,  12,  10,    2,  -11 },   // 0x45 'E'
+  {   348,   7,  12,  10,    2,  -11 },   // 0x46 'F'
+  {   359,   8,  12,  10,    1,  -11 },   // 0x47 'G'
+  {   371,   8,  12,  10,    1,  -11 },   // 0x48 'H'
+  {   383,   6,  12,  10,    2,  -11 },   // 0x49 'I'
+  {   392,   7,  12,  10,    1,  -11 },   // 0x4A 'J'
+  {   403,   9,  12,  10,    1,  -11 },   // 0x4B 'K'
+  {   417,   8,  12,  10,    1,  -11 },   // 0x4C 'L'
+  {   429,   8,  12,  10,    1,  -11 },   // 0x4D 'M'
+  {   441,   8,  12,  10,    1,  -11 },   // 0x4E 'N'
+  {   453,   8,  12,  10,    1,  -11 },   // 0x4F 'O'
+  {   465,   8,  12,  10,    1,  -11 },   // 0x50 'P'
+  {   477,   8,  15,  10,    1,  -11 },   // 0x51 'Q'
+  {   492,   9,  12,  10,    1,  -11 },   // 0x52 'R'
+  {   506,   8,  12,  10,    1,  -11 },   // 0x53 'S'
+  {   518,   8,  12,  10,    1,  -11 },   // 0x54 'T'
+  {   530,   8,  12,  10,    1,  -11 },   // 0x55 'U'
+  {   542,  10,  12,  10,    0,  -11 },   // 0x56 'V'
+  {   557,  10,  12,  10,    0,  -11 },   // 0x57 'W'
+  {   572,  10,  12,  10,    0,  -11 },   // 0x58 'X'
+  {   587,  10,  12,  10,    0,  -11 },   // 0x59 'Y'
+  {   602,   8,  12,  10,    1,  -11 },   // 0x5A 'Z'
+  {   614,   4,  15,  10,    4,  -11 },   // 0x5B '['
+  {   622,   6,  12,  10,    2,  -11 },   // 0x5C '\'
+  {   631,   4,  15,  10,    2,  -11 },   // 0x5D ']'
+  {   639,   8,   7,  10,    1,  -11 },   // 0x5E '^'
+  {   646,  10,   1,  10,    0,    2 },   // 0x5F '_'
+  {   648,   3,   3,  10,    4,  -12 },   // 0x60 '`'
+  {   650,   8,   9,  10,    1,   -8 },   // 0x61 'a'
+  {   659,   8,  13,  10,    1,  -12 },   // 0x62 'b'
+  {   672,   8,   9,  10,    1,   -8 },   // 0x63 'c'
+  {   681,   8,  13,  10,    1,  -12 },   // 0x64 'd'
+  {   694,   8,   9,  10,    1,   -8 },   // 0x65 'e'
+  {   703,   7,  13,  10,    2,  -12 },   // 0x66 'f'
+  {   715,   9,  13,  10,    0,   -8 },   // 0x67 'g'
+  {   730,   8,  13,  10,    1,  -12 },   // 0x68 'h'
+  {   743,   7,  13,  10,    1,  -12 },   // 0x69 'i'
+  {   755,   6,  17,  10,    1,  -12 },   // 0x6A 'j'
+  {   768,   8,  13,  10,    2,  -12 },   // 0x6B 'k'
+  {   781,   7,  13,  10,    1,  -12 },   // 0x6C 'l'
+  {   793,   8,   9,  10,    1,   -8 },   // 0x6D 'm'
+  {   802,   8,   9,  10,    1,   -8 },   // 0x6E 'n'
+  {   811,   8,   9,  10,    1,   -8 },   // 0x6F 'o'
+  {   820,   8,  13,  10,    1,   -8 },   // 0x70 'p'
+  {   833,   8,  13,  10,    1,   -8 },   // 0x71 'q'
+  {   846,   7,   9,  10,    2,   -8 },   // 0x72 'r'
+  {   854,   6,   9,  10,    2,   -8 },   // 0x73 's'
+  {   861,   7,  11,  10,    2,  -10 },   // 0x74 't'
+  {   871,   8,   9,  10,    1,   -8 },   // 0x75 'u'
+  {   880,   8,   9,  10,    1,   -8 },   // 0x76 'v'
+  {   889,  10,   9,  10,    0,   -8 },   // 0x77 'w'
+  {   901,   8,   9,  10,    1,   -8 },   // 0x78 'x'
+  {   910,   8,  13,  10,    1,   -8 },   // 0x79 'y'
+  {   923,   6,   9,  10,    2,   -8 },   // 0x7A 'z'
+  {   930,   6,  15,  10,    2,  -11 },   // 0x7B '{'
+  {   942,   1,  17,  10,    4,  -12 },   // 0x7C '|'
+  {   945,   6,  15,  10,    2,  -11 },   // 0x7D '}'
+  {   957,   8,   3,  10,    1,   -6 } }; // 0x7E '~'
+
+const GFXfont NotoMono8pt7b PROGMEM = {
+  (uint8_t  *)NotoMono8pt7bBitmaps,
+  (GFXglyph *)NotoMono8pt7bGlyphs,
+  0x20, 0x7E, 18 };
+
+// Approx. 1632 bytes
diff --git a/src/guislice/XCheckbox.c b/src/guislice/XCheckbox.c
new file mode 100644
index 0000000..9802e2b
--- /dev/null
+++ b/src/guislice/XCheckbox.c
@@ -0,0 +1,517 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XCheckbox.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XCheckbox.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+// Extended Element: Checkbox
+// - Checkbox with custom handler for touch tracking which
+//   enables glow to be defined whenever touch is tracked over
+//   the element.
+// ============================================================================
+
+// Create a checkbox element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXCheckboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXCheckbox* pXData,gslc_tsRect rElem,bool bRadio,gslc_teXCheckboxStyle nStyle,
+  gslc_tsColor colCheck,bool bChecked)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXCheckboxCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_CHECKBOX,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  // Default group assignment. Can override later with ElemSetGroup()
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Define other extended data
+  pXData->bRadio          = bRadio;
+  pXData->bChecked        = bChecked;
+  pXData->colCheck        = colCheck;
+  pXData->nStyle          = nStyle;
+  pXData->pfuncXToggle    = NULL;
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXCheckboxDraw;
+  // Specify the custom touch tracking callback
+  // - NOTE: This is optional (and can be set to NULL).
+  //   See the discussion under gslc_ElemXCheckboxTouch()
+  sElem.pfuncXTouch       = &gslc_ElemXCheckboxTouch;
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+bool gslc_ElemXCheckboxGetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return false;
+
+  return pCheckbox->bChecked;
+}
+
+
+// Determine which checkbox in the group has been "checked"
+gslc_tsElemRef* gslc_ElemXCheckboxFindChecked(gslc_tsGui* pGui,int16_t nGroupId)
+{
+  int16_t             nCurInd;
+  gslc_tsElemRef*     pCurElemRef = NULL;
+  gslc_tsElem*        pCurElem = NULL;
+  int16_t             nCurType;
+  int16_t             nCurGroup;
+  bool                bCurChecked;
+  gslc_tsElemRef*     pFoundElemRef = NULL;
+
+  // Operate on current page
+  // TODO: Support other page layers
+  gslc_tsPage* pPage = pGui->apPageStack[GSLC_STACK_CUR];
+  if (pPage == NULL) {
+    return NULL; // No page added yet
+  }
+
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXCheckboxFindChecked";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+  for (nCurInd=0;nCurInd<pCollect->nElemCnt;nCurInd++) {
+    // Fetch extended data
+    pCurElemRef   = &(pCollect->asElemRef[nCurInd]);
+    pCurElem      = gslc_GetElemFromRef(pGui,pCurElemRef);
+    nCurType      = pCurElem->nType;
+    // Only want to proceed if it is a checkbox
+    if (nCurType != GSLC_TYPEX_CHECKBOX) {
+      continue;
+    }
+
+    nCurGroup     = pCurElem->nGroup;
+    bCurChecked   = gslc_ElemXCheckboxGetState(pGui,pCurElemRef);
+
+    // If this is in a different group, ignore it
+    if (nCurGroup != nGroupId) {
+      continue;
+    }
+
+    // Did we find an element in the group that was checked?
+    if (bCurChecked) {
+      pFoundElemRef = pCurElemRef;
+      break;
+    }
+  } // nCurInd
+  return pFoundElemRef;
+}
+
+// Assign the callback function for checkbox/radio state change events
+void gslc_ElemXCheckboxSetStateFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_XCHECKBOX pfuncCb)
+{
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return;
+
+  pCheckbox->pfuncXToggle = pfuncCb;
+}
+
+// Helper routine for gslc_ElemXCheckboxSetState()
+// - Updates the checkbox/radio control's state but does
+//   not touch any other controls in the group
+void gslc_ElemXCheckboxSetStateHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bChecked,bool bDoCb)
+{
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return;
+
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Update our data element
+  bool const bCheckedOld = pCheckbox->bChecked;
+  pCheckbox->bChecked = bChecked;
+
+  // Element needs redraw
+  if (bChecked != bCheckedOld) {
+    // Only need an incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  } else {
+    // Same state as before
+    // - No need to do anything further since we don't need to
+    //   trigger any callbacks or redraw
+    return;
+  }
+
+  // If no callbacks requested, exit now
+  if (!bDoCb) {
+    return;
+  }
+
+  // If any state callback is defined, call it now
+  // - In all cases, return the ElementRef of the element that issued the callback
+  //
+  // For checkbox:
+  // - If not selected:  return current ID  and state=false
+  // - If     selected:  return current ID  and state=true
+  // For radio button:
+  // - If none selected: return ID_NONE     and state=false
+  // - If one  selected: return selected ID and state=true
+  if (pCheckbox->pfuncXToggle != NULL) {
+    gslc_tsElemRef* pRetRef = NULL;
+    int16_t nGroup = GSLC_GROUP_ID_NONE;
+    int16_t nSelId = GSLC_ID_NONE;
+    if (!pCheckbox->bRadio) {
+      // Checkbox
+      nSelId = pElem->nId;
+    } else {
+      // Radio button
+      // - Determine the group that the radio button belongs to
+      nGroup = pElem->nGroup;
+      // Determine if any radio button in the group has been selected
+      pRetRef = gslc_ElemXCheckboxFindChecked(pGui, nGroup);
+      if (pRetRef != NULL) {
+        // One has been selected, return its ID
+        bChecked = true;
+        nSelId = pRetRef->pElem->nId;
+      } else {
+        // No radio button selected, return ID NONE
+        bChecked = false;
+        nSelId = GSLC_ID_NONE;
+      }
+    }
+    // Now send the callback notification
+    (*pCheckbox->pfuncXToggle)((void*)(pGui), (void*)(pElemRef), nSelId, bChecked);
+  } // pfuncXToggle
+
+}
+
+// Update the checkbox/radio control's state. If it is a radio button
+// then also update the state of all other buttons in the group.
+void gslc_ElemXCheckboxSetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bChecked)
+{
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return;
+
+
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsPage* pPage = NULL;
+
+  bool                bRadio    = pCheckbox->bRadio;
+  int16_t             nGroup    = pElem->nGroup;
+  int16_t             nElemId   = pElem->nId;
+
+  // Special handling when we select a radio button
+  if (bRadio && bChecked) {
+
+    // If we are selecting a radio button that is already
+    // selected, then skip further update events.
+    // NOTE: This check is not very efficient, but it avoids
+    // the creation of extra events.
+    gslc_tsElemRef* pTmpRef = gslc_ElemXCheckboxFindChecked(pGui, nGroup);
+    if (pTmpRef == pElemRef) {
+      // Same element, so skip
+      return;
+    }
+
+    // Proceed to deselect any other selected items in the group.
+    // Note that SetState calls itself to deselect other items so it
+    // is important to qualify this logic with bChecked=true
+    int16_t           nCurInd;
+    int16_t           nCurId;
+    gslc_tsElem*      pCurElem = NULL;
+    gslc_tsElemRef*   pCurElemRef = NULL;
+    int16_t           nCurType;
+    int16_t           nCurGroup;
+
+    // We use the GUI pointer for access to other elements
+
+    // Check all pages in case we are affecting radio buttons on other pages
+    for (int8_t nPageInd=0;nPageInd<pGui->nPageCnt;nPageInd++) {
+      pPage = &pGui->asPage[nPageInd];
+      if (!pPage) {
+        // If this stack page is not enabled, skip to next stack page
+        continue;
+      }
+
+      gslc_tsCollect* pCollect = &pPage->sCollect;
+      for (nCurInd=0;nCurInd<pCollect->nElemRefCnt;nCurInd++) {
+        // Fetch extended data
+        pCurElemRef   = &pCollect->asElemRef[nCurInd];
+        pCurElem      = gslc_GetElemFromRef(pGui,pCurElemRef);
+
+        // FIXME: Handle pCurElemRef->eElemFlags
+        nCurId        = pCurElem->nId;
+        nCurType      = pCurElem->nType;
+
+        // Only want to proceed if it is a checkbox
+        if (nCurType != GSLC_TYPEX_CHECKBOX) {
+          continue;
+        }
+
+        nCurGroup     = pCurElem->nGroup;
+
+        // If this is in a different group, ignore it
+        if (nCurGroup != nGroup) {
+          continue;
+        }
+
+        // Is this our element? If so, ignore the deselect operation
+        if (nCurId == nElemId) {
+          continue;
+        }
+
+        // Deselect all other elements
+        // - But don't trigger any callbacks
+        gslc_ElemXCheckboxSetStateHelp(pGui,pCurElemRef,false,false);
+
+      } // nInd
+    } // nStackPage
+
+  } // bRadio
+
+  // Set the state of the current element
+  // - Trigger callback if enabled
+  gslc_ElemXCheckboxSetStateHelp(pGui,pElemRef,bChecked,true);
+}
+
+// Toggle the checkbox control's state
+void gslc_ElemXCheckboxToggleState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXCheckboxToggleState";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  // Update the data element
+  bool bCheckNew = (gslc_ElemXCheckboxGetState(pGui,pElemRef))? false : true;
+  gslc_ElemXCheckboxSetState(pGui,pElemRef,bCheckNew);
+
+  // Element needs redraw
+  // - Only incremental is needed
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+// Redraw the checkbox
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXCheckboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return false;
+
+  gslc_tsElem*    pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsRect     rInner;
+
+  bool bChecked  = pCheckbox->bChecked;
+  gslc_teXCheckboxStyle   nStyle = pCheckbox->nStyle;
+  bool bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+
+  // Draw the background
+  gslc_DrawFillRect(pGui,pElem->rElem,pElem->colElemFill);
+
+  // Generic coordinate calcs
+  int16_t nX0,nY0,nX1,nY1,nMidX,nMidY;
+  nX0 = pElem->rElem.x;
+  nY0 = pElem->rElem.y;
+  nX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nMidX = (nX0+nX1)/2;
+  nMidY = (nY0+nY1)/2;
+  if (nStyle == GSLCX_CHECKBOX_STYLE_BOX) {
+    // Draw the center indicator if checked
+    rInner = gslc_ExpandRect(pElem->rElem,-5,-5);
+    if (bChecked) {
+      // If checked, fill in the inner region
+      gslc_DrawFillRect(pGui,rInner,pCheckbox->colCheck);
+    } else {
+      // Assume the background fill has already been done so
+      // we don't need to do anything more in the unchecked case
+    }
+    // Draw a frame around the checkbox
+    gslc_DrawFrameRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFrameGlow:pElem->colElemFrame);
+
+  } else if (nStyle == GSLCX_CHECKBOX_STYLE_X) {
+    // Draw an X through center if checked
+    if (bChecked) {
+      gslc_DrawLine(pGui,nX0,nY0,nX1,nY1,pCheckbox->colCheck);
+      gslc_DrawLine(pGui,nX0,nY1,nX1,nY0,pCheckbox->colCheck);
+    }
+    // Draw a frame around the checkbox
+    gslc_DrawFrameRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFrameGlow:pElem->colElemFrame);
+
+  } else if (nStyle == GSLCX_CHECKBOX_STYLE_ROUND) {
+    // Draw inner circle if checked
+    if (bChecked) {
+      gslc_DrawFillCircle(pGui,nMidX,nMidY,5,pCheckbox->colCheck);
+    }
+    // Draw a frame around the checkbox
+    gslc_DrawFrameCircle(pGui,nMidX,nMidY,(pElem->rElem.w/2),(bGlow)?pElem->colElemFrameGlow:pElem->colElemFrame);
+
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+// - NOTE: Adding this touch callback is optional. Without it, we
+//   can still have a functional checkbox, but doing the touch
+//   tracking allows us to change the glow state of the element
+//   dynamically, as well as updating the checkbox state if the
+//   user releases over it (ie. a click event).
+//
+bool gslc_ElemXCheckboxTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXCheckbox* pCheckbox = (gslc_tsXCheckbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_CHECKBOX, __LINE__);
+  if (!pCheckbox) return false;
+
+  //gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  bool  bRadio      = pCheckbox->bRadio;
+  bool  bCheckedOld = pCheckbox->bChecked;
+  bool  bGlowingOld = gslc_ElemGetGlow(pGui,pElemRef);
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_DOWN_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+
+    case GSLC_TOUCH_MOVE_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+    case GSLC_TOUCH_MOVE_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_UP_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      // Now that we released on element, update the state
+      bool  bCheckNew;
+      if (bRadio) {
+        // Radio button action: set
+        bCheckNew = true;
+      } else {
+        // Checkbox button action: toggle
+        bCheckNew = (pCheckbox->bChecked)?false:true;
+      }
+      gslc_ElemXCheckboxSetState(pGui,pElemRef,bCheckNew);
+      break;
+    case GSLC_TOUCH_UP_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    default:
+      return false;
+      break;
+  }
+
+  // If the checkbox changed state, redraw
+  bool  bChanged = false;
+  if (gslc_ElemGetGlow(pGui,pElemRef) != bGlowingOld) { bChanged = true; }
+  if (pCheckbox->bChecked != bCheckedOld) { bChanged = true; }
+  if (bChanged) {
+    // Incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+// ============================================================================
diff --git a/src/guislice/XCheckbox.h b/src/guislice/XCheckbox.h
new file mode 100644
index 0000000..90a557d
--- /dev/null
+++ b/src/guislice/XCheckbox.h
@@ -0,0 +1,290 @@
+#ifndef _GUISLICE_EX_XCHECKBOX_H_
+#define _GUISLICE_EX_XCHECKBOX_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Checkbox/Radio button control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XCheckbox.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// ============================================================================
+// Extended Element: Checkbox
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_CHECKBOX GSLC_TYPE_BASE_EXTEND + 1
+
+/// Checkbox drawing style
+typedef enum {
+  GSLCX_CHECKBOX_STYLE_BOX,                 ///< Inner box
+  GSLCX_CHECKBOX_STYLE_X,                   ///< Crossed
+  GSLCX_CHECKBOX_STYLE_ROUND,               ///< Circular
+} gslc_teXCheckboxStyle;
+
+/// Callback function for checkbox/radio element state change
+/// - nSelId:   Selected element's ID or GSLC_ID_NONE
+/// - bChecked: Element was selected if true, false otherwise
+typedef bool (*GSLC_CB_XCHECKBOX)(void* pvGui,void* pvElemRef,int16_t nSelId, bool bChecked);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Checkbox element
+typedef struct {
+  bool                        bRadio;       ///< Radio-button operation if true
+  gslc_teXCheckboxStyle       nStyle;       ///< Drawing style for element
+  bool                        bChecked;     ///< Indicates if it is selected (checked)
+  gslc_tsColor                colCheck;     ///< Color of checked inner fill
+  GSLC_CB_XCHECKBOX           pfuncXToggle; ///< Callback event to say element has changed
+} gslc_tsXCheckbox;
+
+
+///
+/// Create a Checkbox or Radio button Element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining checkbox size
+/// \param[in]  bRadio:      Radio-button functionality if true
+/// \param[in]  nStyle:      Drawing style for checkbox / radio button
+/// \param[in]  colCheck:    Color for inner fill when checked
+/// \param[in]  bChecked:    Default state
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXCheckboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXCheckbox* pXData,gslc_tsRect rElem,bool bRadio,
+  gslc_teXCheckboxStyle nStyle,gslc_tsColor colCheck,bool bChecked);
+
+
+///
+/// Get a Checkbox element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current state
+///
+bool gslc_ElemXCheckboxGetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Set a Checkbox element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bChecked:    New state
+///
+/// \return none
+///
+void gslc_ElemXCheckboxSetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bChecked);
+
+///
+/// Find the checkbox within a group that has been checked
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nGroupId:    Group ID to search
+///
+/// \return Element Ptr or NULL if none checked
+///
+gslc_tsElemRef* gslc_ElemXCheckboxFindChecked(gslc_tsGui* pGui,int16_t nGroupId);
+
+///
+/// Toggle a Checkbox element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return none
+///
+void gslc_ElemXCheckboxToggleState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Assign the state callback function for a checkbox/radio button
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  pfuncCb:     Function pointer to callback routine (or NULL for none)
+///
+/// \return none
+///
+void gslc_ElemXCheckboxSetStateFunc(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_XCHECKBOX pfuncCb);
+
+///
+/// Draw a Checkbox element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \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]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXCheckboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Checkbox element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \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
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXCheckboxTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXCheckboxCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,nGroup,bRadio_,nStyle_,colCheck_,bChecked_)
+///
+/// Create a Checkbox or Radio button Element in Flash
+///
+/// \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]  colFill:     Color for the control background fill
+/// \param[in]  bFillEn:     True if background filled, false otherwise (recommend True)
+/// \param[in]  nGroup:      Group ID that radio buttons belong to (else GSLC_GROUP_NONE)
+/// \param[in]  bRadio_:     Radio-button functionality if true
+/// \param[in]  nStyle_:     Drawing style for checkbox / radio button
+/// \param[in]  colCheck_:   Color for inner fill when checked
+/// \param[in]  bChecked_:   Default state
+///
+/// \return none
+///
+
+#if (GSLC_USE_PROGMEM)
+
+#define gslc_ElemXCheckboxCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFill,bFillEn,nGroup,bRadio_,nStyle_,colCheck_,bChecked_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static gslc_tsXCheckbox sCheckbox##nElemId;                     \
+  sCheckbox##nElemId.bRadio = bRadio_;                            \
+  sCheckbox##nElemId.bChecked = bChecked_;                        \
+  sCheckbox##nElemId.colCheck = colCheck_;                        \
+  sCheckbox##nElemId.nStyle = nStyle_;                            \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_CHECKBOX,                                        \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      nGroup,                                                     \
+      GSLC_COL_GRAY,colFill,GSLC_COL_WHITE,GSLC_COL_BLACK, \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sCheckbox##nElemId),                               \
+      NULL,                                                       \
+      &gslc_ElemXCheckboxDraw,                                    \
+      &gslc_ElemXCheckboxTouch,                                   \
+      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_ElemXCheckboxCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,colFill,bFillEn,nGroup,bRadio_,nStyle_,colCheck_,bChecked_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | (bFillEn?GSLC_ELEM_FEA_FILL_EN:0); \
+  static gslc_tsXCheckbox sCheckbox##nElemId;                     \
+  sCheckbox##nElemId.bRadio = bRadio_;                            \
+  sCheckbox##nElemId.bChecked = bChecked_;                        \
+  sCheckbox##nElemId.colCheck = colCheck_;                        \
+  sCheckbox##nElemId.nStyle = nStyle_;                            \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_CHECKBOX,                                        \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      nGroup,                                                     \
+      GSLC_COL_GRAY,colFill,GSLC_COL_WHITE,GSLC_COL_BLACK, \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sCheckbox##nElemId),                               \
+      NULL,                                                       \
+      &gslc_ElemXCheckboxDraw,                                    \
+      &gslc_ElemXCheckboxTouch,                                   \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XCHECKBOX_H_
+
diff --git a/src/guislice/XGauge.c b/src/guislice/XGauge.c
new file mode 100644
index 0000000..cd2dfd3
--- /dev/null
+++ b/src/guislice/XGauge.c
@@ -0,0 +1,699 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XGauge.c
+
+// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
+// WARNING: The XGauge element has been replaced by XProgress / XRadial / XRamp
+//          Please update your code according to the migration notes in:
+//          https://github.com/ImpulseAdventure/GUIslice/pull/157
+//          XGauge may be removed in a future release.
+// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XGauge.h"
+
+#include <stdio.h>
+
+#include <math.h>   // For sin/cos in XGauge(RADIAL)
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Gauge
+// - Basic progress bar with support for positive/negative state
+//   and vertical / horizontal orientation.
+// ============================================================================
+
+// Create a gauge element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXGaugeCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXGauge* pXData,gslc_tsRect rElem,
+  int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_GAUGE,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;  // Element is not "clickable"
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->nMin            = nMin;
+  pXData->nMax            = nMax;
+  pXData->nVal            = nVal;
+  pXData->nStyle          = GSLCX_GAUGE_STYLE_PROG_BAR;  // Default to progress bar
+  pXData->bVert           = bVert;
+  pXData->bFlip           = false;
+  pXData->colGauge        = colGauge;
+  pXData->colTick         = GSLC_COL_GRAY;
+  pXData->nTickCnt        = 8;
+  pXData->nTickLen        = 5;
+  pXData->nIndicLen       = 10;     // Dummy default to be overridden
+  pXData->nIndicTip       = 3;      // Dummy default to be overridden
+  pXData->bIndicFill      = false;
+  sElem.pXData            = (void*)(pXData);
+  sElem.pfuncXDraw        = &gslc_ElemXGaugeDraw;
+  sElem.pfuncXTouch       = NULL;           // No need to track touches
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  GSLC_DEBUG_PRINT("NOTE: XGauge has been replaced by XProgress/XRadial/XRamp\n","");
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void gslc_ElemXGaugeSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teXGaugeStyle nStyle)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeSetStyle";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  // Update the type element
+  pGauge->nStyle = nStyle;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXGaugeSetIndicator(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colGauge,
+    uint16_t nIndicLen,uint16_t nIndicTip,bool bIndicFill)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeSetIndicator";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  // Update the config
+  pGauge->colGauge    = colGauge;
+  pGauge->nIndicLen   = nIndicLen;
+  pGauge->nIndicTip   = nIndicTip;
+  pGauge->bIndicFill  = bIndicFill;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXGaugeSetTicks(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colTick,uint16_t nTickCnt,uint16_t nTickLen)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeSetTicks";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  // Update the config
+  pGauge->colTick   = colTick;
+  pGauge->nTickCnt  = nTickCnt;
+  pGauge->nTickLen  = nTickLen;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+// Update the gauge control's current position
+void gslc_ElemXGaugeUpdate(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeUpdate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  // Update the data element
+  int16_t nValOld = pGauge->nVal;
+  pGauge->nVal = nVal;
+
+  // Element needs redraw
+  if (nVal != nValOld) {
+    // We only need an incremental redraw
+    // NOTE: If the user configures the indicator to be
+    //       long enough that it overlaps some of the gauge indicators
+    //       then a full redraw should be done instead.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+// Update the gauge's fill direction
+// - Setting bFlip causes the gauge to be filled in the reverse direction
+//   to the default
+// - Default fill direction for horizontal gauges: left-to-right
+// - Default fill direction for vertical gauges: bottom-to-top
+void gslc_ElemXGaugeSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeSetFlip";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Fetch the element's extended data structure
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+  if (pGauge == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXGaugeSetFlip(%s) pXData is NULL\n","");
+    return;
+  }
+  pGauge->bFlip = bFlip;
+
+  // Mark for redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+
+// Redraw the gauge
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXGaugeDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGaugeDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXGauge* pGauge;
+  pGauge = (gslc_tsXGauge*)(pElem->pXData);
+  if (pGauge == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXGaugeDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  switch (pGauge->nStyle) {
+    case GSLCX_GAUGE_STYLE_PROG_BAR:
+      gslc_ElemXGaugeDrawProgressBar(pGui,pElemRef,eRedraw);
+      break;
+    case GSLCX_GAUGE_STYLE_RADIAL:
+#if (GSLC_FEATURE_XGAUGE_RADIAL)
+      gslc_ElemXGaugeDrawRadial(pGui,pElemRef,eRedraw);
+#endif
+      break;
+    case GSLCX_GAUGE_STYLE_RAMP:
+#if (GSLC_FEATURE_XGAUGE_RAMP)
+      gslc_ElemXGaugeDrawRamp(pGui,pElemRef,eRedraw);
+#endif
+      break;
+    default:
+      // ERROR
+      break;
+  }
+
+  // Save as "last state" to support incremental erase/redraw
+  pGauge->nValLast      = pGauge->nVal;
+  pGauge->bValLastValid = true;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+bool gslc_ElemXGaugeDrawProgressBar(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  gslc_tsRect   rTmp;           // Temporary rect for drawing
+  gslc_tsRect   rGauge;         // Filled portion of gauge
+  gslc_tsRect   rEmpty;         // Empty portion of gauge
+  uint16_t      nElemW,nElemH;
+  int16_t       nElemX0,nElemY0,nElemX1,nElemY1;
+  int16_t       nGaugeX0,nGaugeY0,nGaugeX1,nGaugeY1;
+
+  nElemX0 = pElem->rElem.x;
+  nElemY0 = pElem->rElem.y;
+  nElemX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nElemY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemW  = pElem->rElem.w;
+  nElemH  = pElem->rElem.h;
+
+  bool    bVert = pGauge->bVert;
+  bool    bFlip = pGauge->bFlip;
+  int16_t nMax  = pGauge->nMax;
+  int16_t nMin  = pGauge->nMin;
+  int16_t nRng  = pGauge->nMax - pGauge->nMin;
+
+  uint32_t nScl = 1;
+  int16_t nGaugeMid = 0;
+  int16_t nLen = 0;
+  int16_t nTmp = 0;
+  int32_t nTmpL = 0;
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXGaugeDraw() Zero gauge range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  if (bVert) {
+    nScl = nElemH*32768/nRng;
+  } else {
+    nScl = nElemW*32768/nRng;
+  }
+
+  // Calculate the control midpoint/zeropoint (for display purposes)
+  nTmpL = -((int32_t)nMin * (int32_t)nScl / 32768);
+  nGaugeMid = (int16_t)nTmpL;
+
+
+  // Calculate the length of the bar
+  // - Use long mult/divide to avoid need for floating point
+  nTmpL = (int32_t)(pGauge->nVal) * (int32_t)(nScl) / 32768;
+  nLen  = (int16_t)(nTmpL);
+
+  // Define the gauge's fill rectangle region
+  // depending on the orientation (bVert) and whether
+  // the current position is negative or positive.
+  if (nLen >= 0) {
+    if (bVert) {
+      nGaugeY0 = nElemY0 + nGaugeMid;
+      nGaugeY1 = nElemY0 + nGaugeMid + nLen;
+    } else {
+      nGaugeX0 = nElemX0 + nGaugeMid;
+      nGaugeX1 = nElemX0 + nGaugeMid + nLen;
+    }
+  } else {
+    if (bVert) {
+      nGaugeY0 = nElemY0 + nGaugeMid + nLen;
+      nGaugeY1 = nElemY0 + nGaugeMid;
+    } else {
+      nGaugeX0 = nElemX0 + nGaugeMid + nLen;
+      nGaugeX1 = nElemX0 + nGaugeMid;
+    }
+  }
+  if (bVert) {
+    nGaugeX0 = nElemX0;
+    nGaugeX1 = nElemX1;
+  } else {
+    nGaugeY0 = nElemY0;
+    nGaugeY1 = nElemY1;
+  }
+
+
+  // Clip the region
+  nGaugeX0 = (nGaugeX0 < nElemX0)? nElemX0 : nGaugeX0;
+  nGaugeY0 = (nGaugeY0 < nElemY0)? nElemY0 : nGaugeY0;
+  nGaugeX1 = (nGaugeX1 > nElemX1)? nElemX1 : nGaugeX1;
+  nGaugeY1 = (nGaugeY1 > nElemY1)? nElemY1 : nGaugeY1;
+
+  // Support flipping of gauge directionality
+  // - The bFlip flag reverses the fill direction
+  // - Vertical gauges are flipped by default
+
+  if (bVert && !bFlip) {
+    nTmp      = nElemY0+(nElemY1-nGaugeY1);  // nTmp will be swapped into nGaugeY0
+    nGaugeY1  = nElemY1-(nGaugeY0-nElemY0);
+    nGaugeY0  = nTmp;
+    nGaugeMid = nElemH-nGaugeMid-1;
+  } else if (!bVert && bFlip) {
+    nTmp      = nElemX0+(nElemX1-nGaugeX1);  // nTmp will be swapped into nGaugeX0
+    nGaugeX1  = nElemX1-(nGaugeX0-nElemX0);
+    nGaugeX0  = nTmp;
+    nGaugeMid = nElemW-nGaugeMid-1;
+  }
+
+  #ifdef DBG_LOG
+  //printf("Gauge: nMin=%4d nMax=%4d nRng=%d nVal=%4d fScl=%6.3f nGaugeMid=%4d RectX=%4d RectW=%4d\n",
+  //  nMin,nMax,nRng,pGauge->nGaugeVal,fScl,nGaugeMid,rGauge.x,rGauge.w);
+  #endif
+
+  // Draw a frame around the gauge
+  // - Only draw this during full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+  }
+
+  // To avoid flicker, we only erase the portion of the gauge
+  // that isn't "filled". Determine the gauge empty region and erase it
+  // There are two empty regions (one in negative and one in positive)
+  int16_t nEmptyPos;
+  if (bVert) {
+    // Empty Region #1 (negative)
+    nEmptyPos = (nGaugeY0 > nElemY1) ? nElemY1 : nGaugeY0;
+    rEmpty = (gslc_tsRect){nElemX0,nElemY0,nElemX1-nElemX0+1,nEmptyPos-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui,rTmp,pElem->colElemFill);
+    // Empty Region #2 (positive)
+    nEmptyPos = (nGaugeY1 < nElemY0) ? nElemY0 : nGaugeY1;
+    rEmpty = (gslc_tsRect){nElemX0,nEmptyPos,nElemX1-nElemX0+1,nElemY1-nEmptyPos+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui,rTmp,pElem->colElemFill);
+  } else {
+    // Empty Region #1 (negative)
+    nEmptyPos = (nGaugeX0 > nElemX1) ? nElemX1 : nGaugeX0;
+    rEmpty = (gslc_tsRect){nElemX0,nElemY0,nEmptyPos-nElemX0+1,nElemY1-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui, rTmp, pElem->colElemFill);
+    // Empty Region #2 (positive)
+    nEmptyPos = (nGaugeX1 < nElemX0) ? nElemX0 : nGaugeX1;
+    rEmpty = (gslc_tsRect){nEmptyPos,nElemY0,nElemX1-nEmptyPos+1,nElemY1-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui, rTmp, pElem->colElemFill);
+  }
+
+  // Draw the gauge fill region
+  rGauge = (gslc_tsRect){nGaugeX0,nGaugeY0,nGaugeX1-nGaugeX0+1,nGaugeY1-nGaugeY0+1};
+  rTmp = gslc_ExpandRect(rGauge,-1,-1);
+  gslc_DrawFillRect(pGui,rTmp,pGauge->colGauge);
+
+
+  // Draw the midpoint line
+  if (bVert) {
+    if (nElemY0 + nGaugeMid < nElemY1) {
+      gslc_DrawLine(pGui, nElemX0, nElemY0 + nGaugeMid, nElemX1, nElemY0 + nGaugeMid, pElem->colElemFrame);
+    }
+  } else {
+    if (nElemX0 + nGaugeMid < nElemX1) {
+      gslc_DrawLine(pGui, nElemX0 + nGaugeMid, nElemY0, nElemX0 + nGaugeMid, nElemY1, pElem->colElemFrame);
+    }
+  }
+
+
+
+  return true;
+}
+
+#if (GSLC_FEATURE_XGAUGE_RADIAL)
+void gslc_ElemXGaugeDrawRadialHelp(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint16_t nArrowLen,uint16_t nArrowSz,int16_t n64Ang,bool bFill,gslc_tsColor colFrame)
+{
+  int16_t   nTipX,nTipY;
+  int16_t   nBaseX1,nBaseY1,nBaseX2,nBaseY2;
+  int16_t   nTipBaseX,nTipBaseY;
+
+  gslc_PolarToXY(nArrowLen,n64Ang,&nTipX,&nTipY);
+  gslc_PolarToXY(nArrowLen-nArrowSz,n64Ang,&nTipBaseX,&nTipBaseY);
+  gslc_PolarToXY(nArrowSz,n64Ang-90*64,&nBaseX1,&nBaseY1);
+  gslc_PolarToXY(nArrowSz,n64Ang+90*64,&nBaseX2,&nBaseY2);
+
+  if (!bFill) {
+    // Framed
+    gslc_DrawLine(pGui,nX+nBaseX1,nY+nBaseY1,nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX2,nY+nBaseY2,nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY,nX+nTipX,nY+nTipY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY,nX+nTipX,nY+nTipY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX1,nY+nBaseY1,nX+nBaseX2,nY+nBaseY2,colFrame);
+
+  } else {
+    // Filled
+    gslc_tsPt asPt[4];
+
+    // Main body of pointer
+    asPt[0] = (gslc_tsPt){nX+nBaseX1,nY+nBaseY1};
+    asPt[1] = (gslc_tsPt){nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY};
+    asPt[2] = (gslc_tsPt){nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY};
+    asPt[3] = (gslc_tsPt){nX+nBaseX2,nY+nBaseY2};
+    gslc_DrawFillQuad(pGui,asPt,colFrame);
+
+    // Tip of pointer
+    asPt[0] = (gslc_tsPt){nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY};
+    asPt[1] = (gslc_tsPt){nX+nTipX,nY+nTipY};
+    asPt[2] = (gslc_tsPt){nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY};
+    gslc_DrawFillTriangle(pGui,asPt[0].x,asPt[0].y,asPt[1].x,asPt[1].y,asPt[2].x,asPt[2].y,colFrame);
+
+  }
+
+}
+
+bool gslc_ElemXGaugeDrawRadial(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  uint16_t      nElemW,nElemH,nElemRad;
+  int16_t       nElemX0,nElemY0,nElemX1,nElemY1;
+  int16_t       nElemMidX,nElemMidY;
+  nElemX0   = pElem->rElem.x;
+  nElemY0   = pElem->rElem.y;
+  nElemX1   = pElem->rElem.x + pElem->rElem.w - 1;
+  nElemY1   = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemMidX = (nElemX0+nElemX1)/2;
+  nElemMidY = (nElemY0+nElemY1)/2;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+  nElemRad  = (nElemW>=nElemH)? nElemH/2 : nElemW/2;
+
+  int16_t   nMax            = pGauge->nMax;
+  int16_t   nMin            = pGauge->nMin;
+  int16_t   nRng            = pGauge->nMax - pGauge->nMin;
+  int16_t   nVal            = pGauge->nVal;
+  int16_t   nValLast        = pGauge->nValLast;
+  bool      bValLastValid   = pGauge->bValLastValid;
+  uint16_t  nTickLen        = pGauge->nTickLen;
+  uint16_t  nTickAng        = 360 / pGauge->nTickCnt;
+  uint16_t  nArrowLen       = pGauge->nIndicLen;
+  uint16_t  nArrowSize      = pGauge->nIndicTip;
+  bool      bFill           = pGauge->bIndicFill;
+
+  int16_t   n64Ang,n64AngLast;
+  int16_t   nInd;
+
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXRadialDraw() Zero range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  // Support reversing of direction
+  // TODO: Clean up excess integer typecasting
+  if (pGauge->bFlip) {
+    n64Ang      = (int32_t)(nMax - nVal    )* 360*64 /nRng;
+    n64AngLast  = (int32_t)(nMax - nValLast)* 360*64 /nRng;
+  } else {
+    n64Ang      = (int32_t)(nVal     - nMin)* 360*64 /nRng;
+    n64AngLast  = (int32_t)(nValLast - nMin)* 360*64 /nRng;
+  }
+
+  // Clear old
+  if (bValLastValid) {
+    gslc_ElemXGaugeDrawRadialHelp(pGui,nElemMidX,nElemMidY,nArrowLen,nArrowSize,n64AngLast,bFill,pElem->colElemFill);
+  }
+
+  // Draw frame
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFillCircle(pGui,nElemMidX,nElemMidY,nElemRad,pElem->colElemFill);  // Erase first
+    gslc_DrawFrameCircle(pGui,nElemMidX,nElemMidY,nElemRad,pElem->colElemFrame);
+    for (nInd=0;nInd<360;nInd+=nTickAng) {
+      gslc_DrawLinePolar(pGui,nElemMidX,nElemMidY,nElemRad-nTickLen,nElemRad,nInd*64,pGauge->colTick);
+    }
+  }
+
+  // Draw pointer
+  gslc_ElemXGaugeDrawRadialHelp(pGui,nElemMidX,nElemMidY,nArrowLen,nArrowSize,n64Ang,bFill,pGauge->colGauge);
+
+  return true;
+}
+#endif // GSLC_FEATURE_XGAUGE_RADIAL
+
+#ifdef GSLC_FEATURE_XGAUGE_RAMP
+bool gslc_ElemXGaugeDrawRamp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGauge*  pGauge  = (gslc_tsXGauge*)(pElem->pXData);
+
+  uint16_t      nElemW,nElemH;
+  int16_t       nElemX0,nElemY1;
+  nElemX0   = pElem->rElem.x;
+  nElemY1   = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+
+  int16_t   nMax            = pGauge->nMax;
+  int16_t   nMin            = pGauge->nMin;
+  int16_t   nRng            = pGauge->nMax - pGauge->nMin;
+  int16_t   nVal            = pGauge->nVal;
+  int16_t   nValLast        = pGauge->nValLast;
+  bool      bValLastValid   = pGauge->bValLastValid;
+  int16_t   nInd;
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXGaugeDrawRamp() Zero range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  uint32_t  nSclFX;
+  uint16_t  nHeight;
+  int32_t   nHeightTmp;
+  uint16_t  nHeightBot;
+  uint16_t  nX;
+  uint16_t  nColInd;
+
+  // Calculate region to draw or clear
+  bool      bModeErase;
+  int16_t   nValStart;
+  int16_t   nValEnd;
+  if ((eRedraw == GSLC_REDRAW_INC) && (!bValLastValid)) {
+    // - If the request was incremental (GSLC_REDRAW_INC) but
+    //   the last value wasn't marked as valid (!bValLastValid)
+    //   then we want to force a full redraw.
+    // - We don't expect to enter here since bValLastValid
+    //   should always be set after we perform our first
+    //   redraw.
+    eRedraw = GSLC_REDRAW_FULL;
+  }
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    // If we haven't drawn anything before, draw full range from zero
+    bModeErase  = false;
+    nValStart   = 0;
+    nValEnd     = nVal;
+  } else {
+    if (nVal >= nValLast) {
+      // As we are advancing the control, we just draw the new range
+      bModeErase  = false;
+      nValStart   = nValLast;
+      nValEnd     = nVal;
+    } else {
+      // Since we are retracting the control, we erase the new range
+      bModeErase  = true;
+      nValStart   = nVal;
+      nValEnd     = nValLast;
+    }
+  }
+
+  // Calculate the scaled gauge position
+  // - TODO: Also support reversing of direction
+  int16_t   nPosXStart,nPosXEnd;
+  nPosXStart  = (nValStart - nMin)*nElemW/nRng;
+  nPosXEnd    = (nValEnd   - nMin)*nElemW/nRng;
+
+  nSclFX = (uint32_t)nElemH*32767/(nElemW*nElemW);
+
+  for (nX=nPosXStart;nX<nPosXEnd;nX++) {
+    nInd = nElemW-nX;
+    nHeightTmp = nSclFX * nInd*nInd /32767;
+    nHeight = nElemH-nHeightTmp;
+    if (nHeight >= 20) {
+      nHeightBot = nHeight-20;
+    } else {
+      nHeightBot = 0;
+    }
+    gslc_tsColor  nCol;
+    uint16_t      nSteps = 10;
+    uint16_t      nGap = 3;
+
+    if (nSteps == 0) {
+      nColInd = nX*1000/nElemW;
+      nCol = gslc_ColorBlend3(GSLC_COL_GREEN,GSLC_COL_YELLOW,GSLC_COL_RED,500,nColInd);
+    } else {
+      uint16_t  nBlockLen,nSegLen,nSegInd,nSegOffset,nSegStart;
+      nBlockLen = (nElemW-(nSteps-1)*nGap)/nSteps;
+      nSegLen = nBlockLen + nGap;
+      nSegInd = nX/nSegLen;
+      nSegOffset = nX % nSegLen;
+      nSegStart = nSegInd * nSegLen;
+
+      if (nSegOffset <= nBlockLen) {
+        // Inside block
+        nColInd = (uint32_t)nSegStart*1000/nElemW;
+        nCol = gslc_ColorBlend3(GSLC_COL_GREEN,GSLC_COL_YELLOW,GSLC_COL_RED,500,nColInd);
+
+      } else {
+        // Inside gap
+        // - No draw
+        nCol = pElem->colElemFill;
+      }
+
+    }
+
+    if (bModeErase) {
+      nCol = pElem->colElemFill;
+    }
+    gslc_DrawLine(pGui,nElemX0+nX,nElemY1-nHeightBot,nElemX0+nX,nElemY1-nHeight,nCol);
+
+  }
+
+  return true;
+}
+#endif // GLSC_FEATURE_XGAUGE_RAMP
+
+
+// ============================================================================
diff --git a/src/guislice/XGauge.h b/src/guislice/XGauge.h
new file mode 100644
index 0000000..d08316f
--- /dev/null
+++ b/src/guislice/XGauge.h
@@ -0,0 +1,394 @@
+#ifndef _GUISLICE_EX_XGAUGE_H_
+#define _GUISLICE_EX_XGAUGE_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Gauge control (See replacement warning below)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XGauge.h
+
+// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
+// WARNING: The XGauge element has been replaced by XProgress / XRadial / XRamp
+//          Please update your code according to the migration notes in:
+//          https://github.com/ImpulseAdventure/GUIslice/pull/157
+//          XGauge may be removed in a future release.
+// *-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Gauge
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_GAUGE GSLC_TYPE_BASE_EXTEND + 0
+
+
+/// Gauge drawing style
+typedef enum {
+    GSLCX_GAUGE_STYLE_PROG_BAR,  ///< Progress bar
+    GSLCX_GAUGE_STYLE_RADIAL,    ///< Radial indicator
+    GSLCX_GAUGE_STYLE_RAMP,      ///< Ramp indicator
+} gslc_teXGaugeStyle;
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Gauge element
+typedef struct {
+  // Range config
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+
+  // Current value
+  int16_t             nVal;           ///< Current control value
+  // Previous value
+  int16_t             nValLast;       ///< Last value
+  bool                bValLastValid;  ///< Last value valid?
+
+  // Appearance config
+  gslc_teXGaugeStyle  nStyle;         ///< Gauge sub-type
+  gslc_tsColor        colGauge;       ///< Color of gauge fill bar
+  gslc_tsColor        colTick;        ///< Color of gauge tick marks
+  uint16_t            nTickCnt;       ///< Number of gauge tick marks
+  uint16_t            nTickLen;       ///< Length of gauge tick marks
+  bool                bVert;          ///< Vertical if true, else Horizontal
+  bool                bFlip;          ///< Reverse direction of gauge
+  uint16_t            nIndicLen;      ///< Indicator length
+  uint16_t            nIndicTip;      ///< Size of tip at end of indicator
+  bool                bIndicFill;     ///< Fill the indicator if true
+
+} gslc_tsXGauge;
+
+
+///
+/// Create a Gauge Element
+/// - Draws a gauge element that represents a proportion (nVal)
+///   between nMin and nMax.
+/// - Support gauge sub-types:
+///   - GSLC_TYPEX_GAUGE_PROG_BAR: Horizontal or vertical box with filled region
+///   - GSLC_TYPEX_GAUGE_RADIAL:   Radial / compass indicator
+/// - Default appearance is a horizontal progress bar, but can be changed
+///   with gslc_ElemXGaugeSetStyle())
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining gauge size
+/// \param[in]  nMin:        Minimum value of gauge for nVal comparison
+/// \param[in]  nMax:        Maximum value of gauge for nVal comparison
+/// \param[in]  nVal:        Starting value of gauge
+/// \param[in]  colGauge:    Color for the gauge indicator
+/// \param[in]  bVert:       Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXGaugeCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXGauge* pXData,gslc_tsRect rElem,int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert);
+
+
+///
+/// Configure the style of a Gauge element
+/// - This function is used to select between one of several gauge types
+///   (eg. progress bar, radial dial, etc.)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nType:       Gauge style enumeration
+///
+/// \return none
+///
+void gslc_ElemXGaugeSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teXGaugeStyle nType);
+
+
+///
+/// Configure the appearance of the Gauge indicator
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colGauge:    Color of the indicator
+/// \param[in]  nIndicLen:   Length of the indicator
+/// \param[in]  nIndicTip:   Size of the indicator tip
+/// \param[in]  bIndicFill:  Fill in the indicator if true
+///
+/// \return none
+///
+void gslc_ElemXGaugeSetIndicator(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colGauge,
+        uint16_t nIndicLen,uint16_t nIndicTip,bool bIndicFill);
+
+
+///
+/// Configure the appearance of the Gauge ticks
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colTick:     Color of the gauge ticks
+/// \param[in]  nTickCnt:    Number of ticks to draw around / along gauge
+/// \param[in]  nTickLen:    Length of the tick marks to draw
+///
+/// \return none
+///
+void gslc_ElemXGaugeSetTicks(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colTick,uint16_t nTickCnt,uint16_t nTickLen);
+
+
+///
+/// Update a Gauge element's current value
+/// - Note that min & max values are assigned in create()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New value to show in gauge
+///
+/// \return none
+///
+void gslc_ElemXGaugeUpdate(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+///
+/// Set a Gauge element's fill direction
+/// - Setting bFlip reverses the default fill direction
+/// - Default fill direction for horizontal gauges: left-to-right
+/// - Default fill direction for vertical gauges: bottom-to-top
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bFlip:       If set, reverse direction of fill from default
+///
+/// \return none
+///
+void gslc_ElemXGaugeSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip);
+
+
+///
+/// Draw a gauge element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \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]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGaugeDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Helper function to draw a gauge with style: progress bar
+/// - Called from gslc_ElemXGaugeDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGaugeDrawProgressBar(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+#if (GSLC_FEATURE_XGAUGE_RADIAL)
+///
+/// Helper function to draw a gauge with style: radial
+/// - Called from gslc_ElemXGaugeDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGaugeDrawRadial(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+#endif
+
+#if (GSLC_FEATURE_XGAUGE_RAMP)
+///
+/// Helper function to draw a gauge with style: ramp
+/// - Called from gslc_ElemXGaugeDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGaugeDrawRamp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+#endif
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXGaugeCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_)
+///
+/// Create a Gauge Element in Flash
+///
+/// \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]  nMin_:       Minimum value of gauge for nVal comparison
+/// \param[in]  nMax_:       Maximum value of gauge for nVal comparison
+/// \param[in]  nVal_:       Starting value of gauge
+/// \param[in]  colFrame_:   Color for the gauge frame
+/// \param[in]  colFill_:    Color for the gauge background fill
+/// \param[in]  colGauge_:   Color for the gauge indicator
+/// \param[in]  bVert_:      Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXGaugeCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXGauge sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.nStyle = GSLCX_GAUGE_STYLE_PROG_BAR;            \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.colTick = GSLC_COL_GRAY;                        \
+  sGauge##nElemId.nTickCnt = 8;                                   \
+  sGauge##nElemId.nTickLen = 5;                                   \
+  sGauge##nElemId.bVert = bVert_;                                 \
+  sGauge##nElemId.bFlip = false;                                  \
+  sGauge##nElemId.nIndicLen = 10;                                 \
+  sGauge##nElemId.nIndicTip = 3;                                  \
+  sGauge##nElemId.bIndicFill = false;                             \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_GAUGE,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXGaugeDraw,                                       \
+      NULL,                                                       \
+      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_ElemXGaugeCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXGauge sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.nStyle = GSLCX_GAUGE_STYLE_PROG_BAR;            \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.colTick = GSLC_COL_GRAY;                        \
+  sGauge##nElemId.nTickCnt = 8;                                   \
+  sGauge##nElemId.nTickLen = 5;                                   \
+  sGauge##nElemId.bVert = bVert_;                                 \
+  sGauge##nElemId.bFlip = false;                                  \
+  sGauge##nElemId.nIndicLen = 10;                                 \
+  sGauge##nElemId.nIndicTip = 3;                                  \
+  sGauge##nElemId.bIndicFill = false;                             \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_GAUGE,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXGaugeDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XGAUGE_H_
+
diff --git a/src/guislice/XGlowball.c b/src/guislice/XGlowball.c
new file mode 100644
index 0000000..884158c
--- /dev/null
+++ b/src/guislice/XGlowball.c
@@ -0,0 +1,348 @@
+// =======================================================================
+// GUIslice library extension: XGlowball
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XGlowball.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XGlowball.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: XGlowball
+// ============================================================================
+
+// Create a XGlowball element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXGlowballCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXGlowball* pXData, int16_t nMidX, int16_t nMidY, gslc_tsXGlowballRing* pRings, uint8_t nNumRings)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Calculate the actual element dimensions based on the ring defintion
+  // - Note that we use the outer radius of the last ring
+  int16_t nRadMax;
+  gslc_tsRect rElem;
+  nRadMax = pRings[nNumRings - 1].nRad2;
+  rElem.w = 2 * nRadMax;
+  rElem.h = 2 * nRadMax;
+  rElem.x = nMidX - nRadMax;
+  rElem.y = nMidY - nRadMax;
+
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_GLOW,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  sElem.colElemText       = GSLC_COL_WHITE;
+  sElem.colElemTextGlow   = GSLC_COL_WHITE;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+  sElem.eTxtAlign         = GSLC_ALIGN_MID_LEFT;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Initialize any pxData members with default parameters
+  pXData->nVal = 0;
+  pXData->nQuality = 72;
+  pXData->nAngStart = 0;
+  pXData->nAngEnd = 360;
+  pXData->pRings = pRings;
+  pXData->nNumRings = nNumRings;
+  pXData->nMidX = nMidX;
+  pXData->nMidY = nMidY;
+  pXData->colBg = GSLC_COL_BLACK;
+  pXData->nValLast = 0;
+
+
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXGlowballDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch = NULL;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void drawXGlowballArc(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2, gslc_tsColor cArc, uint16_t nAngStart, uint16_t nAngEnd)
+{
+  gslc_tsPt anPts[4];
+  // TODO: Cleanup
+  int16_t nStep64 = 64*360 / pGlowball->nQuality;
+  int16_t nAng64;
+  int16_t nX, nY;
+  int16_t nSegStart, nSegEnd;
+  nSegStart = nAngStart * pGlowball->nQuality / 360;
+  nSegEnd = nAngEnd * pGlowball->nQuality / 360;
+
+  for (uint16_t nSegInd = nSegStart; nSegInd < nSegEnd; nSegInd++) {
+    nAng64 = nSegInd * nStep64;
+    nAng64 = nAng64 % (360 * 64);
+
+    gslc_PolarToXY(nRad1, nAng64, &nX, &nY);
+    anPts[0] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad2, nAng64, &nX, &nY);
+    anPts[1] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad2, nAng64 + nStep64, &nX, &nY);
+    anPts[2] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+    gslc_PolarToXY(nRad1, nAng64 + nStep64, &nX, &nY);
+    anPts[3] = (gslc_tsPt) { nMidX + nX, nMidY + nY };
+
+    gslc_DrawFillQuad(pGui, anPts, cArc);
+  }
+}
+
+
+void drawXGlowballRing(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nVal, uint16_t nAngStart, uint16_t nAngEnd, bool bErase)
+{
+  int16_t nRad1, nRad2;
+  gslc_tsColor cCol;
+
+  if ((nVal <= 0) || (nVal > pGlowball->nNumRings)) {
+    return;
+  }
+
+  nRad1 = pGlowball->pRings[nVal - 1].nRad1;
+  nRad2 = pGlowball->pRings[nVal - 1].nRad2;
+  cCol = (bErase) ? pGlowball->colBg : pGlowball->pRings[nVal - 1].cCol;
+
+  drawXGlowballArc(pGui, pGlowball, nMidX, nMidY, nRad1, nRad2, cCol, nAngStart, nAngEnd);
+}
+
+// nAngStart & nAngEnd define the range (in degrees) for the XGlowball arcs
+// - Angles are measured with 0 degrees at the top, incrementing clockwise
+// - Note that the supported range is 0..510 degrees
+// nVal represents the value to set (0.. NUM_RINGS)
+// nMidX,nMidY define the center of the XGlowball
+void drawXGlowball(gslc_tsGui* pGui,gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nVal, uint16_t nAngStart, uint16_t nAngEnd)
+{
+  int16_t nValLast = pGlowball->nValLast;
+  int8_t nRingInd;
+
+  if (nVal > nValLast) {
+    for (nRingInd = nValLast + 1; nRingInd <= nVal; nRingInd++) {
+      drawXGlowballRing(pGui, pGlowball, nMidX, nMidY, nRingInd, nAngStart, nAngEnd, false);
+    }
+  } else {
+    for (nRingInd = nValLast; nRingInd > nVal; nRingInd--) {
+      drawXGlowballRing(pGui, pGlowball, nMidX, nMidY, nRingInd, nAngStart, nAngEnd, true);
+    }
+  }
+  pGlowball->nValLast = nVal;
+}
+
+void gslc_ElemXGlowballSetVal(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nVal)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballSetVal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGlowball* pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+
+  // Update the value
+  pGlowball->nVal = nVal;
+
+  // Mark for redraw
+  // - Only need incremental redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+void gslc_ElemXGlowballSetAngles(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nAngStart, int16_t nAngEnd)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballSetAngles";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGlowball* pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+
+  // Update the angular ranges
+  pGlowball->nAngStart = nAngStart;
+  pGlowball->nAngEnd = nAngEnd;
+
+  // Mark for redraw
+  // - Force full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXGlowballSetQuality(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nQuality)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballSetQuality";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGlowball* pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+
+  // Update the rendering quality setting
+  pGlowball->nQuality = nQuality;
+
+  // Mark for redraw
+  // - Force full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXGlowballSetColorBack(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colBg)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballSetColorBack";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXGlowball* pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+
+  // Update the background color
+  pGlowball->colBg = colBg;
+
+  // Mark for redraw
+  // - Force full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+// Redraw the element
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXGlowballDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGlowballDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXGlowball* pGlowball;
+  pGlowball = (gslc_tsXGlowball*)(pElem->pXData);
+  if (pGlowball == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXGlowballDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  // --------------------------------------------------------------------------
+  // Init for default drawing
+  // --------------------------------------------------------------------------
+
+  int16_t   nElemX,nElemY;
+  uint16_t  nElemW,nElemH;
+
+  nElemX    = pElem->rElem.x;
+  nElemY    = pElem->rElem.y;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+
+  // Calculate center of XGlowball
+  int16_t nMidX, nMidY;
+  nMidX = nElemX + (nElemW / 2);
+  nMidY = nElemY + (nElemH / 2);
+
+  // Fetch the current value
+  int16_t nVal = pGlowball->nVal;
+  int16_t nAngStart = pGlowball->nAngStart;
+  int16_t nAngEnd = pGlowball->nAngEnd;
+
+  // Check to see if we need full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    // Erase the region
+	  gslc_DrawFillRect(pGui, pElem->rElem, pGlowball->colBg);
+    // Now force redraw from zero level to current value
+	  pGlowball->nValLast = 0;
+  }
+
+  // Draw the glowball
+  drawXGlowball(pGui, pGlowball, nMidX, nMidY, nVal, nAngStart, nAngEnd);
+  // --------------------------------------------------------------------------
+
+  // Mark the element as no longer requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+
+}
+
+// ============================================================================
diff --git a/src/guislice/XGlowball.h b/src/guislice/XGlowball.h
new file mode 100644
index 0000000..b4d2cbf
--- /dev/null
+++ b/src/guislice/XGlowball.h
@@ -0,0 +1,136 @@
+#ifndef _GUISLICE_EX_XGLOWBALL_H_
+#define _GUISLICE_EX_XGLOWBALL_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: XGlowball
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XGlowball.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Example template
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_GLOW GSLC_TYPE_BASE_EXTEND + 24
+
+// Defines the attributes of each ring in the XGlowball gauge
+typedef struct {
+  uint8_t        nRad1;      // Inner radius
+  uint8_t        nRad2;      // Outer radius
+  gslc_tsColor   cCol;       // Fill color
+} gslc_tsXGlowballRing;
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Slider element
+typedef struct {
+  // Config
+  int16_t               nMidX;          ///< Gauge midpoint X coord
+  int16_t               nMidY;          ///< Gauge midpoint Y coord
+  gslc_tsXGlowballRing* pRings;         ///< Ring definition array
+  uint8_t               nNumRings;      ///< Number of rings in definition
+  // Style config
+  uint16_t              nQuality;       ///< Rendering quality (number of segments / rotation)
+  int16_t               nAngStart;      ///< Starting angle (0..510 degrees)
+  int16_t               nAngEnd;        ///< Ending angle (0..510 degrees)
+  gslc_tsColor          colBg;          ///< Background color (for redraw)
+  // State
+  int16_t               nVal;           ///< Current value
+  int16_t               nValLast;       ///< Previous value
+  // Callbacks
+} gslc_tsXGlowball;
+
+
+///
+/// Create a XGlowball element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  nMidX:       Center X coordinate
+/// \param[in]  nMidY:       Center Y coordinate
+/// \param[in]  pRings:      Pointer to tsXGlowballRing structure array defining appearance
+/// \param[in]  nNumRings:   Number of rings in pRings array
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXGlowballCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXGlowball* pXData, int16_t nMidX, int16_t nMidY, gslc_tsXGlowballRing* pRings, uint8_t nNumRings);
+
+
+///
+/// Draw the XGlowball element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGlowballDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+// XGlowball draw helper routines
+void drawXGlowballArc(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nRad1, int16_t nRad2, gslc_tsColor cArc, uint16_t nAngStart, uint16_t nAngEnd);
+void drawXGlowballRing(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nVal, uint16_t nAngStart, uint16_t nAngEnd, bool bErase);
+void drawXGlowball(gslc_tsGui* pGui, gslc_tsXGlowball* pGlowball, int16_t nMidX, int16_t nMidY, int16_t nVal, uint16_t nAngStart, uint16_t nAngEnd);
+
+void gslc_ElemXGlowballSetAngles(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nAngStart, int16_t nAngEnd);
+void gslc_ElemXGlowballSetVal(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nVal);
+void gslc_ElemXGlowballSetQuality(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nQuality);
+void gslc_ElemXGlowballSetColorBack(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colBg);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XGLOWBALL_H_
+
diff --git a/src/guislice/XGraph.c b/src/guislice/XGraph.c
new file mode 100644
index 0000000..6db6a53
--- /dev/null
+++ b/src/guislice/XGraph.c
@@ -0,0 +1,366 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XGraph.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XGraph.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+
+gslc_tsElemRef* gslc_ElemXGraphCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXGraph* pXData,gslc_tsRect rElem,int16_t nFontId,int16_t* pBuf,
+  uint16_t nBufMax,gslc_tsColor colGraph)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGraphCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_GRAPH,rElem,NULL,0,nFontId);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+
+  // Default group assignment. Can override later with ElemSetGroup()
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Define other extended data
+  pXData->pBuf            = pBuf;
+  pXData->nMargin         = 5;
+
+  pXData->nBufMax         = nBufMax;
+  pXData->nBufCnt         = 0;
+  pXData->nPlotIndStart   = 0;
+
+  pXData->colGraph        = colGraph;
+  pXData->eStyle          = GSLCX_GRAPH_STYLE_DOT;
+
+  // Define the visible region of the window
+  // - The range in value can be overridden by the user
+  pXData->nWndHeight = rElem.h - (2*pXData->nMargin);
+  pXData->nWndWidth  = rElem.w - (2*pXData->nMargin);
+
+  // Default scale is
+  // - Each data point (buffer row) gets 1 pixel in X direction
+  // - Data value is directly mapped to height in Y direction
+  pXData->nPlotValMin   = 0;
+  pXData->nPlotValMax   = pXData->nWndHeight;
+  pXData->nPlotIndMax    = pXData->nWndWidth;
+
+
+  // Clear the buffer
+  memset(pBuf,0,nBufMax*sizeof(int16_t));
+
+
+  // Determine if scrollbar should be enabled
+  if (pXData->nPlotIndMax >= pXData->nBufMax) {
+    // Disable scrollbar as the window is larger
+    // than the number of rows in the buffer
+    pXData->bScrollEn   = false;
+    pXData->nScrollPos  = 0;
+  } else {
+    // Scrollbar is enabled
+    pXData->bScrollEn   = true;
+    pXData->nScrollPos  = pXData->nBufMax - pXData->nPlotIndMax;
+  }
+
+  sElem.pXData            = (void*)(pXData);
+
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXGraphDraw;
+  sElem.pfuncXTouch       = NULL;
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void gslc_ElemXGraphSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        gslc_teXGraphStyle eStyle,uint8_t nMargin)
+{
+  gslc_tsXGraph*  pBox;
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+
+  pBox->eStyle  = eStyle;
+  pBox->nMargin = nMargin;
+
+  // TODO: Recalculate the window extents and defaults
+  // - Note that ElemXGraphSetStyle() was not intended to be
+  //   called after the control is already in use/displayed
+
+  // Set the redraw flag
+  // - Force full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+// TODO: Support scaling in X direction
+void gslc_ElemXGraphSetRange(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        int16_t nYMin,int16_t nYMax)
+{
+  gslc_tsXGraph*    pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+
+  pBox->nPlotValMax = nYMax;
+  pBox->nPlotValMin = nYMin;
+
+  // Set the redraw flag
+  // - As we are changing the scale, force a full redraw
+  //   since incremental redraws may make assumption about
+  //   prior coordinate scaling
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+
+void gslc_ElemXGraphScrollSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nScrollPos,uint8_t nScrollMax)
+{
+
+  gslc_tsXGraph*  pBox;
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+
+  // Ensure scrollbar is enabled
+  if (!pBox->bScrollEn) {
+    // Scrollbar is disabled, so ignore
+    return;
+  }
+
+  // Assign proportional value based on visible window region
+  uint16_t nScrollPosOld = pBox->nScrollPos;
+  pBox->nScrollPos = nScrollPos * (pBox->nBufMax - pBox->nPlotIndMax) / nScrollMax;
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  // - Only redraw if changed actual scroll row
+  if (pBox->nScrollPos != nScrollPosOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+}
+
+
+// Write a data value to the buffer
+// - Advance the write ptr, wrap if needed
+// - If encroach upon buffer read ptr, then drop the oldest line from the buffer
+void gslc_ElemXGraphAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  gslc_tsXGraph*  pBox = NULL;
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+
+  // Add the data value
+  pBox->pBuf[pBox->nBufCnt] = nVal;
+
+  // Advance the pointer
+  // - Wrap the pointers around end of buffer
+  pBox->nBufCnt = (pBox->nBufCnt+1) % pBox->nBufMax;
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+
+bool gslc_ElemXGraphDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXGraphDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*     pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*    pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXGraph* pBox;
+  pBox = (gslc_tsXGraph*)(pElem->pXData);
+  if (pBox == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXGraphDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  bool     bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  bool     bFrameEn  = (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN);
+
+  // Draw the frame
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    if (bFrameEn) {
+      gslc_DrawFrameRect(pGui,pElem->rElem,pElem->colElemFrame);
+    }
+  }
+
+  // Clear the background (inset from frame)
+  // TODO: Support incremental redraw in which case we don't
+  //       erase the inner region. Instead we would just erase
+  //       old values and redraw new ones
+  gslc_tsRect rInner = gslc_ExpandRect(pElem->rElem,-1,-1);
+  gslc_DrawFillRect(pGui,rInner,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+
+  int16_t           nDataVal;
+  uint16_t          nCurX = 0;
+  int16_t           nPixX,nPixY,nPixYBase,nPixYOffset;
+  gslc_tsColor      colGraph;
+
+  uint8_t           nScrollMax;
+
+  // Initialize color state
+  colGraph  = pBox->colGraph;
+
+  // Calculate the current window position based on
+  // the current buffer write pointer and scroll
+  // position
+  nScrollMax           = pBox->nBufMax - pBox->nPlotIndMax;
+  pBox->nPlotIndStart  = pBox->nBufMax + pBox->nBufCnt;
+  pBox->nPlotIndStart -= pBox->nPlotIndMax;
+  // Only correct for scrollbar position if enabled
+  if (pBox->bScrollEn) {
+    pBox->nPlotIndStart -= (nScrollMax - pBox->nScrollPos);
+  }
+  pBox->nPlotIndStart  = pBox->nPlotIndStart % pBox->nBufMax;
+
+  uint8_t nPlotInd = 0;
+  uint8_t nIndMax = 0;
+  nIndMax = (pBox->nBufMax < pBox->nPlotIndMax)? pBox->nBufMax : pBox->nPlotIndMax;
+  for (nPlotInd=0;nPlotInd<nIndMax;nPlotInd++) {
+
+    // Calculate row offset after accounting for buffer wrap
+    // and current window starting offset
+    uint16_t nBufInd = pBox->nPlotIndStart + nPlotInd;
+    nBufInd = nBufInd % pBox->nBufMax;
+
+    // NOTE: At the start of buffer fill when we have
+    // only written a few values, we will continue to read
+    // values out of the buffer so we are dependent upon
+    // the reset to initialize the buffer to zero.
+
+    nDataVal = pBox->pBuf[nBufInd];
+
+    // Clip the value to the plot range
+    if      (nDataVal > pBox->nPlotValMax) { nDataVal = pBox->nPlotValMax; }
+    else if (nDataVal < pBox->nPlotValMin) { nDataVal = pBox->nPlotValMin; }
+
+    // TODO: Make nCurX a scaled version of nPlotInd
+    // - Support different modes for mapping multiple data points
+    //   a single X coordinate and mapping a single data point
+    //   to multiple X coordinates
+    // - For now, just have a 1:1 correspondence between data
+    //   points and the X coordinate
+    nCurX = nPlotInd;
+
+    // TODO: Scale data value
+
+    // TODO: Consider supporting various color mapping modes
+    //colGraph = gslc_ColorBlend2(GSLC_COL_BLACK,GSLC_COL_WHITE,500,nDataVal*500/200);
+
+    // Determine the drawing coordinates
+    nPixX       = pElem->rElem.x + pBox->nMargin + nCurX;
+    nPixYBase   = pElem->rElem.y - pBox->nMargin + pElem->rElem.h-1;
+
+    // Calculate Y coordinate
+    nPixYOffset = nDataVal;
+
+    // Clip plot Y coordinate
+    if (nPixY > pBox->nWndHeight) { nPixY = pBox->nWndHeight; }
+    if (nPixY < 0)                { nPixY = 0;                }
+
+    // Calculate final Y coordinate
+    nPixY       = pElem->rElem.y - pBox->nMargin + pElem->rElem.h-1 - nPixYOffset;
+
+
+    // Render the datapoints
+    if (pBox->eStyle == GSLCX_GRAPH_STYLE_DOT) {
+      gslc_DrawSetPixel(pGui,nPixX,nPixY,colGraph);
+    } else if (pBox->eStyle == GSLCX_GRAPH_STYLE_LINE) {
+    } else if (pBox->eStyle == GSLCX_GRAPH_STYLE_FILL) {
+      gslc_DrawLine(pGui,nPixX,nPixYBase,nPixX,nPixY,colGraph);
+    }
+
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// ============================================================================
diff --git a/src/guislice/XGraph.h b/src/guislice/XGraph.h
new file mode 100644
index 0000000..472c5b2
--- /dev/null
+++ b/src/guislice/XGraph.h
@@ -0,0 +1,186 @@
+#ifndef _GUISLICE_EX_XGRAPH_H_
+#define _GUISLICE_EX_XGRAPH_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Graph control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XGraph.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Graph
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_GRAPH GSLC_TYPE_BASE_EXTEND + 5
+
+
+/// Gauge drawing style
+typedef enum {
+  GSLCX_GRAPH_STYLE_DOT,        ///< Dot
+  GSLCX_GRAPH_STYLE_LINE,       ///< Line
+  GSLCX_GRAPH_STYLE_FILL,       ///< Filled
+} gslc_teXGraphStyle;
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Graph element
+typedef struct {
+  // Config
+  int16_t*                  pBuf;           ///< Ptr to the data buffer (circular buffer))
+  uint8_t                   nMargin;        ///< Margin for graph area within element rect
+  gslc_tsColor              colGraph;       ///< Color of the graph
+  gslc_teXGraphStyle        eStyle;         ///< Style of the graph
+
+  uint16_t                  nBufMax;        ///< Maximum number of points in buffer
+  bool                      bScrollEn;      ///< Enable for scrollbar
+  uint16_t                  nScrollPos;     ///< Current scrollbar position
+
+  uint16_t                  nWndHeight;     ///< Visible window height
+  uint16_t                  nWndWidth;      ///< Visible window width
+  int16_t                   nPlotValMax;    ///< Visible window maximum value
+  int16_t                   nPlotValMin;    ///< Visible window minimum value
+  uint16_t                  nPlotIndMax;    ///< Number of data points to show in window
+
+  // Current status
+  uint16_t                  nBufCnt;        ///< Number of points in buffer
+  uint16_t                  nPlotIndStart;  ///< First row of current window
+
+} gslc_tsXGraph;
+
+
+
+///
+/// Create a Graph Element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining checkbox size
+/// \param[in]  nFontId:     Font ID to use for graph area
+/// \param[in]  pBuf:        Ptr to data buffer (already allocated)
+///                          with size (nBufMax) int16_t
+/// \param[in]  nBufRows:    Maximum number of points in buffer
+/// \param[in]  colGraph:    Color of the graph
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXGraphCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXGraph* pXData,gslc_tsRect rElem,int16_t nFontId,int16_t* pBuf,
+  uint16_t nBufRows,gslc_tsColor colGraph);
+
+///
+/// Set the graph's additional drawing characteristics
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  eStyle:      Drawing style for the graph
+/// \param[in]  nMargin:     Margin to provide around graph area inside frame
+///
+/// \return none
+///
+void gslc_ElemXGraphSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        gslc_teXGraphStyle eStyle,uint8_t nMargin);
+
+///
+/// Set the graph's drawing range
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nYMin:       Minimum Y value to draw
+/// \param[in]  nYMax:       Maximum Y value to draw
+///
+/// \return none
+///
+void gslc_ElemXGraphSetRange(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        int16_t nYMin,int16_t nYMax);
+
+///
+/// Draw a Graph element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \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]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXGraphDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+/// Add a value to the graph at the latest position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        Data value to add
+///
+/// \return none
+///
+void gslc_ElemXGraphAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+///
+/// Set the graph scroll position (nScrollPos) as a fraction of
+/// nScrollMax
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nScrollPos:  New scroll position
+/// \param[in]  nScrollMax:  Maximum scroll position
+///
+/// \return none
+///
+void gslc_ElemXGraphScrollSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nScrollPos,uint8_t nScrollMax);
+
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XGRAPH_H_
+
diff --git a/src/guislice/XKeyPad.c b/src/guislice/XKeyPad.c
new file mode 100644
index 0000000..54fc476
--- /dev/null
+++ b/src/guislice/XKeyPad.c
@@ -0,0 +1,714 @@
+// =======================================================================
+// GUIslice library extension: XKeyPad control
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XKeyPad.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XKeyPad.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+#if (GSLC_FEATURE_COMPOUND)
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: KeyPad
+// - Keypad element with numeric input
+// - Optionally supports floating point values
+// - Optionally supports negative values
+// ============================================================================
+
+// Define the button labels
+// - TODO: Create more efficient storage for the labels
+//   so that it doesn't consume 4 bytes even for labels
+//   that can be generated (eg. 0..9, a--z, etc.)
+// - NOTE: Not using "const char" in order to support
+//   modification of labels by user.
+
+
+const char KEYPAD_DISP_NEGATIVE = '-';
+const char KEYPAD_DISP_DECIMAL_PT = '.';
+
+
+
+// --------------------------------------------------------------------------
+// Create the keypad definition
+// --------------------------------------------------------------------------
+
+
+void XKeyPadAddKeyElem(gslc_tsGui* pGui, gslc_tsXKeyPad* pXData, int16_t nKeyId, bool bTxtField, int16_t nRow, int16_t nCol, int8_t nRowSpan, int8_t nColSpan,
+  gslc_tsColor cColFill, gslc_tsColor cColGlow, bool bVisible)
+{
+  gslc_tsXKeyPadCfg* pConfig;
+  char* pKeyStr = NULL;
+
+  pConfig = &(pXData->sConfig);
+
+  gslc_tsElemRef* pElemRefTmp = NULL;
+  gslc_tsElem*    pElemTmp = NULL;
+
+  int16_t nButtonSzW = pConfig->nButtonSzW;
+  int16_t nButtonSzH = pConfig->nButtonSzH;
+  int16_t nOffsetX = pConfig->nOffsetX;
+  int16_t nOffsetY = pConfig->nOffsetY;
+  int8_t nFontId = pConfig->nFontId;
+
+  int16_t nButtonW = (nColSpan * nButtonSzW);
+  int16_t nButtonH = (nRowSpan * nButtonSzH);
+
+  // Fetch the keypad key string
+  if (bTxtField) {
+    pKeyStr = (char*)pXData->acValStr;
+  } else {
+    XKEYPAD_LOOKUP pfuncLookup = pXData->pfuncLookup;
+    int16_t nKeyInd = (*pfuncLookup)(pGui, nKeyId);
+    pKeyStr = pXData->pacKeys[nKeyInd];
+  }
+
+  //GSLC_DEBUG2_PRINT("DBG: KeyId=%d R=%d C=%d str=[%s] SubElemMax=%d\n", nKeyId, nRow,nCol,pKeyStr,pXData->nSubElemMax);
+
+  if (bTxtField) {
+    // Text field
+    pElemRefTmp = gslc_ElemCreateTxt(pGui, nKeyId, GSLC_PAGE_NONE,
+      (gslc_tsRect) { nOffsetX + (nCol*nButtonSzW), nOffsetY + (nRow*nButtonSzH), nButtonW-1, nButtonH - 1 },
+      pKeyStr, XKEYPAD_VAL_LEN, nFontId);
+    gslc_ElemSetFrameEn(pGui, pElemRefTmp, true);
+    gslc_ElemSetTxtMargin(pGui, pElemRefTmp, 5); // Apply default margin
+  } else {
+    // Text button
+    //GSLC_DEBUG2_PRINT("DrawBtn: %d [%s] @ r=%d,c=%d,width=%d\n", nKeyId, pXData->pacKeys[nKeyId], nRow, nCol, nButtonW);
+    pElemRefTmp = gslc_ElemCreateBtnTxt(pGui, nKeyId, GSLC_PAGE_NONE,
+      (gslc_tsRect) { nOffsetX + (nCol*nButtonSzW), nOffsetY + (nRow*nButtonSzH), nButtonW - 1, nButtonH - 1 },
+      pKeyStr, sizeof(pKeyStr), nFontId, &gslc_ElemXKeyPadClick);
+    // For the text buttons, optionally use rounded profile if enabled
+    gslc_ElemSetRoundEn(pGui, pElemRefTmp, pConfig->bRoundEn);
+  }
+
+  // Set color
+  gslc_ElemSetTxtCol(pGui, pElemRefTmp, GSLC_COL_WHITE);
+  gslc_ElemSetCol(pGui, pElemRefTmp, GSLC_COL_WHITE, cColFill, cColGlow);
+
+  // Set the visibility status
+  // FIXME: Need to fix dynamic visibility change
+  // gslc_ElemSetVisible(pGui, pElemRefTmp, bVisible);
+  if (!bVisible) {
+    // For now, skip addition of invisible buttons
+	  return;
+  }
+
+  // Add element to compound element collection
+  pElemTmp = gslc_GetElemFromRef(pGui, pElemRefTmp);
+  pElemRefTmp = gslc_CollectElemAdd(pGui, &pXData->sCollect, pElemTmp, GSLC_ELEMREF_DEFAULT);
+}
+
+gslc_tsElemRef* gslc_ElemXKeyPadCreateBase(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXKeyPad* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig,
+  XKEYPAD_CREATE pfuncCreate, XKEYPAD_LOOKUP pfuncLookup)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXKeyPadCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return NULL;
+  }
+
+  // Fetch config options
+  int8_t nButtonSzW = pConfig->nButtonSzW;
+  int8_t nButtonSzH = pConfig->nButtonSzH;
+
+  gslc_tsRect rElem;
+  rElem.x = nX0;
+  rElem.y = nY0;
+  rElem.w = (nButtonSzW * pConfig->nMaxCols) + (2 * pConfig->nFrameMargin);
+  rElem.h = (nButtonSzH * pConfig->nMaxRows) + (2 * pConfig->nFrameMargin);
+
+  gslc_tsElem sElem;
+
+  // Initialize composite element
+  sElem = gslc_ElemCreate(pGui, nElemId, nPage, GSLC_TYPEX_KEYPAD, rElem, NULL, 0, GSLC_FONT_NONE);
+  sElem.nFeatures |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures &= ~GSLC_ELEM_FEA_GLOW_EN;  // Don't need to glow outer element
+  sElem.nGroup = GSLC_GROUP_ID_NONE;
+
+  gslc_CollectReset(&pXData->sCollect, pXData->psElem, pXData->nSubElemMax, pXData->psElemRef, pXData->nSubElemMax);
+
+  sElem.pXData = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw = &gslc_ElemXKeyPadDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch = &gslc_ElemXKeyPadTouch;
+
+  // shouldn't be used
+  sElem.colElemFill = GSLC_COL_BLACK;
+  sElem.colElemFillGlow = GSLC_COL_BLACK;
+  sElem.colElemFrame = GSLC_COL_BLUE;
+  sElem.colElemFrameGlow = GSLC_COL_BLUE_LT4;
+
+  // Now create the sub elements
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Determine offset coordinate of compound element so that we can
+  // specify relative positioning during the sub-element Create() operations.
+  int16_t nOffsetX = nX0 + pConfig->nFrameMargin;
+  int16_t nOffsetY = nY0 + pConfig->nFrameMargin;
+
+  // Reset value string
+  memset(pXData->acValStr, 0, XKEYPAD_VAL_LEN);
+  pXData->nValStrPos = 0;
+
+  pXData->pacKeys = pConfig->pacKeys;
+  pXData->pfuncCb = NULL;
+  pXData->pfuncLookup = pfuncLookup;
+  pXData->nTargetId = GSLC_ID_NONE;  // Default to no target defined
+  pXData->bValPositive = true;
+  pXData->bValDecimalPt = false;
+
+  // Update config with constructor settings
+  pConfig->nFontId = nFontId;
+  pConfig->nOffsetX = nOffsetX;
+  pConfig->nOffsetY = nOffsetY;
+
+
+  // Copy content into local structure
+  pXData->sConfig = *pConfig;
+
+  // Create the keypad definition
+  // -- Call XKeyPadCreateKeys()
+  if (pfuncCreate != NULL) {
+    (*pfuncCreate)(pGui, pXData);
+  }
+
+  // Now proceed to add the compound element to the page
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui, nPage, &sElem, GSLC_ELEMREF_DEFAULT);
+
+    // Now propagate the parent relationship to enable a cascade
+    // of redrawing from low-level elements to the top
+    gslc_CollectSetParent(pGui, &pXData->sCollect, pElemRef);
+    return pElemRef;
+  }
+  else {
+    #if defined(DEBUG_LOG)
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXKeyPadCreate(%s) Compound elements inside compound elements not supported\n", "");
+    #endif
+    return NULL;
+  }
+
+}
+
+void gslc_ElemXKeyPadValSet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, const char* pStrBuf)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+
+  // Copy over the new value string
+  strncpy(pKeyPad->acValStr, pStrBuf, XKEYPAD_VAL_LEN);
+  pKeyPad->acValStr[XKEYPAD_VAL_LEN - 1] = 0; // Force null terminate
+
+  // Handle negation and floating point detection
+  pKeyPad->bValPositive = true;
+  if (pKeyPad->acValStr[0] == KEYPAD_DISP_NEGATIVE) {
+    pKeyPad->bValPositive = false;
+  }
+  pKeyPad->bValDecimalPt = false;
+  if (strchr(pKeyPad->acValStr, KEYPAD_DISP_DECIMAL_PT)) {
+    pKeyPad->bValDecimalPt = true;
+  }
+
+  // Update the current buffer position
+  pKeyPad->nValStrPos = strlen(pKeyPad->acValStr);
+
+  // Find element associated with text field
+  gslc_tsElemRef* pTxtElemRef = gslc_CollectFindElemById(pGui, &pKeyPad->sCollect, KEYPAD_ID_TXT);
+
+  // Mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pTxtElemRef,GSLC_REDRAW_INC);
+}
+
+void gslc_ElemXKeyPadTargetIdSet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nTargetId)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+  pKeyPad->nTargetId = nTargetId;
+}
+
+int16_t gslc_ElemXKeyPadDataTargetIdGet(gslc_tsGui* pGui, void* pvData)
+{
+  if (pvData == NULL) {
+    #if defined(DEBUG_LOG)
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXKeyPadDataTargetIdGet() NULL data\n", "");
+    #endif
+    return GSLC_ID_NONE;
+  }
+  gslc_tsXKeyPadData* pData = (gslc_tsXKeyPadData*)pvData;
+  return pData->nTargetId;
+}
+
+char* gslc_ElemXKeyPadDataValGet(gslc_tsGui* pGui, void* pvData)
+{
+  if (pvData == NULL) {
+    #if defined(DEBUG_LOG)
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXKeyPadDataValGet() NULL data\n", "");
+    #endif
+    return NULL;
+  }
+  gslc_tsXKeyPadData* pData = (gslc_tsXKeyPadData*)pvData;
+  return pData->pStr;
+}
+
+
+
+// NOTE: API changed to pass nStrBufLen (total buffer size including terminator)
+//       instead of nStrBufMax (max index value)
+bool gslc_ElemXKeyPadValGet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, char* pStrBuf, uint8_t nStrBufLen)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return false;
+
+  // - Check for negation flag
+  // - If negative, copy minus sign
+  // - Copy the remainder of the string
+  // FIXME: check for shortest of XKEYPAD_VAL_LEN & nStrBufLen
+  char* pBufPtr = pStrBuf;
+  uint8_t nMaxCopyLen = nStrBufLen - 1;
+  // FIXME: Do we still need to do this step?
+  if (!pKeyPad->bValPositive) {
+    *pBufPtr = KEYPAD_DISP_NEGATIVE;
+    pBufPtr++;
+    nMaxCopyLen--;
+  }
+  strncpy(pBufPtr, pKeyPad->acValStr, nMaxCopyLen);
+  pStrBuf[nStrBufLen-1] = '\0';  // Force termination
+
+  // TODO: Do we need to reset the contents?
+
+  return true;
+}
+
+
+// Redraw the KeyPad element
+// - When drawing a KeyPad we do not clear the background.
+//   We do redraw the sub-element collection.
+bool gslc_ElemXKeyPadDraw(void* pvGui, void* pvElemRef, gslc_teRedrawType eRedraw)
+{
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return false;
+
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui, pElemRef);
+
+  // Draw any parts of the compound element itself
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    // Force the fill to ensure the background doesn't bleed thorugh gaps
+    // between the sub-elements
+    gslc_DrawFillRect(pGui, pElem->rElem, pElem->colElemFill);
+    if (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN) {
+      gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+    }
+  }
+
+  // Draw the sub-elements
+  gslc_tsCollect* pCollect = &pKeyPad->sCollect;
+
+  if (eRedraw != GSLC_REDRAW_NONE) {
+    uint8_t sEventSubType = GSLC_EVTSUB_DRAW_NEEDED;
+    if (eRedraw == GSLC_REDRAW_FULL) {
+      sEventSubType = GSLC_EVTSUB_DRAW_FORCE;
+    }
+    gslc_tsEvent  sEvent = gslc_EventCreate(pGui, GSLC_EVT_DRAW, sEventSubType, (void*)(pCollect), NULL);
+    gslc_CollectEvent(pGui, sEvent);
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui, true);
+
+  return true;
+}
+
+void gslc_ElemXKeyPadValSetCb(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_INPUT pfuncCb)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+
+  pKeyPad->pfuncCb = pfuncCb;
+}
+
+// Change the sign of the number string
+// - This function also performs in-place shifting of the content
+void gslc_ElemXKeyPadValSetSign(gslc_tsGui* pGui, gslc_tsElemRef *pElemRef, bool bPositive)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+
+  char* pStrBuf = pKeyPad->acValStr;
+
+  //GSLC_DEBUG2_PRINT("SetSign: old=%d new=%d\n", pKeyPad->bValPositive, bPositive);
+  if (pKeyPad->bValPositive == bPositive) {
+    // No change to sign
+    return;
+  }
+
+  //GSLC_DEBUG2_PRINT("SetSign:   str_old=[%s] idx=%d\n", pStrBuf,pKeyPad->nValStrPos);
+
+  if ((pKeyPad->bValPositive) && (!bPositive)) {
+    // Change from positive to negative
+    // - Shift string right one position, and replace first position with minus sign
+    // - Increase current buffer position
+    memmove(pStrBuf+1, pStrBuf, XKEYPAD_VAL_LEN-1);
+    pStrBuf[0] = KEYPAD_DISP_NEGATIVE; // Overwrite with minus sign
+    pStrBuf[XKEYPAD_VAL_LEN-1] = 0; // Force terminate
+    pKeyPad->nValStrPos++; // Advance buffer position
+  } else if ((!pKeyPad->bValPositive) && (bPositive)) {
+    // Change from negative to positive
+    // - Shift string left one position, overwriting the minus sign
+    memmove(pStrBuf, pStrBuf+1, XKEYPAD_VAL_LEN-1);
+    pStrBuf[XKEYPAD_VAL_LEN-1] = 0; // Force terminate
+    if (pKeyPad->nValStrPos > 0) {
+      // Expect that original position should be non-zero if previously minux
+      pKeyPad->nValStrPos--; // Reduce buffer position
+    }
+  }
+
+  //GSLC_DEBUG2_PRINT("SetSign:   str_new=[%s] idx=%d\n", pStrBuf,pKeyPad->nValStrPos);
+
+  // Update sign state
+  pKeyPad->bValPositive = bPositive;
+
+  // The text string sub-element content has already been updated,
+  // so now we can simply mark it for redraw
+  gslc_tsElemRef* pTxtElemRef = gslc_CollectFindElemById(pGui, &pKeyPad->sCollect, KEYPAD_ID_TXT);
+  gslc_ElemSetRedraw(pGui,pTxtElemRef,GSLC_REDRAW_INC);
+
+}
+
+bool ElemXKeyPadAddChar(gslc_tsGui* pGui, gslc_tsXKeyPad* pKeyPad, char ch)
+{
+  bool bRedraw = false;
+  // Do we have space for this character?
+  if (pKeyPad->nValStrPos < XKEYPAD_VAL_LEN - 1) {
+    pKeyPad->acValStr[pKeyPad->nValStrPos] = ch;
+    pKeyPad->nValStrPos++;
+    pKeyPad->acValStr[pKeyPad->nValStrPos] = '\0'; // Zero terminate
+    bRedraw = true;
+  }
+  return bRedraw;
+}
+
+// Handle the compound element main functionality
+// - This routine is called by gslc_ElemEvent() to handle
+//   any click events that resulted from the touch tracking process.
+// - The code here will generally represent the core
+//   functionality of the compound element and any communication
+//   between sub-elements.
+// - pvElemRef is a void pointer to the element ref being tracked. From
+//   the pElemRefParent member we can get the parent/compound element
+//   data structures.
+bool gslc_ElemXKeyPadClick(void* pvGui, void *pvElemRef, gslc_teTouch eTouch, int16_t nX, int16_t nY)
+{
+  #if defined(DRV_TOUCH_NONE)
+  return false;
+  #else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+
+  // Fetch the parent of the clicked element which is the compound
+  // element itself. This enables us to access the extra control data.
+  gslc_tsElemRef*    pElemRefParent = pElem->pElemRefParent;
+  if (pElemRefParent == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXKeyPadClick(%s) parent ElemRef ptr NULL\n", "");
+    return false;
+  }
+
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRefParent, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return false;
+
+  //GSLC_DEBUG2_PRINT("KeyPad Click   Touch=%d\n", eTouch);
+
+  // Handle the various button presses
+  if (eTouch == GSLC_TOUCH_UP_IN) {
+    // Get the tracked element ID
+    gslc_tsElemRef* pElemRefTracked = pKeyPad->sCollect.pElemRefTracked;
+    gslc_tsElem*    pElemTracked = gslc_GetElemFromRef(pGui, pElemRefTracked);
+
+    int nSubElemId = pElemTracked->nId;
+    int16_t nKeyInd = 0;
+    bool bValRedraw = false;
+
+    GSLC_CB_INPUT pfuncXInput = pKeyPad->pfuncCb;
+    XKEYPAD_LOOKUP pfuncLookup = pKeyPad->pfuncLookup;
+    gslc_tsXKeyPadData sKeyPadData;
+
+    if (pfuncLookup != NULL) {
+      // FIXME: ERROR
+    }
+
+    // Prepare the return data
+    sKeyPadData.pStr = pKeyPad->acValStr;
+    sKeyPadData.nTargetId = pKeyPad->nTargetId;
+
+    //GSLC_DEBUG2_PRINT("KeyPad Click   ID=%d\n", nSubElemId);
+
+    switch (nSubElemId) {
+
+    case KEYPAD_ID_ENTER:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=ENT\n", "");
+      //GSLC_DEBUG2_PRINT("KeyPad Done Str=[%s]\n", pKeyPad->acValStr);
+
+   
+      // Issue callback with Done status
+      if (pfuncXInput != NULL) {
+        (*pfuncXInput)(pvGui, (void*)(pElemRefParent), XKEYPAD_CB_STATE_DONE, (void*)(&sKeyPadData));
+      }
+
+      // Clear the contents
+      memset(pKeyPad->acValStr, 0, XKEYPAD_VAL_LEN);
+      pKeyPad->nValStrPos = 0;
+      pKeyPad->nTargetId = GSLC_ID_NONE;
+      break;
+
+    case KEYPAD_ID_ESC:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=ESC\n", "");
+      // Clear the contents
+      memset(pKeyPad->acValStr, 0, XKEYPAD_VAL_LEN);
+      pKeyPad->nValStrPos = 0;
+      pKeyPad->nTargetId = GSLC_ID_NONE;    
+      bValRedraw = true;
+      //GSLC_DEBUG2_PRINT("KeyPad Done Str=[%s]\n", pKeyPad->acValStr);
+      // Issue callback with Cancel status
+      if (pfuncXInput != NULL) {
+        (*pfuncXInput)(pvGui, (void*)(pElemRefParent), XKEYPAD_CB_STATE_CANCEL, (void*)(&sKeyPadData));
+      }
+      break;
+
+    case KEYPAD_ID_DECIMAL:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=Decimal\n", "");
+      if (!pKeyPad->sConfig.bFloatEn) break; // Ignore if floating point not enabled
+      if (!pKeyPad->bValDecimalPt) {
+        bValRedraw |= ElemXKeyPadAddChar(pGui, pKeyPad, KEYPAD_DISP_DECIMAL_PT);
+      }
+      break;
+
+    case KEYPAD_ID_MINUS:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=Minus\n", "");
+      if (!pKeyPad->sConfig.bSignEn) break; // Ignore if negative numbers not enabled
+      // Toggle sign
+      gslc_ElemXKeyPadValSetSign(pGui, pElemRefParent, pKeyPad->bValPositive ? false : true);
+      bValRedraw = true;
+      break;
+
+    case KEYPAD_ID_BACKSPACE:
+      //GSLC_DEBUG2_PRINT("KeyPad Key=BS\n", "");
+      if (pKeyPad->nValStrPos < 1) break;
+      pKeyPad->nValStrPos--;
+      // Handle the special case of decimal point if floating point enabled
+      if (pKeyPad->sConfig.bFloatEn) {
+        if (pKeyPad->acValStr[pKeyPad->nValStrPos] == KEYPAD_DISP_DECIMAL_PT) {
+          //GSLC_DEBUG2_PRINT("KeyPad Key=BS across decimal\n", "");
+          pKeyPad->bValDecimalPt = false;
+        }
+      }
+      if (pKeyPad->nValStrPos == 0) {
+        memset(pKeyPad->acValStr, 0, XKEYPAD_VAL_LEN);
+        pKeyPad->bValPositive = true;
+      }
+      pKeyPad->acValStr[pKeyPad->nValStrPos] = '\0';
+      bValRedraw = true;
+      break;
+
+    case KEYPAD_ID_PERIOD:
+    case KEYPAD_ID_SPACE:
+    default:
+      // Normal character
+      //GSLC_DEBUG2_PRINT("KeyPad Key=Digit\n", "");
+      // For basic buttons, we need to fetch the keypad string index
+      nKeyInd = (*pfuncLookup)(pGui, nSubElemId);
+      bValRedraw |= ElemXKeyPadAddChar(pGui, pKeyPad, pKeyPad->pacKeys[nKeyInd][0]);
+      break;
+    } // switch
+
+    // Do we need to redraw the text field?
+    if (bValRedraw) {
+      pElemRef = gslc_CollectFindElemById(pGui, &pKeyPad->sCollect, KEYPAD_ID_TXT);
+      gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_INC);
+      // Issue callback with Update status
+      if (pfuncXInput != NULL) {
+        (*pfuncXInput)(pvGui, (void*)(pElemRefParent), XKEYPAD_CB_STATE_UPDATE, (void*)(&sKeyPadData));
+      }
+    } // bValRedraw
+
+  } // eTouch
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+bool gslc_ElemXKeyPadTouch(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY)
+{
+  #if defined(DRV_TOUCH_NONE)
+  return false;
+  #else
+
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXKeyPadTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+  gslc_tsElem*          pElem = NULL;
+  gslc_tsXKeyPad*       pKeyPad = NULL;
+
+
+  // Typecast the parameters to match the GUI
+  pGui = (gslc_tsGui*)(pvGui);
+  pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  pElem = gslc_GetElemFromRef(pGui, pElemRef);
+  pKeyPad = (gslc_tsXKeyPad*)(pElem->pXData);
+
+  // Get Collection
+  gslc_tsCollect* pCollect = &pKeyPad->sCollect;
+
+  // Cascade the touch event to the sub-element collection
+  return gslc_CollectTouchCompound(pvGui, pvElemRef, eTouch, nRelX, nRelY, pCollect);
+  #endif // !DRV_TOUCH_NONE
+}
+
+
+
+void gslc_ElemXKeyPadCfgSetButtonSz(gslc_tsXKeyPadCfg* pConfig, int8_t nButtonSzW, int8_t nButtonSzH)
+{
+  pConfig->nButtonSzW = nButtonSzW;
+  pConfig->nButtonSzH = nButtonSzH;
+}
+
+void gslc_ElemXKeyPadCfgSetFloatEn(gslc_tsXKeyPadCfg* pConfig, bool bEn)
+{
+  pConfig->bFloatEn = bEn;
+}
+
+void gslc_ElemXKeyPadCfgSetSignEn(gslc_tsXKeyPadCfg* pConfig, bool bEn)
+{
+  pConfig->bSignEn = bEn;
+}
+
+void gslc_ElemXKeyPadCfgSetRoundEn(gslc_tsXKeyPadCfg* pConfig, bool bEn)
+{
+  pConfig->bRoundEn = bEn;
+}
+
+
+// FIXME: Runtime API not fully functional yet - Do not use
+void gslc_ElemXKeyPadSetFloatEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bEn)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+  pKeyPad->sConfig.bFloatEn = bEn;
+  // Mark as needing full redraw as button visibility may have changed
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+// FIXME: Runtime API not fully functional yet - Do not use
+void gslc_ElemXKeyPadSetSignEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bEn)
+{
+  gslc_tsXKeyPad* pKeyPad = (gslc_tsXKeyPad*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_KEYPAD, __LINE__);
+  if (!pKeyPad) return;
+  pKeyPad->sConfig.bSignEn = bEn;
+  // Mark as needing full redraw as button visibility may have changed
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXKeyPadInputAsk(gslc_tsGui* pGui, gslc_tsElemRef* pKeyPadRef, int16_t nPgPopup, gslc_tsElemRef* pTxtRef)
+{
+  // Fetch the Element ID from the text element
+  gslc_tsElem* pTxtElem = gslc_GetElemFromRefD(pGui,pTxtRef,__LINE__);
+  if (!pTxtElem) return;
+  int16_t nTxtElemId = pTxtElem->nId;
+
+  // Associate the keypad with the text field
+  gslc_ElemXKeyPadTargetIdSet(pGui, pKeyPadRef, nTxtElemId);
+  // Show a popup box for the keypad
+  gslc_PopupShow(pGui, nPgPopup, true);
+  // Preload text field with current value
+  gslc_ElemXKeyPadValSet(pGui, pKeyPadRef, gslc_ElemGetTxtStr(pGui, pTxtRef));
+}
+
+char* gslc_ElemXKeyPadInputGet(gslc_tsGui* pGui, gslc_tsElemRef* pTxtRef, void* pvCbData)
+{
+  char* pStr = NULL;
+  // Fetch the current value of the keypad popup
+  pStr = gslc_ElemXKeyPadDataValGet(pGui, pvCbData);
+  // Update the linked text item
+  gslc_ElemSetTxtStr(pGui, pTxtRef, gslc_ElemXKeyPadDataValGet(pGui, pvCbData));
+  // Hide the popup
+  gslc_PopupHide(pGui);
+
+  // Return the text string in case the user wants it
+  return pStr;
+}
+
+
+
+#endif // GSLC_FEATURE_COMPOUND
+
+
+// ============================================================================
diff --git a/src/guislice/XKeyPad.h b/src/guislice/XKeyPad.h
new file mode 100644
index 0000000..5a1a1bc
--- /dev/null
+++ b/src/guislice/XKeyPad.h
@@ -0,0 +1,409 @@
+#ifndef _GUISLICE_EX_XKEYPAD_H_
+#define _GUISLICE_EX_XKEYPAD_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: XKeyPad control
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XKeyPad.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: KeyPad (Number Selector)
+// - Demonstration of a compound element consisting of
+//   a counter text field along with an increment and
+//   decrement button.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define GSLC_TYPEX_KEYPAD GSLC_TYPE_BASE_EXTEND + 20
+
+#define XKEYPAD_VAL_LEN  12  // Maximum buffer length for input string
+
+// Define the status for GSLC_CB_INPUT callback
+#define XKEYPAD_CB_STATE_DONE 1
+#define XKEYPAD_CB_STATE_CANCEL 2
+#define XKEYPAD_CB_STATE_UPDATE 3
+
+
+// Define global list of button ID types
+// - A given keypad may not use all of these
+enum {
+  // --------------------------------------------
+  // --- Special Buttons
+  KEYPAD_ID_BACKSPACE,
+  KEYPAD_ID_PERIOD,
+  KEYPAD_ID_SPACE,
+  KEYPAD_ID_DECIMAL,
+  KEYPAD_ID_MINUS,
+  KEYPAD_ID_ESC,
+  KEYPAD_ID_ENTER,
+  // --- Basic Buttons
+  KEYPAD_ID_BASIC_START=100,
+  // --------------------------------------------
+  // --- Extra elements
+  KEYPAD_ID_TXT=200,        // Value string text area
+};
+
+/// Function for KeyPad creation
+typedef int16_t (*XKEYPAD_LOOKUP)(gslc_tsGui* pGui, int16_t nKeyId);
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+  /// Configuration for the KeyPad
+  typedef struct {
+    bool                bFloatEn;         ///< Enable floating point (ie. decimal point)
+    bool                bSignEn;          ///< Enable negative numbers
+	  bool                bRoundEn;         ///< Enable rounded corners
+    int8_t              nButtonSzW;       ///< Button width (in pixels)
+    int8_t              nButtonSzH;       ///< Button height (in pixels)
+    char**              pacKeys;          ///< Array of character strings for KeyPad labels
+
+    // From constructor
+    int16_t             nFontId;          ///< Configured font for KeyPad labels
+    int16_t             nOffsetX;         ///< Configured offset (X direction) for buttons from parent container
+    int16_t             nOffsetY;         ///< Configured offset (Y direction) for buttons from parent container
+
+    int8_t              nFrameMargin;     ///< Margin around text value field
+    uint8_t             nMaxCols;         ///< Maximum number of columns to occupy
+    uint8_t             nMaxRows;         ///< Maximum number of rows to occupy
+  } gslc_tsXKeyPadCfg;
+
+  /// Input callback data structure
+  /// - This struct is returned in GSLC_CB_INPUT when the
+  ///   KeyPad edits are complete, and is used to provide
+  ///   the resulting edited value.
+  typedef struct {
+    char*               pStr;             ///< Final value of edited value field
+    int16_t             nTargetId;        ///< Target element ID to receive the value
+  } gslc_tsXKeyPadData;
+
+  /// Extended data for KeyPad element
+  typedef struct {
+
+    // State
+    uint8_t             nValStrPos;       ///< Current number of characters stored in edit value string
+    char                acValStr[XKEYPAD_VAL_LEN];  ///< Storage for edit value string
+    bool                bValPositive;     ///< Value is positive if true, negative if false
+    bool                bValDecimalPt;    ///< Value string includes decimal point
+
+    // Config
+    char**              pacKeys;          ///< Array of character strings for KeyPad labels
+    gslc_tsXKeyPadCfg   sConfig;          ///< Configuration options
+
+    GSLC_CB_INPUT       pfuncCb;          ///< Callback function for KeyPad actions
+    XKEYPAD_LOOKUP      pfuncLookup;      ///< Callback function for converting key into key label
+    int16_t             nTargetId;        ///< Target element ID associated with keypad (GSLC_CB_INPUT)
+
+    // Internal sub-element members
+    gslc_tsCollect      sCollect;         ///< Collection management for sub-elements
+    uint8_t             nSubElemMax;      ///< Maximum number of sub-elements to create within KeyPad container
+    gslc_tsElemRef*     psElemRef;        ///< Ptr to storage for sub-element references
+    gslc_tsElem*        psElem;           ///< Ptr to storage for sub-elements
+
+  } gslc_tsXKeyPad;
+
+
+// Callback function for KeyPad creation
+typedef void (*XKEYPAD_CREATE)(gslc_tsGui* pGui,gslc_tsXKeyPad* pXData);
+
+
+  ///
+  /// Add a key to the KeyPad control
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pXData:      Ptr to extended element data structure
+  /// \param[in]  nKeyId:      ID to associated with the key
+  /// \param[in]  bTxtField:   Is this the text value field?
+  /// \param[in]  nRow:        Element placement position (row index, 0 at top)
+  /// \param[in]  nCol:        Element placement position (column index, 0 at left)
+  /// \param[in]  nRowSpan:    Number of columns to occupy by element (1 for normal size, 2 for double width)
+  /// \param[in]  nColSpan:    Number of rows to occupy by element (1 for normal size, 2 for double height)
+  /// \param[in]  cColFill:    Fill color for element
+  /// \param[in]  cColGlow:    Fill color for element when glowing
+  /// \param[in]  bVisible:    Initial key visibility state
+  ///
+  /// \return none
+  ///
+void XKeyPadAddKeyElem(gslc_tsGui* pGui, gslc_tsXKeyPad* pXData, int16_t nKeyId, bool bTxtField, int16_t nRow, int16_t nCol,
+  int8_t nRowSpan, int8_t nColSpan, gslc_tsColor cColFill, gslc_tsColor cColGlow, bool bVisible);
+
+  ///
+  /// Create a KeyPad Element
+  ///
+  /// \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]  pXData:      Ptr to extended element data structure
+  /// \param[in]  nX0:         X KeyPad Starting Coordinate 
+  /// \param[in]  nY0:         Y KeyPad Starting Coordinate 
+  /// \param[in]  nFontId:     Font ID to use for drawing the element
+  /// \param[in]  pConfig:     Ptr to Config options
+  /// \param[in]  pfuncCreate: Ptr to callback function for creation
+  /// \param[in]  pfuncLookup: Ptr to callback function for button lookups
+  ///
+  /// \return Pointer to Element or NULL if failure
+  ///
+  gslc_tsElemRef* gslc_ElemXKeyPadCreateBase(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+    gslc_tsXKeyPad* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig,
+    XKEYPAD_CREATE pfuncCreate, XKEYPAD_LOOKUP pfuncLookup);
+
+
+  ///
+  /// Set the current value for the editable text field
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:   Ptr to KeyPad Element reference
+  /// \param[in]  pStrBuf:     String to copy into keypad
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadValSet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, const char* pStrBuf);
+
+  ///
+  /// Set target element ID for KeyPad return value
+  /// - The Target ID is used in the GSLC_CB_INPUT callback so that the user
+  ///   has the context needed to determine which field should be edited
+  ///   with the contents of the KeyPad edit field
+  /// - It is expected that the user will call this function when showing
+  ///   the KeyPad popup dialog
+  ///
+  /// \param[in]  pGui:       Pointer to GUI
+  /// \param[in]  pElemRef:   Ptr to KeyPad Element reference
+  /// \param[in]  nId:        Element enum ID for target of KeyPad value
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadTargetIdSet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nId);
+
+
+  ///
+  /// Set the current output string buffer associated with NumericInput element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:    Ptr to KeyPad Element reference
+  /// \param[in]  pStrBuf:     String to copy into element
+  /// \param[in]  nStrBufMax:  Maximum length of string buffer (pStrBuf)
+  ///
+  /// \return none
+  ///
+  bool gslc_ElemXKeyPadValGet(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, char* pStrBuf, uint8_t nStrBufMax);
+
+  ///
+  /// Fetch the edited value string from the KeyPad
+  ///
+  /// \param[in]  pGui:       Pointer to GUI
+  /// \param[in]  pvData :    Void ptr to callback data structure
+  ///
+  /// \return Pointer to edited character string
+  ///
+  char* gslc_ElemXKeyPadDataValGet(gslc_tsGui* pGui, void* pvData);
+
+
+  ///
+  /// Fetch the element target ID associated with this KeyPad
+  ///
+  /// \param[in]  pGui:       Pointer to GUI
+  /// \param[in]  pvData :    Void ptr to callback data structure
+  ///
+  /// \return Target Element ID or GSLC_ID_NONE if unspecified
+  ///
+  int16_t gslc_ElemXKeyPadDataTargetIdGet(gslc_tsGui* pGui, void* pvData);
+
+  ///
+  /// Draw a KeyPad element on the screen
+  /// - Called during redraw
+  ///
+  /// \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]  eRedraw:     Redraw mode
+  ///
+  /// \return true if success, false otherwise
+  ///
+  bool gslc_ElemXKeyPadDraw(void* pvGui, void* pvElemRef, gslc_teRedrawType eRedraw);
+
+  ///
+  /// Handle a click event within the KeyPad
+  /// - This is called internally by the KeyPad touch handler
+  ///
+  /// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+  /// \param[in]  pvElemRef:   Void ptr to Element Ref (typecast to gslc_tsElemRef*)
+  /// \param[in]  eTouch:      Touch event type
+  /// \param[in]  nX:          Touch X coord
+  /// \param[in]  nY:          Touch Y coord
+  ///
+  /// \return none
+  ///
+  bool gslc_ElemXKeyPadClick(void* pvGui, void *pvElemRef, gslc_teTouch eTouch, int16_t nX, int16_t nY);
+
+  ///
+  /// Handle touch (up,down,move) events to KeyPad element
+  /// - Called from gslc_ElemSendEventTouch()
+  ///
+  /// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+  /// \param[in]  pvElemRef:   Void ptr to Element ref (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
+  ///
+  /// \return true if success, false otherwise
+  ///
+  bool gslc_ElemXKeyPadTouch(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY);
+
+  ///
+  /// Set the callback function associated with the KeyPad
+  /// - This function will be called during updates and OK / Cancel
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:    Pointer to Element Reference for KeyPad
+  /// \param[in]  pfuncCb:     Callback function pointer
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadValSetCb(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, GSLC_CB_INPUT pfuncCb);
+
+  ///
+  /// Update the KeyPad configuration to enable floating point numbers
+  /// - Effectively disables/enables the decimal point button & handling
+  ///
+  /// \param[in]  pConfig:     Pointer to the XKeyPad config structure
+  /// \param[in]  bEn:         Enable flag (true if floating point enabled)
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadCfgSetFloatEn(gslc_tsXKeyPadCfg* pConfig,bool bEn);
+
+  ///
+  /// Update the KeyPad configuration to enable negative numbers
+  /// - Effectively disables/enables the sign button & handling
+  ///
+  /// \param[in]  pConfig:     Pointer to the XKeyPad config structure
+  /// \param[in]  bEn:         Enable flag (true if negative numbers enabled)
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadCfgSetSignEn(gslc_tsXKeyPadCfg* pConfig,bool bEn);
+
+  ///
+  /// Update the KeyPad configuration to enable rounded button corners
+  ///
+  /// \param[in]  pConfig:     Pointer to the XKeyPad config structure
+  /// \param[in]  bEn:         Enable rounded corners
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadCfgSetRoundEn(gslc_tsXKeyPadCfg* pConfig,bool bEn);
+
+  ///
+  /// Update the KeyPad configuration to define the KeyPad button sizing
+  ///
+  /// \param[in]  pConfig:     Pointer to the XKeyPad config structure
+  /// \param[in]  nButtonSzW:  Width of buttons in pixels
+  /// \param[in]  nButtonSzH:  Width of buttons in pixels
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadCfgSetButtonSz(gslc_tsXKeyPadCfg* pConfig, int8_t nButtonSzW, int8_t nButtonSzH);
+
+  ///
+  /// Update the KeyPad active configuration to enable negative numbers
+  /// - Effectively disables/enables the sign button & handling
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:    Pointer to KeyPad element reference
+  /// \param[in]  bEn:         Enable flag (true if negative numbers enabled)
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadSetFloatEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bEn);
+
+  ///
+  /// Update the KeyPad active configuration to enable negative numbers
+  /// - Effectively disables/enables the sign button & handling
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pElemRef:    Pointer to KeyPad element reference
+  /// \param[in]  bEn:         Enable flag (true if negative numbers enabled)
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadSetSignEn(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, bool bEn);
+
+  ///
+  /// Trigger a KeyPad popup and associate it with a text element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pKeyPadRef:  Pointer to KeyPad element reference
+  /// \param[in]  nPgPopup:    Page enum that contains the popup to show
+  /// \param[in]  pTxtRef:     Pointer to associated text field element reference
+  ///
+  /// \return none
+  ///
+  void gslc_ElemXKeyPadInputAsk(gslc_tsGui* pGui, gslc_tsElemRef* pKeyPadRef, int16_t nPgPopup, gslc_tsElemRef* pTxtRef);
+
+  ///
+  /// Complete a KeyPad popup by retrieving the input data and storing it in the text element
+  ///
+  /// \param[in]  pGui:        Pointer to GUI
+  /// \param[in]  pTxtRef:     Pointer to associated text field element reference
+  /// \param[in]  pvCbData:    Void pointer to callback function's pvData
+  ///
+  /// \return The text string that was fetched from the KeyPad
+  ///
+  char* gslc_ElemXKeyPadInputGet(gslc_tsGui* pGui, gslc_tsElemRef* pTxtRef, void* pvCbData);
+
+
+  #endif // GSLC_FEATURE_COMPOUND
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XKEYPAD_H_
+
diff --git a/src/guislice/XKeyPad_Alpha.c b/src/guislice/XKeyPad_Alpha.c
new file mode 100644
index 0000000..ef05272
--- /dev/null
+++ b/src/guislice/XKeyPad_Alpha.c
@@ -0,0 +1,204 @@
+// =======================================================================
+// GUIslice library extension: XKeyPad control (Alpha entry)
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XKeyPad.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XKeyPad.h"
+#include "XKeyPad_Alpha.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: KeyPad
+// - Keypad element with alpha input
+// ============================================================================
+
+// Define the button labels
+// - TODO: Create more efficient storage for the labels
+//   so that it doesn't consume 4 bytes even for labels
+//   that can be generated (eg. 0..9, a--z, etc.)
+// - TODO: Support use of PROGMEM. Note that these labels
+//   are not currently using "const char" since we may
+//   want to support user-modification of the labels.
+
+static char* KEYPAD_LABEL_STRINGS[] = {
+  // Special buttons
+  "<", ".", " ", "ESC", "ENT",
+  // Basic buttons
+  "A", "B", "C", "D", "E", "F", "G", "H" ,"I", "J",
+  "K", "L", "M", "N", "O", "P", "Q", "R" ,"S", "T",
+  "U", "V", "W", "X", "Y", "Z",
+};
+
+// Define enums for KEYPAD_LABEL_STRINGS
+enum {
+  // - Special buttons
+  KEYPAD_LBL_BACKSPACE,
+  KEYPAD_LBL_PERIOD,
+  KEYPAD_LBL_SPACE,
+  KEYPAD_LBL_ESC,
+  KEYPAD_LBL_ENTER,
+  // - Basic buttons
+  KEYPAD_LBL_BASIC_START
+};
+
+
+// Generate the keypad layout
+void XKeyPadCreateKeys_Alpha(gslc_tsGui* pGui, gslc_tsXKeyPad* pXData)
+{
+  int16_t nKeyInd;
+  int16_t nRow, nCol;
+
+  // - Create the "special" buttons
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_BACKSPACE, false, 1, 6, 1, 2, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_PERIOD, false, 3, 7, 1, 1, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_SPACE, false, 3, 6, 1, 1, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_ESC, false, 2, 6, 1, 2, GSLC_COL_RED, GSLC_COL_RED_LT4, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_ENTER, false, 0, 6, 1, 2, GSLC_COL_GREEN, GSLC_COL_GREEN_LT4, true);
+
+  // - Create the "simple" buttons
+  for (int16_t nKeyId = KEYPAD_ID_BASIC_START; nKeyId < (KEYPAD_ID_BASIC_START + XKEYPADALPHA_BTN_BASIC); nKeyId++) {
+    nKeyInd = nKeyId - KEYPAD_ID_BASIC_START;
+    nRow = (nKeyInd / 6) + 1;
+    nCol = nKeyInd % 6;
+    XKeyPadAddKeyElem(pGui, pXData, nKeyId, false, nRow, nCol, 1, 1, GSLC_COL_BLUE_LT1, GSLC_COL_BLUE_LT4, true);
+  }
+
+  // - Create the text field
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_TXT, true, 0, 0, 1, 6, GSLC_COL_BLACK, GSLC_COL_BLACK, true);
+}
+
+// Convert between keypad ID and the index into the keypad label array
+int16_t XKeyPadLookup_Alpha(gslc_tsGui* pGui, int16_t nKeyId)
+{
+  int16_t nKeyInd;
+
+  // Basic button
+  if (nKeyId >= KEYPAD_ID_BASIC_START) {
+    nKeyInd = (nKeyId - KEYPAD_ID_BASIC_START) + KEYPAD_LBL_BASIC_START;
+  } else {
+    // Special button
+    switch (nKeyId) {
+    case KEYPAD_ID_PERIOD:
+      nKeyInd = KEYPAD_LBL_PERIOD;
+      break;
+    case KEYPAD_ID_SPACE:
+      nKeyInd = KEYPAD_LBL_SPACE;
+      break;
+    case KEYPAD_ID_BACKSPACE:
+      nKeyInd = KEYPAD_LBL_BACKSPACE;
+      break;
+    case KEYPAD_ID_ESC:
+      nKeyInd = KEYPAD_LBL_ESC;
+      break;
+    case KEYPAD_ID_ENTER:
+      nKeyInd = KEYPAD_LBL_ENTER;
+      break;
+    default:
+      // FIXME: ERROR
+      nKeyInd = -1; // Not expected
+      break;
+    }
+  }
+  return nKeyInd;
+}
+
+// Create the XKeyPad_Alpha compound element
+// - Note that this also revises some of the members of the base XKeyPad struct
+gslc_tsElemRef* gslc_ElemXKeyPadCreate_Alpha(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXKeyPad_Alpha* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig)
+{
+  gslc_tsXKeyPad* pXDataBase = (gslc_tsXKeyPad*)pXData;
+  pXDataBase->nSubElemMax = XKEYPADALPHA_ELEM_MAX;
+  pXDataBase->psElemRef = pXData->asElemRef;
+  pXDataBase->psElem = pXData->asElem;
+
+  // Provide default config if none supplied
+  gslc_tsXKeyPadCfg sConfigTmp;
+  if (pConfig == NULL) {
+    sConfigTmp = gslc_ElemXKeyPadCfgInit_Alpha();
+    pConfig = &sConfigTmp;
+  }
+
+  return gslc_ElemXKeyPadCreateBase(pGui, nElemId, nPage, pXDataBase, nX0, nY0, nFontId, pConfig,
+    &XKeyPadCreateKeys_Alpha,&XKeyPadLookup_Alpha);
+}
+
+// Reset the XKeyPad config struct
+// - This must be called before any XKeyPad config update APIs are called
+gslc_tsXKeyPadCfg gslc_ElemXKeyPadCfgInit_Alpha()
+{
+  gslc_tsXKeyPadCfg sConfig;
+  sConfig.nButtonSzW = 25;
+  sConfig.nButtonSzH = 25;
+  sConfig.bFloatEn = false; // Unused
+  sConfig.bSignEn = false; // Unused
+  sConfig.bRoundEn = false;
+  sConfig.nFontId = GSLC_FONT_NONE; // Will be overwritten
+  sConfig.pacKeys = KEYPAD_LABEL_STRINGS;
+  sConfig.nMaxCols = 8;
+  sConfig.nMaxRows = 6;
+  sConfig.nFrameMargin = 2;
+  return sConfig;
+}
+
+#endif // GSLC_FEATURE_COMPOUND
+
+// ============================================================================
diff --git a/src/guislice/XKeyPad_Alpha.h b/src/guislice/XKeyPad_Alpha.h
new file mode 100644
index 0000000..94f259e
--- /dev/null
+++ b/src/guislice/XKeyPad_Alpha.h
@@ -0,0 +1,100 @@
+#ifndef _GUISLICE_EX_XKEYPAD_ALPHA_H_
+#define _GUISLICE_EX_XKEYPAD_ALPHA_H_
+
+#include "GUIslice.h"
+
+#include "XKeyPad.h"
+
+// =======================================================================
+// GUIslice library extension: XKeyPad control (alpha entry)
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XKeyPad.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// Define number of buttons & elements
+// - Refer to the definitions in the XKeyPad_*.c file
+#define XKEYPADALPHA_BTN_BASIC 26
+#define XKEYPADALPHA_ELEM_MAX (6 + XKEYPADALPHA_BTN_BASIC)
+
+// ============================================================================
+// Extended Element: KeyPad Character entry
+// - NOTE: The XKeyPad_Alpha extends the XKeyPad base element
+// ============================================================================
+
+typedef struct {
+  // Base XKeyPad struct
+  // - The base type must appear at the top of the derived struct
+  gslc_tsXKeyPad      sKeyPad;                             ///< Base XKeyPad element
+
+  gslc_tsElemRef      asElemRef[XKEYPADALPHA_ELEM_MAX];    ///< Storage for sub-element references
+  gslc_tsElem         asElem[XKEYPADALPHA_ELEM_MAX];       ///< Storage for sub-elements
+} gslc_tsXKeyPad_Alpha;
+
+  ///
+  /// Create a KeyPad Element
+  ///
+  /// \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]  pXData:      Ptr to extended element data structure
+  /// \param[in]  nX0:         X KeyPad Starting Coordinate 
+  /// \param[in]  nY0:         Y KeyPad Starting Coordinate 
+  /// \param[in]  nFontId:     Font ID to use for drawing the element
+  /// \param[in]  pConfig:     Ptr to config options
+  ///
+  /// \return Pointer to Element or NULL if failure
+  ///
+  gslc_tsElemRef* gslc_ElemXKeyPadCreate_Alpha(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+    gslc_tsXKeyPad_Alpha* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig);
+
+
+  ///
+  /// Initialize the KeyPad config structure
+  /// - This routine should be called to initialize the configuration
+  ///   data structure before calling any of the KeyPad config APIs
+  ///
+  /// \return Initialized KeyPad config structure
+  ///
+  gslc_tsXKeyPadCfg gslc_ElemXKeyPadCfgInit_Alpha();
+
+// ============================================================================
+
+#endif // GSLC_FEATURE_COMPOUND
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XKEYPAD_ALPHA_H_
+
diff --git a/src/guislice/XKeyPad_Num.c b/src/guislice/XKeyPad_Num.c
new file mode 100644
index 0000000..bcc64ee
--- /dev/null
+++ b/src/guislice/XKeyPad_Num.c
@@ -0,0 +1,206 @@
+// =======================================================================
+// GUIslice library extension: XKeyPad control (Numeric entry)
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XKeyPad.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XKeyPad.h"
+#include "XKeyPad_Num.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: KeyPad
+// - Keypad element with numeric input
+// - Optionally supports floating point values
+// - Optionally supports negative values
+// ============================================================================
+
+// Define the button labels
+// - TODO: Create more efficient storage for the labels
+//   so that it doesn't consume 4 bytes even for labels
+//   that can be generated (eg. 0..9, a--z, etc.)
+// - TODO: Support use of PROGMEM. Note that these labels
+//   are not currently using "const char" since we may
+//   want to support user-modification of the labels.
+
+static char* KEYPAD_LABEL_STRINGS[] = {
+  // Special buttons
+  "<", ".", "-", "ESC", "ENT",
+  // Basic buttons
+  "0", "1", "2", "3", "4", "5", "6", "7" ,"8", "9",
+};
+// Define enums for KEYPAD_LABEL_STRINGS
+enum {
+  // - Special buttons
+  KEYPAD_LBL_BACKSPACE,
+  KEYPAD_LBL_DECIMAL,
+  KEYPAD_LBL_MINUS,
+  KEYPAD_LBL_ESC,
+  KEYPAD_LBL_ENTER,
+  // - Basic buttons
+  KEYPAD_LBL_BASIC_START
+};
+
+
+// Generate the keypad layout
+void XKeyPadCreateKeys_Num(gslc_tsGui* pGui, gslc_tsXKeyPad* pXData)
+{
+  int16_t nKeyInd;
+  int16_t nRow, nCol;
+  gslc_tsXKeyPadCfg* pConfig = &pXData->sConfig;
+  
+
+  // - Create the "special" buttons
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_BACKSPACE, false, 1, 6, 1, 2, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_MINUS, false, 1, 5, 1, 1, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, pConfig->bSignEn);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_DECIMAL, false, 2, 5, 1, 1, GSLC_COL_GRAY_LT1, GSLC_COL_GRAY_LT3, pConfig->bFloatEn);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_ESC, false, 2, 6, 1, 2, GSLC_COL_RED, GSLC_COL_RED_LT4, true);
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_ENTER, false, 0, 6, 1, 2, GSLC_COL_GREEN, GSLC_COL_GREEN_LT4, true);
+
+  // - Create the "simple" buttons
+  for (int16_t nKeyId = KEYPAD_ID_BASIC_START; nKeyId < (KEYPAD_ID_BASIC_START + XKEYPADNUM_BTN_BASIC); nKeyId++) {
+    nKeyInd = nKeyId - KEYPAD_ID_BASIC_START;
+    nRow = (nKeyInd / 5) + 1;
+    nCol = nKeyInd % 5;
+    XKeyPadAddKeyElem(pGui, pXData, nKeyId, false, nRow, nCol, 1, 1, GSLC_COL_BLUE_LT1, GSLC_COL_BLUE_LT4, true);
+  }
+
+  // - Create the text field
+  XKeyPadAddKeyElem(pGui, pXData, KEYPAD_ID_TXT, true, 0, 0, 1, 6, GSLC_COL_BLACK, GSLC_COL_BLACK, true);
+}
+
+// Convert between keypad ID and the index into the keypad label array
+int16_t XKeyPadLookup_Num(gslc_tsGui* pGui, int16_t nKeyId)
+{
+  int16_t nKeyInd;
+
+  // Basic button
+  if (nKeyId >= KEYPAD_ID_BASIC_START) {
+    nKeyInd = (nKeyId - KEYPAD_ID_BASIC_START) + KEYPAD_LBL_BASIC_START;
+  } else {
+    // Special button
+    switch (nKeyId) {
+    case KEYPAD_ID_DECIMAL:
+      nKeyInd = KEYPAD_LBL_DECIMAL;
+      break;
+    case KEYPAD_ID_MINUS:
+      nKeyInd = KEYPAD_LBL_MINUS;
+      break;
+    case KEYPAD_ID_BACKSPACE:
+      nKeyInd = KEYPAD_LBL_BACKSPACE;
+      break;
+    case KEYPAD_ID_ESC:
+      nKeyInd = KEYPAD_LBL_ESC;
+      break;
+    case KEYPAD_ID_ENTER:
+      nKeyInd = KEYPAD_LBL_ENTER;
+      break;
+    default:
+      // FIXME: ERROR
+      nKeyInd = -1; // Not expected
+      break;
+    }
+
+  }
+  return nKeyInd;
+}
+
+// Create the XKeyPad_Alpha compound element
+// - Note that this also revises some of the members of the base XKeyPad struct
+gslc_tsElemRef* gslc_ElemXKeyPadCreate_Num(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXKeyPad_Num* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig)
+{
+  gslc_tsXKeyPad* pXDataBase = (gslc_tsXKeyPad*)pXData;
+  pXDataBase->nSubElemMax = XKEYPADNUM_ELEM_MAX;
+  pXDataBase->psElemRef = pXData->asElemRef;
+  pXDataBase->psElem = pXData->asElem;
+
+  // Provide default config if none supplied
+  gslc_tsXKeyPadCfg sConfigTmp;
+  if (pConfig == NULL) {
+    sConfigTmp = gslc_ElemXKeyPadCfgInit_Num();
+    pConfig = &sConfigTmp;
+  }
+
+  return gslc_ElemXKeyPadCreateBase(pGui, nElemId, nPage, pXDataBase, nX0, nY0, nFontId, pConfig,
+    &XKeyPadCreateKeys_Num,&XKeyPadLookup_Num);
+}
+
+// Reset the XKeyPad config struct
+// - This must be called before any XKeyPad config update APIs are called
+gslc_tsXKeyPadCfg gslc_ElemXKeyPadCfgInit_Num()
+{
+  gslc_tsXKeyPadCfg sConfig;
+  sConfig.nButtonSzW = 25;
+  sConfig.nButtonSzH = 25;
+  sConfig.bFloatEn = true;
+  sConfig.bSignEn = true;
+  sConfig.bRoundEn = false;
+  sConfig.nFontId = GSLC_FONT_NONE; // Will be overwritten
+  sConfig.pacKeys = KEYPAD_LABEL_STRINGS;
+  sConfig.nMaxCols = 8;
+  sConfig.nMaxRows = 3;
+  sConfig.nFrameMargin = 2;
+  return sConfig;
+}
+
+#endif // GSLC_FEATURE_COMPOUND
+
+// ============================================================================
diff --git a/src/guislice/XKeyPad_Num.h b/src/guislice/XKeyPad_Num.h
new file mode 100644
index 0000000..5fe549d
--- /dev/null
+++ b/src/guislice/XKeyPad_Num.h
@@ -0,0 +1,100 @@
+#ifndef _GUISLICE_EX_XKEYPAD_NUM_H_
+#define _GUISLICE_EX_XKEYPAD_NUM_H_
+
+#include "GUIslice.h"
+
+#include "XKeyPad.h"
+
+// =======================================================================
+// GUIslice library extension: XKeyPad control (numeric entry)
+// - Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XKeyPad.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+#if (GSLC_FEATURE_COMPOUND)
+
+// Define number of buttons & elements
+// - Refer to the definitions in the XKeyPad_*.c file
+#define XKEYPADNUM_BTN_BASIC 10
+#define XKEYPADNUM_ELEM_MAX (6 + XKEYPADNUM_BTN_BASIC)
+
+// ============================================================================
+// Extended Element: KeyPad Character entry
+// - NOTE: The XKeyPad_Alpha extends the XKeyPad base element
+// ============================================================================
+
+typedef struct {
+  // Base XKeyPad struct
+  // - The base type must appear at the top of the derived struct
+  gslc_tsXKeyPad      sKeyPad;                             ///< Base XKeyPad element
+
+  gslc_tsElemRef      asElemRef[XKEYPADNUM_ELEM_MAX];    ///< Storage for sub-element references
+  gslc_tsElem         asElem[XKEYPADNUM_ELEM_MAX];       ///< Storage for sub-elements
+} gslc_tsXKeyPad_Num;
+
+  ///
+  /// Create a KeyPad Element
+  ///
+  /// \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]  pXData:      Ptr to extended element data structure
+  /// \param[in]  nX0:         X KeyPad Starting Coordinate 
+  /// \param[in]  nY0:         Y KeyPad Starting Coordinate 
+  /// \param[in]  nFontId:     Font ID to use for drawing the element
+  /// \param[in]  pConfig:     Ptr to config options
+  ///
+  /// \return Pointer to Element or NULL if failure
+  ///
+  gslc_tsElemRef* gslc_ElemXKeyPadCreate_Num(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+    gslc_tsXKeyPad_Num* pXData, int16_t nX0, int16_t nY0, int8_t nFontId, gslc_tsXKeyPadCfg* pConfig);
+
+
+  ///
+  /// Initialize the KeyPad config structure
+  /// - This routine should be called to initialize the configuration
+  ///   data structure before calling any of the KeyPad config APIs
+  ///
+  /// \return Initialized KeyPad config structure
+  ///
+  gslc_tsXKeyPadCfg gslc_ElemXKeyPadCfgInit_Num();
+
+// ============================================================================
+
+#endif // GSLC_FEATURE_COMPOUND
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XKEYPAD_NUM_H_
+
diff --git a/src/guislice/XListbox.c b/src/guislice/XListbox.c
new file mode 100644
index 0000000..65c1072
--- /dev/null
+++ b/src/guislice/XListbox.c
@@ -0,0 +1,982 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XListbox.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XListbox.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+
+// ----------------------------------------------------------------------------
+
+// TODO: Combine with GUIslice MAX_STR
+// Defines the maximum length of a listbox item
+#define XLISTBOX_MAX_STR        20
+
+// ============================================================================
+// Extended Element: Listbox
+// - A Listbox control
+// ============================================================================
+
+
+// Basic debug functionality
+/*
+void debug_ElemXListboxDump(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui, pElemRef);
+  gslc_tsXListbox*  pListbox = (gslc_tsXListbox*)(pElem->pXData);
+
+  // Prevent runaway looping due to damaged buffer
+  // Don't ask why I know to do this - PaulC
+
+  int16_t    nSafety=0; 
+  char acTxt[50 + 1];
+  GSLC_DEBUG2_PRINT("Xlistbox:Dump (nBufPos=%d nItemCnt=%d)\n", pListbox->nBufItemsPos,pListbox->nItemCnt);
+  for (unsigned nInd = 0; nInd < pListbox->nBufItemsPos; nInd++) {
+    nSafety++;
+    if (nSafety > pListbox->nBufItemsMax) break;
+    char ch = pListbox->pBufItems[nInd];
+    if (ch == 0) {
+      snprintf(acTxt, 40,"0x%04x: [%2u] = %02X = [NULL]", (char*)&pListbox->pBufItems[nInd],nInd, ch);
+    }
+    else {
+      snprintf(acTxt, 40,"0x%04x: [%2u] = %02X = [%c]", (char*)&pListbox->pBufItems[nInd],nInd, ch, ch);
+    }
+    GSLC_DEBUG2_PRINT("XListbox:Dump: %s\n", acTxt);
+  }
+}
+*/
+
+char* gslc_ElemXListboxGetItemAddr(gslc_tsXListbox* pListbox, int16_t nItemCurSel)
+{
+  char*      pBuf = NULL;
+  uint16_t   nBufPos = 0;
+  uint16_t   nItemInd = 0;
+  bool       bFound = false;
+  while (1) {
+    if (nItemInd == nItemCurSel) {
+      bFound = true;
+      break;
+    }
+    if (nBufPos >= pListbox->nBufItemsMax) {
+      break;
+    }
+    if (pListbox->pBufItems[nBufPos] == 0) {
+      nItemInd++;
+    }
+    nBufPos++;
+  }
+  if (bFound) {
+    pBuf = (char*)&(pListbox->pBufItems[nBufPos]);
+    return pBuf;
+  } else {
+    return NULL;
+  }
+}
+
+// Recalculate listbox item sizing if enabled
+bool gslc_ElemXListboxRecalcSize(gslc_tsXListbox* pListbox,gslc_tsRect rElem)
+{
+  int16_t nElem;
+  int16_t nElemInner;
+  int16_t nItemOuter;
+  int16_t nItemWOld;
+  bool bNeedRedraw = false;
+
+  // If number of rows was auto-sized based on content, then calculate now
+  if (pListbox->nRows == XLISTBOX_SIZE_AUTO) {
+    if (pListbox->nItemCnt == 0) {
+      pListbox->nRows = 1; // Force at least one row
+    } else {
+      pListbox->nRows = ((pListbox->nItemCnt + 1) / pListbox->nCols);
+    }
+  }
+
+  // NOTE: In the nElemInner calculation, we add nItemGap to account
+  // for the fact that the last column does not include a "gap" after it.
+  if (pListbox->bItemAutoSizeW) {
+    nItemWOld = pListbox->nItemW;
+    nElem = rElem.w;
+    nElemInner = nElem - (2 * pListbox->nMarginW) + pListbox->nItemGap;
+    nItemOuter = nElemInner / pListbox->nCols;
+    pListbox->nItemW = nItemOuter - pListbox->nItemGap;
+    if (pListbox->nItemW != nItemWOld) {
+      bNeedRedraw = true;
+    }
+  }
+  if (pListbox->bItemAutoSizeH) {
+    nItemWOld = pListbox->nItemH;
+    nElem = rElem.h;
+    nElemInner = nElem - (2 * pListbox->nMarginH) + pListbox->nItemGap;
+    nItemOuter = nElemInner / pListbox->nRows;
+    pListbox->nItemH = nItemOuter - pListbox->nItemGap;
+    if (pListbox->nItemH != nItemWOld) {
+      bNeedRedraw = true;
+    }
+  }
+
+  // Clear Need Recalc flag
+  pListbox->bNeedRecalc = false;
+
+  return bNeedRedraw;
+}
+
+void gslc_ElemXListboxSetSize(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nRows, int8_t nCols)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nRows = nRows;
+  pListbox->nCols = nCols;
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+
+
+void gslc_ElemXListboxSetMargin(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nMarginW, int8_t nMarginH)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nMarginW = nMarginW;
+  pListbox->nMarginH = nMarginH;
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemXListboxItemsSetSize(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemW, int16_t nItemH)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nItemW = nItemW;
+  pListbox->nItemH = nItemH;
+  // Determine if auto-sizing requested
+  pListbox->bItemAutoSizeW = (nItemW == XLISTBOX_SIZE_AUTO) ? true : false;
+  pListbox->bItemAutoSizeH = (nItemH == XLISTBOX_SIZE_AUTO) ? true : false;
+
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXListboxItemsSetGap(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nGap, gslc_tsColor colGap)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nItemGap = nGap;
+  pListbox->colGap = colGap;
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemXListboxReset(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->nBufItemsPos = 0;
+  pListbox->nItemCnt = 0;
+  pListbox->nItemCurSel = XLISTBOX_SEL_NONE;
+  pListbox->bNeedRecalc = true;
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+}
+
+
+bool gslc_ElemXListboxAddItem(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, const char* pStrItem)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  int8_t      nStrItemLen;
+  char*       pBuf = NULL;
+  uint16_t    nBufItemsPos = pListbox->nBufItemsPos;
+  uint16_t    nBufItemsMax = pListbox->nBufItemsMax;
+
+  nStrItemLen = strlen(pStrItem);
+
+  if (nStrItemLen == 0) {
+    // Nothing to add
+    return false;
+  }
+
+  // Ensure we won't overrun the buffer, including the terminator
+  if (nBufItemsPos + nStrItemLen + 1 > nBufItemsMax) {
+    // Proceed with truncation
+    nStrItemLen = nBufItemsMax - pListbox->nBufItemsPos - 1;
+    GSLC_DEBUG2_PRINT("ERROR: ElemXListboxAddItem() buffer too small\n", "");
+  }
+
+  // If the truncation left nothing to add, skip out now
+  if (nStrItemLen <= 0) {
+    return false;
+  }
+
+  // Treat this section of the buffer as [char]
+  pBuf = (char*)pListbox->pBufItems + nBufItemsPos;
+  strncpy(pBuf, pStrItem, nStrItemLen);
+  pListbox->nBufItemsPos += nStrItemLen;
+
+  // Ensure terminator added
+  pBuf += nStrItemLen;
+  *pBuf = 0;
+  pListbox->nBufItemsPos++;
+
+  pListbox->nItemCnt++;
+
+  //GSLC_DEBUG2_PRINT("Xlistbox:Add\n", "");
+  //debug_ElemXListboxDump(pGui, pElemRef);
+
+  // Inidicate sizing may need update
+  pListbox->bNeedRecalc = true;
+
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+  return true;
+}
+
+bool gslc_ElemXListboxInsertItemAt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nInsertPos, 
+  const char* pStrItem)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  int8_t      nStrItemLen;
+  char*       pBuf = NULL;
+  uint16_t    nBufItemsPos = pListbox->nBufItemsPos;
+  uint16_t    nBufItemsMax = pListbox->nBufItemsMax;
+
+  if (nInsertPos > pListbox->nItemCnt) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXListboxInsertItemAt() Current Count: %d Invalid Position %d\n", 
+      pListbox->nItemCnt,nInsertPos);
+    return false;
+  }
+  nStrItemLen = strlen(pStrItem);
+
+  if (nStrItemLen == 0) {
+    // Nothing to add
+    return false;
+  }
+
+  // Ensure we won't overrun the buffer, including the terminator
+  if (nBufItemsPos + nStrItemLen + 1 > nBufItemsMax) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXListboxInsertItemAt() buffer too small\n", "");
+    return false;
+  }
+
+  // If the truncation left nothing to add, skip out now
+  if (nStrItemLen <= 0) {
+    return false;
+  }
+
+//  GSLC_DEBUG2_PRINT("Xlistbox:InsertAt: %d\n", nInsertPos);
+//  debug_ElemXListboxDump(pGui, pElemRef);
+
+  pBuf = gslc_ElemXListboxGetItemAddr(pListbox, nInsertPos);
+  // If position is incorrect, bail out...
+  if (pBuf == NULL) {
+    return false;
+  }
+ 
+  // Make a hole in the buffer to slot in the new item
+  char* pSrc = (char*)pListbox->pBufItems+nBufItemsPos-1;
+  char* pDest = pSrc+nStrItemLen+1;  
+  int16_t nMoveLen = (int16_t)(pSrc - pBuf)+1;
+  uint8_t ch;
+  for (uint16_t nInd = 0; nInd < nMoveLen; nInd++) {
+    ch = *pSrc;
+    *pDest = ch;
+    pDest--;
+    pSrc--;
+  }
+  
+  // Now slot in the new item
+  memcpy(pBuf, pStrItem, nStrItemLen+1);
+
+  // update our buffer information
+  pListbox->nBufItemsPos += nStrItemLen+1;
+  pListbox->nItemCnt++;
+
+//  GSLC_DEBUG2_PRINT("Xlistbox:After InsertAt %d\n", nInsertPos);
+//  debug_ElemXListboxDump(pGui, pElemRef);
+
+  // Indicate sizing may need update
+  pListbox->bNeedRecalc = true;
+
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+
+  return true;
+}
+
+bool gslc_ElemXListboxDeleteItemAt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nDeletePos)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  int8_t      nStrItemLen;
+  char*       pBuf = NULL;
+  uint16_t    nBufItemsPos = pListbox->nBufItemsPos;
+
+//  GSLC_DEBUG2_PRINT("Xlistbox:DeleteAt: %d\n", nDeletePos);
+//  debug_ElemXListboxDump(pGui, pElemRef);
+
+  pBuf = gslc_ElemXListboxGetItemAddr(pListbox, nDeletePos);
+  // If position is incorrect, bail out...
+  if (pBuf == NULL) {
+    return false;
+  }
+  nStrItemLen = strlen(pBuf);
+  
+  // Pull items after this delete position up to delete this item
+  char* pSrc  = (char*)pBuf+nStrItemLen+1;
+  char* pDest = (char*)pBuf;
+  char* pEndOfBuf = (char*)(pListbox->pBufItems+nBufItemsPos);
+  int16_t nMoveLen = (int16_t)(pEndOfBuf-pSrc)+1;
+  uint8_t ch;
+  if (nMoveLen > 1) {
+    for (uint16_t nInd = 0; nInd < nMoveLen; nInd++) {
+      ch = *pSrc;
+      *pDest = ch;
+      pDest++;
+      pSrc++;
+    }
+  }
+  
+  // update our buffer information
+  pListbox->nBufItemsPos -= nStrItemLen+1;
+  pListbox->nItemCnt--;
+  
+  // unselect item
+  gslc_ElemXListboxSetSel(pGui, pElemRef, XLISTBOX_SEL_NONE);
+
+//  GSLC_DEBUG2_PRINT("Xlistbox:After DeleteAt %d\n", nDeletePos);
+//  debug_ElemXListboxDump(pGui, pElemRef);
+
+  // Indicate sizing may need update
+  pListbox->bNeedRecalc = true;
+
+  // Mark as needing full redraw
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+
+  return true;
+}
+
+bool gslc_ElemXListboxGetItem(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemCurSel, char* pStrItem, 
+  uint8_t nStrItemLen)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  // Ensure user provided valid string
+  if ((pStrItem == NULL) || (nStrItemLen == 0)) {
+    // ERROR
+    return false;
+  }
+  uint16_t   nBufPos = 0;
+  uint16_t   nItemInd = 0;
+  uint8_t*   pBuf = NULL;
+  bool       bFound = false;
+  while (1) {
+    if (nItemInd == nItemCurSel) {
+      bFound = true;
+      break;
+    }
+    if (nBufPos >= pListbox->nBufItemsMax) {
+      break;
+    }
+    if (pListbox->pBufItems[nBufPos] == 0) {
+      nItemInd++;
+    }
+    nBufPos++;
+  }
+  if (bFound) {
+    pBuf = &(pListbox->pBufItems[nBufPos]);
+    strncpy(pStrItem, (char*)pBuf, nStrItemLen);
+    // Ensure null terminated in case the buffer
+    // was smaller than the item source
+    pStrItem[nStrItemLen - 1] = 0;
+    return true;
+  } else {
+    // If no item was found, return an empty string (NULL)
+    pStrItem[0] = 0;
+    return false;
+  }
+}
+
+
+int16_t gslc_ElemXListboxGetItemCnt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return 0;
+
+  return pListbox->nItemCnt;
+}
+
+
+// Create a Listbox element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXListboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXListbox* pXData,gslc_tsRect rElem,int16_t nFontId,uint8_t* pBufItems,uint16_t nBufItemsMax,int16_t nItemDefault)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXListboxCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_LISTBOX,rElem,NULL,0,nFontId);
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->pBufItems       = pBufItems;
+  pXData->nBufItemsMax    = nBufItemsMax;
+  pXData->nBufItemsPos    = 0;
+  pXData->nItemCnt        = 0;
+  pXData->nItemCurSel     = nItemDefault;
+  pXData->nItemCurSelLast = XLISTBOX_SEL_NONE;
+  pXData->nItemSavedSel   = XLISTBOX_SEL_NONE;
+  pXData->nItemTop        = 0;
+  pXData->pfuncXSel       = NULL;
+  pXData->nCols           = 1;
+  pXData->nRows           = XLISTBOX_SIZE_AUTO;     // Auto-calculated from content
+  pXData->bNeedRecalc     = true;                   // Force auto-sizing
+  pXData->nMarginW        = 5;
+  pXData->nMarginH        = 5;
+  pXData->bItemAutoSizeW  = true;                   // Force auto-sizing
+  pXData->bItemAutoSizeH  = false;
+  pXData->nItemW          = XLISTBOX_SIZE_AUTO;     // Auto-sized
+  pXData->nItemH          = 30;
+  pXData->nItemGap        = 2;
+  pXData->colGap          = GSLC_COL_BLACK;
+  pXData->nItemCurSelLast = XLISTBOX_SEL_NONE;
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXListboxDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXListboxTouch;
+
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+
+  // Set default text alignment:
+  // - Vertical center, left justify
+  sElem.eTxtAlign        = GSLC_ALIGN_MID_LEFT;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// Redraw the Listbox
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXListboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  //bool            bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  int8_t          nItemCurSel  = pListbox->nItemCurSel;
+
+
+  gslc_tsRect rElemRect;
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN) {
+    rElemRect = gslc_ExpandRect(pElem->rElem, -1, -1);
+    if (eRedraw == GSLC_REDRAW_FULL) {
+      gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+    }
+  } else {
+    rElemRect = pElem->rElem;
+  }
+
+  // If full redraw and gap is enabled:
+  // - Clear background with gap color, as list items
+  //   will be overdrawn in colBg color
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    if (pListbox->nItemGap > 0) {
+      gslc_DrawFillRect(pGui, rElemRect, pListbox->colGap);
+    }
+  }
+
+  // Determine if we need to recalculate the item sizing
+  if (pListbox->bNeedRecalc) {
+    gslc_ElemXListboxRecalcSize(pListbox, rElemRect);
+  }
+
+  int16_t nX0, nY0;
+  nX0 = rElemRect.x;
+  nY0 = rElemRect.y;
+
+  int8_t        nRows = pListbox->nRows;
+  int8_t        nCols = pListbox->nCols;
+  gslc_tsRect   rItemRect;
+  int16_t       nItemBaseX, nItemBaseY;
+  int16_t       nItemX, nItemY;
+  int16_t       nItemW, nItemH;
+  bool          bItemSel;
+  gslc_tsColor  colFill, colTxt;
+
+  // Error check
+  if (nCols == 0) {
+    return false;
+  }
+
+  // Determine top-left coordinate of list matrix
+  nItemBaseX = nX0 + pListbox->nMarginW;
+  nItemBaseY = nY0 + pListbox->nMarginH;
+  char acStr[XLISTBOX_MAX_STR+1] = "";
+
+
+  // Loop through the items in the list
+  int8_t nItemTop = pListbox->nItemTop;
+  int8_t nItemCnt = pListbox->nItemCnt;
+  int8_t nItemInd;
+
+  // Note that nItemTop is always pointing to an
+  // item index at the start of a row
+
+  // Determine the list indices to display in the visible window due to scrolling
+  int8_t nDispIndMax = (nRows * nCols);
+
+  for (int8_t nDispInd = 0; nDispInd < nDispIndMax; nDispInd++) {
+
+    // Calculate the item index based on the display index
+    nItemInd = nItemTop + nDispInd;
+
+    // Did we go past the end of our list?
+    if (nItemInd >= nItemCnt) {
+      break;
+    }
+
+    // Fetch the list item
+    bool bOk = gslc_ElemXListboxGetItem(pGui, pElemRef, nItemInd, acStr, XLISTBOX_MAX_STR);
+    if (!bOk) {
+      // TODO: Erorr handling
+      break;
+    }
+
+    int8_t    nItemIndX, nItemIndY;
+    int16_t   nItemOuterW, nItemOuterH;
+
+    // Convert linear count into row & column
+    nItemIndY = nDispInd / nCols; // Round down
+    nItemIndX = nDispInd % nCols;
+
+    // Calculate total spacing between items (including gap)
+    nItemOuterW = pListbox->nItemW + pListbox->nItemGap;
+    nItemOuterH = pListbox->nItemH + pListbox->nItemGap;
+
+    // Determine top-left corner of each item
+    nItemW = pListbox->nItemW;
+    nItemH = pListbox->nItemH;
+    nItemY = nItemBaseY + (nItemIndY * nItemOuterH);
+    nItemX = nItemBaseX + (nItemIndX * nItemOuterW);
+
+    // Create rect for item
+    rItemRect = (gslc_tsRect) { nItemX, nItemY, nItemW, nItemH };
+
+    // Is the item selected?
+    bItemSel = (nItemInd == nItemCurSel) ? true : false;
+
+    // Determine the color based on state
+    colFill = (bItemSel) ? pElem->colElemFillGlow : pElem->colElemFill;
+    colTxt = (bItemSel) ? pElem->colElemTextGlow : pElem->colElemText;
+
+    bool bDoRedraw = false;
+    if (eRedraw == GSLC_REDRAW_FULL) {
+      bDoRedraw = true;
+    } else if (eRedraw == GSLC_REDRAW_INC) {
+      // Redraw both the old selected item (ie. to unselect it)
+      // and the current selected item (ie. to select it)
+      if (nItemInd == pListbox->nItemCurSelLast) {
+        bDoRedraw = true;
+      } else if (nItemInd == nItemCurSel) {
+        bDoRedraw = true;
+      }
+    }
+
+    // Draw the list item
+    if (bDoRedraw) {
+      gslc_DrawFillRect(pGui, rItemRect, colFill);
+
+      // Set the text flags to indicate that the user has separately
+      // allocated memory for the text strings.
+      gslc_teTxtFlags eTxtFlags = GSLC_TXT_MEM_RAM | GSLC_TXT_ALLOC_EXT;
+
+      // Draw the aligned text string (by default it is GSLC_ALIGN_MID_LEFT)
+      gslc_DrawTxtBase(pGui, acStr, rItemRect, pElem->pTxtFont, eTxtFlags,
+        pElem->eTxtAlign, colTxt, colFill, pElem->nTxtMarginX, pElem->nTxtMarginY);
+    }
+
+  }
+
+  // Save the last selected item during redraw
+  pListbox->nItemCurSelLast = nItemCurSel;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+bool gslc_ElemXListboxTouch(void* pvGui, void* pvElemRef, gslc_teTouch eTouch, int16_t nRelX, int16_t nRelY)
+{
+  #if defined(DRV_TOUCH_NONE)
+  return false;
+  #else
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+
+  // Typecast the parameters to match the GUI
+  pGui = (gslc_tsGui*)(pvGui);
+  pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  //bool    bGlowingOld = gslc_ElemGetGlow(pGui, pElemRef);
+  bool    bIndexed = false;
+
+  int16_t nItemSavedSel = pListbox->nItemSavedSel;
+  int16_t nItemCurSelOld = pListbox->nItemCurSel;
+  int16_t nItemCurSel = XLISTBOX_SEL_NONE;
+  bool bSelTrack = false;
+  bool bSelSave = false;
+  bool bSelInItem = true;
+
+  switch (eTouch) {
+
+  case GSLC_TOUCH_DOWN_IN:
+    // Start glowing as must be over it
+    gslc_ElemSetGlow(pGui, pElemRef, true);
+    // User pressed inside elem: start selection
+    bSelTrack = true;
+    break;
+
+  case GSLC_TOUCH_MOVE_IN:
+    gslc_ElemSetGlow(pGui, pElemRef, true);
+    // Track changes in selection
+    bSelTrack = true;
+    break;
+  case GSLC_TOUCH_MOVE_OUT:
+    gslc_ElemSetGlow(pGui, pElemRef, false);
+    // User has dragged to outside elem: deselect
+    bSelTrack = true;
+    break;
+
+  case GSLC_TOUCH_UP_IN:
+    // End glow
+    gslc_ElemSetGlow(pGui, pElemRef, false);
+    // User released inside elem.
+    // Save selection.
+    // If selection is same as previous: toggle it
+    bSelTrack = true;
+    bSelSave = true;
+    break;
+  case GSLC_TOUCH_UP_OUT:
+    // End glow
+    gslc_ElemSetGlow(pGui, pElemRef, false);
+    // User released outside elem: leave selection as-is
+    bSelTrack = true;
+    bSelSave = true; // Save SEL_NONE
+    break;
+
+  case GSLC_TOUCH_SET_REL:
+  case GSLC_TOUCH_SET_ABS:
+    bIndexed = true;
+    gslc_ElemSetGlow(pGui,pElemRef,true);
+    // Keyboard / pin control
+    bSelTrack = true;
+    bSelSave = true;
+    break;
+
+  default:
+    return false;
+    break;
+  }
+
+  uint8_t nCols = pListbox->nCols;
+  uint8_t nRows = pListbox->nRows;
+
+  // If we need to update the Listbox selection, calculate the value
+  // and perform the update
+  if (bSelTrack) {
+
+    if (bIndexed) {
+      // The selection is changed by direct control (eg. keyboard)
+      // instead of touch coordinates
+
+
+      // FIXME: Change the following to be either absolute or relative
+      // value assignment instead of inc/dec. Then the user code can
+      // define what the magnitude and direction should be.
+
+      if (eTouch == GSLC_TOUCH_SET_REL) {
+        // Overload the "nRelY" parameter as an increment value
+        nItemCurSel = nItemCurSelOld + nRelY;
+      }
+      else if (eTouch == GSLC_TOUCH_SET_ABS) {
+        // Overload the "nRelY" parameter as an absolute value
+        nItemCurSel = nRelY;
+      }
+      gslc_ElemXListboxSetSel(pGui, pElemRef, nItemCurSel);
+    }
+    else {
+      // Determine which item we are tracking
+      int16_t nItemOuterW, nItemOuterH;
+      int16_t nDispR, nDispC;
+      int16_t nItemR, nItemC;
+
+      // Get position relative to top-left list matrix cell
+      nRelX -= pListbox->nMarginW;
+      nRelY -= pListbox->nMarginH;
+
+      // Determine spacing between matrix cells
+      nItemOuterW = pListbox->nItemW + pListbox->nItemGap;
+      nItemOuterH = pListbox->nItemH + pListbox->nItemGap;
+
+      // Determine which matrix cell we are in
+      nDispC = nRelX / nItemOuterW;
+      nDispR = nRelY / nItemOuterH;
+
+      if ((nRelX < 0) || (nRelY < 0)) {
+        bSelInItem = false;
+      }
+
+      // Determine if the selection was inside the range of displayed items
+      if ((nDispR < 0) || (nDispR >= nRows) || (nDispC < 0) || (nDispC >= nCols)) {
+        bSelInItem = false;
+      }
+      if (bSelInItem) {
+
+        // We have confirmed that the selected cell is
+        // within the visible display range. Now translate
+        // the display cell index to the absolute list cell index
+        // by taking into account the scroll position.
+        // - Note that nItemTop is always pointing to an
+        //   item index at the start of a row
+        nItemC = nDispC;
+        nItemR = pListbox->nItemTop + nDispR;
+
+        // Now we have identified the cell within the list matrix
+        nItemCurSel = nItemR * nCols + nItemC;
+
+        // Confirm we haven't selected out of range
+        if (nItemCurSel >= pListbox->nItemCnt) {
+          bSelInItem = false;
+        }
+      }
+
+      if (bSelInItem) {
+        // Now check for touch in gap region
+        // - First find offset from top-left of matrix cell
+        nRelX = nRelX % nItemOuterW;
+        nRelY = nRelY % nItemOuterH;
+        // If we are in the gap region, disable
+        if (nRelX > pListbox->nItemW) {
+          bSelInItem = false;
+        }
+        if (nRelY > pListbox->nItemH) {
+          bSelInItem = false;
+        }
+      }
+
+      // If we determined that the coordinate was not inside an
+      // element, then clear current selection
+      if (!bSelInItem) {
+        nItemCurSel = XLISTBOX_SEL_NONE;
+      }
+
+      // If we have committed a touch press within an item
+      // that was already selected, then toggle (deselect it)
+      if ((bSelSave) && (nItemCurSel == nItemSavedSel)) {
+        nItemCurSel = XLISTBOX_SEL_NONE;
+      }
+
+      bool bDoRedraw = false;
+
+      if (nItemCurSel != nItemCurSelOld) {
+        // Selection changed, so we will redraw
+        bDoRedraw = true;
+      }
+
+      if (bDoRedraw) {
+        // Update the selection
+        gslc_ElemXListboxSetSel(pGui, pElemRef, nItemCurSel);
+
+        // If any selection callback is defined, call it now
+        if (pListbox->pfuncXSel != NULL) {
+          (*pListbox->pfuncXSel)((void*)(pGui), (void*)(pElemRef), nItemCurSel);
+        }
+        // Redraw the element
+        // - Note that ElemXListboxSetSel() above will also request redraw
+        gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_INC);
+      }
+
+      // Update the saved selection
+      if (bSelSave) {
+        pListbox->nItemSavedSel = nItemCurSel;
+      }
+
+    } // bIndexed
+
+  } // bSelTrack
+
+  return true;
+  
+  #endif // DRV_TOUCH_NONE
+}
+
+int16_t gslc_ElemXListboxGetSel(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return XLISTBOX_SEL_NONE;
+
+  return pListbox->nItemCurSel;
+}
+
+bool gslc_ElemXListboxSetSel(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef, int16_t nItemCurSel)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  bool bOk = false;
+  if (nItemCurSel == XLISTBOX_SEL_NONE) { bOk = true; }
+  if ((nItemCurSel >= 0) && (nItemCurSel < pListbox->nItemCnt)) { bOk = true; }
+  if (bOk) {
+    pListbox->nItemCurSel = nItemCurSel;
+    gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_INC);
+  }
+  return bOk;
+}
+
+bool gslc_ElemXListboxSetScrollPos(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nScrollPos)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return false;
+
+  bool bOk = false;
+  if ((nScrollPos >= 0) && (nScrollPos < pListbox->nItemCnt)) {
+    bOk = true;
+  }
+
+  int16_t nCols = pListbox->nCols;
+  int16_t nItemCnt = pListbox->nItemCnt;
+
+  // Error handling: in case position out of bounds
+  if (nScrollPos >= nItemCnt) {
+    nScrollPos = (nItemCnt > 0) ? nItemCnt - 1 : 0;
+  }
+
+  // Adjust the top item index to the start of its row
+  // - This is done because we may have multiple columns
+  //   per row. This ensures nItemTop points to the list
+  //   index at the start of a row.
+  nScrollPos = (nScrollPos / nCols) * nCols;
+  pListbox->nItemTop = nScrollPos;
+
+  // Need to update all rows in display
+  gslc_ElemSetRedraw(pGui, pElemRef, GSLC_REDRAW_FULL);
+  return bOk;
+}
+
+
+// Assign the selection callback function for a Listbox
+void gslc_ElemXListboxSetSelFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XLISTBOX_SEL funcCb)
+{
+  gslc_tsXListbox* pListbox = (gslc_tsXListbox*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_LISTBOX, __LINE__);
+  if (!pListbox) return;
+
+  pListbox->pfuncXSel = funcCb;
+}
+
+// ============================================================================
diff --git a/src/guislice/XListbox.h b/src/guislice/XListbox.h
new file mode 100644
index 0000000..4440c16
--- /dev/null
+++ b/src/guislice/XListbox.h
@@ -0,0 +1,329 @@
+#ifndef _GUISLICE_EX_XLISTBOX_H_
+#define _GUISLICE_EX_XLISTBOX_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Listbox control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XListbox.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Listbox
+// - NOTE: The XListbox element is in beta development.
+//         Therefore, its API is subject to change.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_LISTBOX GSLC_TYPE_BASE_EXTEND + 10
+
+// Define constants specific to the control
+#define XLISTBOX_SEL_NONE       -1  // Indicator for "no selection"
+#define XLISTBOX_SIZE_AUTO      -1  // Indicator for "auto-size"
+#define XLISTBOX_BUF_OH_R        2  // Listbox buffer overhead per row
+
+/// Callback function for Listbox feedback
+typedef bool (*GSLC_CB_XLISTBOX_SEL)(void* pvGui,void* pvElem,int16_t nSel);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Listbox element
+typedef struct {
+
+  // Config
+  uint8_t*        pBufItems;      ///< Buffer containing items
+  uint16_t        nBufItemsMax;   ///< Max size of buffer containing items
+  uint16_t        nBufItemsPos;   ///< Current buffer position
+  int16_t         nItemCnt;       ///< Number of items in the list
+
+  // Style config
+  int8_t          nCols;          ///< Number of columns
+  int8_t          nRows;          ///< Number of columns (or XLSITBOX_SIZE_AUTO to calculate)
+  bool            bNeedRecalc;    ///< Determine if sizing may need recalc
+  int8_t          nMarginW;       ///< Margin inside main listbox area (X offset)
+  int8_t          nMarginH;       ///< Margin inside main listbox area (Y offset)
+  int16_t         nItemW;         ///< Width of listbox item
+  int16_t         nItemH;         ///< Height of listbox item
+  int8_t          nItemGap;       ///< Gap between listbox items
+  gslc_tsColor    colGap;         ///< Gap color
+  bool            bItemAutoSizeW; ///< Enable auto-sizing of items (in width)
+  bool            bItemAutoSizeH; ///< Enable auto-sizing of items (in height)
+
+  // State
+  int16_t         nItemCurSel;      ///< Currently selected item (XLISTBOX_SEL_NONE for none)
+  int16_t         nItemCurSelLast;  ///< Old selected item to redraw (XLISTBOX_SEL_NONE for none)
+  int16_t         nItemSavedSel;    ///< Persistent selected item (ie. saved selection)
+  int16_t         nItemTop;         ///< Item to show at top of list after scrolling (0 is default)
+
+  // Callbacks
+  GSLC_CB_XLISTBOX_SEL pfuncXSel; ///< Callback func ptr for selection update
+
+} gslc_tsXListbox;
+
+
+///
+/// Create a Listbox Element
+///
+/// \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]  pXData:        Ptr to extended element data structure
+/// \param[in]  rElem:         Rectangle coordinates defining checkbox size
+/// \param[in]  nFontId:       Font ID for item display
+/// \param[in]  pBufItems:     Pointer to buffer that will contain list of items
+/// \param[in]  nBufItemsMax:  Max size of buffer for list of items (pBufItems)
+/// \param[in]  nSelDefault:   Default item to select
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXListboxCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXListbox* pXData, gslc_tsRect rElem, int16_t nFontId, uint8_t* pBufItems,
+  uint16_t nBufItemsMax, int16_t nSelDefault);
+
+
+///
+/// Configure the number of rows & columns to display in the listbox
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nRows:         Number of rows (>= 1, or XLISTBOX_SIZE_AUTO to base on content)
+/// \param[in]  nCols:         Number of columns (>= 1)
+///
+/// \return none
+///
+void gslc_ElemXListboxSetSize(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nRows, int8_t nCols);
+
+
+///
+/// Configure the margin inside the listbox
+/// - Defines the region bewteen the element rect and the inner listbox items
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nMarginW:      Set the margin (horizontal) inside the listbox (0 for none)
+/// \param[in]  nMarginH:      Set the margin (horizontal) inside the listbox (0 for none)
+///
+/// \return none
+///
+void gslc_ElemXListboxSetMargin(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nMarginW, int8_t nMarginH);
+
+///
+/// Configure the size of the listbox items
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nItemW:        Set the width of a listbox item (or -1 to auto-size)
+/// \param[in]  nItemH:        Set the height of a listbox item
+///
+/// \return none
+///
+void gslc_ElemXListboxItemsSetSize(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemW, int16_t nItemH);
+
+///
+/// Configure the gap between listbox items
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nGap:          Set the gap between listbox items (0 for none)
+/// \param[in]  colGap:        Set the color of the gap between listbox items
+///
+/// \return none
+///
+void gslc_ElemXListboxItemsSetGap(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nGap, gslc_tsColor colGap);
+
+
+///
+/// Empty the listbox of all items
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+///
+/// \return none
+///
+void gslc_ElemXListboxReset(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
+
+
+///
+/// Add an item to the listbox
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  pStrItem:      String to use when creating the listbox item
+///
+/// \return true if OK, false if fail (eg. insufficient buffer storage)
+///
+bool gslc_ElemXListboxAddItem(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, const char* pStrItem);
+
+///
+/// Insert an item in the listbox at a specific position
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nInsertPos:    Insertion position
+/// \param[in]  pStrItem:      String to use when creating the listbox item
+///
+/// \return true if OK, false if fail (eg. insufficient buffer storage)
+///
+bool gslc_ElemXListboxInsertItemAt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nInsertPos, 
+  const char* pStrItem);
+
+///
+/// Insert an item in the listbox at a specific position
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nDeletePos:    Position to delete
+///
+/// \return true if OK, false if fail
+///
+bool gslc_ElemXListboxDeleteItemAt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nDeletePos);
+
+///
+/// Get the indexed listbox item
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+/// \param[in]  nItemCurSel:   Item index to fetch
+/// \param[out] pStrItem:      Ptr to the string buffer to receive the item
+/// \param[in]  nStrItemLen:   Maximum buffer length of pStrItem
+///
+/// \return true if success, false if fail (eg. can't locate item)
+///
+bool gslc_ElemXListboxGetItem(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemCurSel, 
+  char* pStrItem, uint8_t nStrItemLen);
+
+
+///
+/// Get the number of items in the listbox
+///
+/// \param[in]  pGui:          Pointer to GUI
+/// \param[in]  pElemRef:      Ptr to Element Reference to update
+///
+/// \return Number of items
+///
+int16_t gslc_ElemXListboxGetItemCnt(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef);
+
+///
+/// Draw a Listbox element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXListboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Listbox element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (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
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXListboxTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+
+///
+/// Get a Listbox element's current selection
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current Listbox selection (or -1 if none)
+///
+int16_t gslc_ElemXListboxGetSel(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Set a Listbox element's current selection
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nItemCurSel:    Listbox item to select (or -1 for none)
+///
+/// \return true if success, false if fail
+///
+bool gslc_ElemXListboxSetSel(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nItemCurSel);
+
+///
+/// Set the Listbox scroll position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nScrollPos:  Scroll the listbox so that the nScrollPos item is at the top (0 default)
+///
+/// \return true if success, false if fail
+///
+bool gslc_ElemXListboxSetScrollPos(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nScrollPos);
+
+
+///
+/// Assign the selection callback function for a Listbox
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to selection routine (or NULL for none)
+///
+/// \return none
+///
+void gslc_ElemXListboxSetSelFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XLISTBOX_SEL funcCb);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XLISTBOX_H_
+
diff --git a/src/guislice/XProgress.c b/src/guislice/XProgress.c
new file mode 100644
index 0000000..308cf4d
--- /dev/null
+++ b/src/guislice/XProgress.c
@@ -0,0 +1,365 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XProgress.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XProgress.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Progress Bar
+// - Basic progress bar with support for vertical / horizontal orientation and
+//   fill direction. Also provides an indicator of negative regions, depending
+//   on the configured range.
+// ============================================================================
+
+// Create a gauge element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXProgressCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXProgress* pXData,gslc_tsRect rElem,
+  int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXProgressCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_PROGRESS,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;  // Element is not "clickable"
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->nMin            = nMin;
+  pXData->nMax            = nMax;
+  pXData->nVal            = nVal;
+  pXData->bVert           = bVert;
+  pXData->bFlip           = false;
+  pXData->colGauge        = colGauge;
+  sElem.pXData            = (void*)(pXData);
+  sElem.pfuncXDraw        = &gslc_ElemXProgressDraw;
+  sElem.pfuncXTouch       = NULL;           // No need to track touches
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+// Update the gauge control's current position
+void gslc_ElemXProgressSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXProgressSetVal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_PROGRESS,__LINE__);
+
+  // Update the data element
+  int16_t nValOld = pGauge->nVal;
+  pGauge->nVal = nVal;
+
+  // Element needs redraw
+  if (nVal != nValOld) {
+    // We only need an incremental redraw
+    // NOTE: If the user configures the indicator to be
+    //       long enough that it overlaps some of the gauge indicators
+    //       then a full redraw should be done instead.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+// Update the gauge's fill direction
+// - Setting bFlip causes the gauge to be filled in the reverse direction
+//   to the default
+// - Default fill direction for horizontal gauges: left-to-right
+// - Default fill direction for vertical gauges: bottom-to-top
+void gslc_ElemXProgressSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXProgressSetFlip";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Fetch the element's extended data structure
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_PROGRESS,__LINE__);
+
+  pGauge->bFlip = bFlip;
+
+  // Mark for redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+
+// Redraw the gauge
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXProgressDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXProgressDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_PROGRESS,__LINE__);
+
+  gslc_ElemXProgressDrawHelp(pGui,pElemRef,eRedraw);
+
+  // Save as "last state" to support incremental erase/redraw
+  pGauge->nValLast      = pGauge->nVal;
+  pGauge->bValLastValid = true;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+bool gslc_ElemXProgressDrawHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*       pElem   = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXProgress*  pGauge  = (gslc_tsXProgress*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_PROGRESS,__LINE__);
+
+  gslc_tsRect   rTmp;           // Temporary rect for drawing
+  gslc_tsRect   rGauge;         // Filled portion of gauge
+  gslc_tsRect   rEmpty;         // Empty portion of gauge
+  uint16_t      nElemW,nElemH;
+  int16_t       nElemX0,nElemY0,nElemX1,nElemY1;
+  int16_t       nGaugeX0,nGaugeY0,nGaugeX1,nGaugeY1;
+
+  nElemX0 = pElem->rElem.x;
+  nElemY0 = pElem->rElem.y;
+  nElemX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nElemY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemW  = pElem->rElem.w;
+  nElemH  = pElem->rElem.h;
+
+  bool    bVert = pGauge->bVert;
+  bool    bFlip = pGauge->bFlip;
+  int16_t nMax  = pGauge->nMax;
+  int16_t nMin  = pGauge->nMin;
+  int16_t nRng  = pGauge->nMax - pGauge->nMin;
+
+  uint32_t nScl = 1;
+  int16_t nGaugeMid = 0;
+  int16_t nLen = 0;
+  int16_t nTmp = 0;
+  int32_t nTmpL = 0;
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXProgressDraw() Zero gauge range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  if (bVert) {
+    nScl = nElemH*32768/nRng;
+  } else {
+    nScl = nElemW*32768/nRng;
+  }
+
+  // Calculate the control midpoint/zeropoint (for display purposes)
+  nTmpL = -((int32_t)nMin * (int32_t)nScl / 32768);
+  nGaugeMid = (int16_t)nTmpL;
+
+
+  // Calculate the length of the bar
+  // - Use long mult/divide to avoid need for floating point
+  nTmpL = (int32_t)(pGauge->nVal) * (int32_t)(nScl) / 32768;
+  nLen  = (int16_t)(nTmpL);
+
+  // Define the gauge's fill rectangle region
+  // depending on the orientation (bVert) and whether
+  // the current position is negative or positive.
+  if (nLen >= 0) {
+    if (bVert) {
+      nGaugeY0 = nElemY0 + nGaugeMid;
+      nGaugeY1 = nElemY0 + nGaugeMid + nLen;
+    } else {
+      nGaugeX0 = nElemX0 + nGaugeMid;
+      nGaugeX1 = nElemX0 + nGaugeMid + nLen;
+    }
+  } else {
+    if (bVert) {
+      nGaugeY0 = nElemY0 + nGaugeMid + nLen;
+      nGaugeY1 = nElemY0 + nGaugeMid;
+    } else {
+      nGaugeX0 = nElemX0 + nGaugeMid + nLen;
+      nGaugeX1 = nElemX0 + nGaugeMid;
+    }
+  }
+  if (bVert) {
+    nGaugeX0 = nElemX0;
+    nGaugeX1 = nElemX1;
+  } else {
+    nGaugeY0 = nElemY0;
+    nGaugeY1 = nElemY1;
+  }
+
+
+  // Clip the region
+  nGaugeX0 = (nGaugeX0 < nElemX0)? nElemX0 : nGaugeX0;
+  nGaugeY0 = (nGaugeY0 < nElemY0)? nElemY0 : nGaugeY0;
+  nGaugeX1 = (nGaugeX1 > nElemX1)? nElemX1 : nGaugeX1;
+  nGaugeY1 = (nGaugeY1 > nElemY1)? nElemY1 : nGaugeY1;
+
+  // Support flipping of gauge directionality
+  // - The bFlip flag reverses the fill direction
+  // - Vertical gauges are flipped by default
+
+  if (bVert && !bFlip) {
+    nTmp      = nElemY0+(nElemY1-nGaugeY1);  // nTmp will be swapped into nGaugeY0
+    nGaugeY1  = nElemY1-(nGaugeY0-nElemY0);
+    nGaugeY0  = nTmp;
+    nGaugeMid = nElemH-nGaugeMid-1;
+  } else if (!bVert && bFlip) {
+    nTmp      = nElemX0+(nElemX1-nGaugeX1);  // nTmp will be swapped into nGaugeX0
+    nGaugeX1  = nElemX1-(nGaugeX0-nElemX0);
+    nGaugeX0  = nTmp;
+    nGaugeMid = nElemW-nGaugeMid-1;
+  }
+
+  #ifdef DBG_LOG
+  //printf("Gauge: nMin=%4d nMax=%4d nRng=%d nVal=%4d fScl=%6.3f nGaugeMid=%4d RectX=%4d RectW=%4d\n",
+  //  nMin,nMax,nRng,pGauge->nGaugeVal,fScl,nGaugeMid,rGauge.x,rGauge.w);
+  #endif
+
+  // Draw a frame around the gauge
+  // - Only draw this during full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+  }
+
+  // To avoid flicker, we only erase the portion of the gauge
+  // that isn't "filled". Determine the gauge empty region and erase it
+  // There are two empty regions (one in negative and one in positive)
+  int16_t nEmptyPos;
+  if (bVert) {
+    // Empty Region #1 (negative)
+    nEmptyPos = (nGaugeY0 > nElemY1) ? nElemY1 : nGaugeY0;
+    rEmpty = (gslc_tsRect){nElemX0,nElemY0,nElemX1-nElemX0+1,nEmptyPos-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui,rTmp,pElem->colElemFill);
+    // Empty Region #2 (positive)
+    nEmptyPos = (nGaugeY1 < nElemY0) ? nElemY0 : nGaugeY1;
+    rEmpty = (gslc_tsRect){nElemX0,nEmptyPos,nElemX1-nElemX0+1,nElemY1-nEmptyPos+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui,rTmp,pElem->colElemFill);
+  } else {
+    // Empty Region #1 (negative)
+    nEmptyPos = (nGaugeX0 > nElemX1) ? nElemX1 : nGaugeX0;
+    rEmpty = (gslc_tsRect){nElemX0,nElemY0,nEmptyPos-nElemX0+1,nElemY1-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui, rTmp, pElem->colElemFill);
+    // Empty Region #2 (positive)
+    nEmptyPos = (nGaugeX1 < nElemX0) ? nElemX0 : nGaugeX1;
+    rEmpty = (gslc_tsRect){nEmptyPos,nElemY0,nElemX1-nEmptyPos+1,nElemY1-nElemY0+1};
+    rTmp = gslc_ExpandRect(rEmpty,-1,-1);
+    gslc_DrawFillRect(pGui, rTmp, pElem->colElemFill);
+  }
+
+  // Draw the gauge fill region
+  rGauge = (gslc_tsRect){nGaugeX0,nGaugeY0,nGaugeX1-nGaugeX0+1,nGaugeY1-nGaugeY0+1};
+  rTmp = gslc_ExpandRect(rGauge,-1,-1);
+  gslc_DrawFillRect(pGui,rTmp,pGauge->colGauge);
+
+
+  // Draw the midpoint line
+  if (bVert) {
+    if (nElemY0 + nGaugeMid < nElemY1) {
+      gslc_DrawLine(pGui, nElemX0, nElemY0 + nGaugeMid, nElemX1, nElemY0 + nGaugeMid, pElem->colElemFrame);
+    }
+  } else {
+    if (nElemX0 + nGaugeMid < nElemX1) {
+      gslc_DrawLine(pGui, nElemX0 + nGaugeMid, nElemY0, nElemX0 + nGaugeMid, nElemY1, pElem->colElemFrame);
+    }
+  }
+
+
+
+  return true;
+}
+
+// ============================================================================
diff --git a/src/guislice/XProgress.h b/src/guislice/XProgress.h
new file mode 100644
index 0000000..ad27aec
--- /dev/null
+++ b/src/guislice/XProgress.h
@@ -0,0 +1,287 @@
+#ifndef _GUISLICE_EX_XPROGRESS_H_
+#define _GUISLICE_EX_XPROGRESS_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Progress Bar
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XProgress.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Progress Bar
+// - Basic progress bar with support for vertical / horizontal orientation and
+//   fill direction. Also provides an indicator of negative regions, depending
+//   on the configured range.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_PROGRESS GSLC_TYPE_BASE_EXTEND + 60
+
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Gauge element
+typedef struct {
+  // Range config
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+
+  // Current value
+  int16_t             nVal;           ///< Current control value
+  // Previous value
+  int16_t             nValLast;       ///< Last value
+  bool                bValLastValid;  ///< Last value valid?
+
+  // Appearance config
+  gslc_tsColor        colGauge;       ///< Color of gauge fill bar
+  bool                bVert;          ///< Vertical if true, else Horizontal
+  bool                bFlip;          ///< Reverse direction of gauge
+
+} gslc_tsXProgress;
+
+
+///
+/// Create a Progress Bar Element
+/// - Draws a gauge element that represents a proportion (nVal)
+///   between nMin and nMax.
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining gauge size
+/// \param[in]  nMin:        Minimum value of gauge for nVal comparison
+/// \param[in]  nMax:        Maximum value of gauge for nVal comparison
+/// \param[in]  nVal:        Starting value of gauge
+/// \param[in]  colGauge:    Color for the gauge indicator
+/// \param[in]  bVert:       Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXProgressCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXProgress* pXData,gslc_tsRect rElem,int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert);
+
+
+///
+/// Update a Gauge element's current value
+/// - Note that min & max values are assigned in create()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New value to show in gauge
+///
+/// \return none
+///
+void gslc_ElemXProgressSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+///
+/// Set a Gauge element's fill direction
+/// - Setting bFlip reverses the default fill direction
+/// - Default fill direction for horizontal gauges: left-to-right
+/// - Default fill direction for vertical gauges: bottom-to-top
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bFlip:       If set, reverse direction of fill from default
+///
+/// \return none
+///
+void gslc_ElemXProgressSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip);
+
+
+///
+/// Draw a gauge element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \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]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXProgressDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Helper function to draw a gauge with style: progress bar
+/// - Called from gslc_ElemXProgressDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXProgressDrawHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXProgressCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_)
+///
+/// Create a Gauge Element in Flash
+///
+/// \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]  nMin_:       Minimum value of gauge for nVal comparison
+/// \param[in]  nMax_:       Maximum value of gauge for nVal comparison
+/// \param[in]  nVal_:       Starting value of gauge
+/// \param[in]  colFrame_:   Color for the gauge frame
+/// \param[in]  colFill_:    Color for the gauge background fill
+/// \param[in]  colGauge_:   Color for the gauge indicator
+/// \param[in]  bVert_:      Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXProgressCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXProgress sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.bVert = bVert_;                                 \
+  sGauge##nElemId.bFlip = false;                                  \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_PROGRESS,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXProgressDraw,                                       \
+      NULL,                                                       \
+      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_ElemXProgressCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_,bVert_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXProgress sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.bVert = bVert_;                                 \
+  sGauge##nElemId.bFlip = false;                                  \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_PROGRESS,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXProgressDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XPROGRESS_H_
+
diff --git a/src/guislice/XRadial.c b/src/guislice/XRadial.c
new file mode 100644
index 0000000..98d893a
--- /dev/null
+++ b/src/guislice/XRadial.c
@@ -0,0 +1,363 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XRadial.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XRadial.h"
+
+#include <stdio.h>
+
+#include <math.h>   // For sin/cos
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Radial Gauge
+// - A circular gauge that can be used to show direction or other
+//   rotational values. Tick marks can be optionally drawn
+//   around the gauge.
+// - Size, color and fill of the needle can be configured.
+// ============================================================================
+
+// Create a radial gauge element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXRadialCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXRadial* pXData,gslc_tsRect rElem,
+  int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_RADIAL,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;  // Element is not "clickable"
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->nMin            = nMin;
+  pXData->nMax            = nMax;
+  pXData->nVal            = nVal;
+  pXData->bFlip           = false;
+  pXData->colGauge        = colGauge;
+  pXData->colTick         = GSLC_COL_GRAY;
+  pXData->nTickCnt        = 8;
+  pXData->nTickLen        = 5;
+  pXData->nIndicLen       = 10;     // Dummy default to be overridden
+  pXData->nIndicTip       = 3;      // Dummy default to be overridden
+  pXData->bIndicFill      = false;
+  sElem.pXData            = (void*)(pXData);
+  sElem.pfuncXDraw        = &gslc_ElemXRadialDraw;
+  sElem.pfuncXTouch       = NULL;           // No need to track touches
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void gslc_ElemXRadialSetIndicator(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colGauge,
+    uint16_t nIndicLen,uint16_t nIndicTip,bool bIndicFill)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialSetIndicator";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  // Update the config
+  pGauge->colGauge    = colGauge;
+  pGauge->nIndicLen   = nIndicLen;
+  pGauge->nIndicTip   = nIndicTip;
+  pGauge->bIndicFill  = bIndicFill;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRadialSetTicks(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colTick,uint16_t nTickCnt,uint16_t nTickLen)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialSetTicks";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  // Update the config
+  pGauge->colTick   = colTick;
+  pGauge->nTickCnt  = nTickCnt;
+  pGauge->nTickLen  = nTickLen;
+
+  // Just in case we were called at runtime, mark as needing redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+// Update the gauge control's current position
+void gslc_ElemXRadialSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialSetVal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  // Update the data element
+  int16_t nValOld = pGauge->nVal;
+  pGauge->nVal = nVal;
+
+  // Element needs redraw
+  if (nVal != nValOld) {
+    // We only need an incremental redraw
+    // NOTE: If the user configures the indicator to be
+    //       long enough that it overlaps some of the gauge indicators
+    //       then a full redraw should be done instead.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+// Update the gauge's rotation direction
+// - Setting bFlip reverses the rotation direction
+// - Default rotation is clockwise. When bFlip is set, uses counter-clockwise
+void gslc_ElemXRadialSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialSetFlip";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+
+  // Fetch the element's extended data structure
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+  if (pGauge == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXRadialSetFlip(%s) pXData is NULL\n","");
+    return;
+  }
+  pGauge->bFlip = bFlip;
+
+  // Mark for redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+
+}
+
+
+// Redraw the gauge
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXRadialDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRadialDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  gslc_ElemXRadialDrawRadial(pGui,pElemRef,eRedraw);
+
+  // Save as "last state" to support incremental erase/redraw
+  pGauge->nValLast      = pGauge->nVal;
+  pGauge->bValLastValid = true;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+void gslc_ElemXRadialDrawRadialHelp(gslc_tsGui* pGui,int16_t nX,int16_t nY,uint16_t nArrowLen,uint16_t nArrowSz,int16_t n64Ang,bool bFill,gslc_tsColor colFrame)
+{
+  int16_t   nTipX,nTipY;
+  int16_t   nBaseX1,nBaseY1,nBaseX2,nBaseY2;
+  int16_t   nTipBaseX,nTipBaseY;
+
+  gslc_PolarToXY(nArrowLen,n64Ang,&nTipX,&nTipY);
+  gslc_PolarToXY(nArrowLen-nArrowSz,n64Ang,&nTipBaseX,&nTipBaseY);
+  gslc_PolarToXY(nArrowSz,n64Ang-90*64,&nBaseX1,&nBaseY1);
+  gslc_PolarToXY(nArrowSz,n64Ang+90*64,&nBaseX2,&nBaseY2);
+
+  // FIXME: There appears to be a wrapping bug in the trigonometry
+  //        calculations associated with the bottom-right corner
+  //        of the pointer body when angles approach 359 degrees.
+
+  if (!bFill) {
+    // Framed
+    gslc_DrawLine(pGui,nX+nBaseX1,nY+nBaseY1,nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX2,nY+nBaseY2,nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY,nX+nTipX,nY+nTipY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY,nX+nTipX,nY+nTipY,colFrame);
+    gslc_DrawLine(pGui,nX+nBaseX1,nY+nBaseY1,nX+nBaseX2,nY+nBaseY2,colFrame);
+
+  } else {
+    // Filled
+    gslc_tsPt asPt[4];
+
+    // Main body of pointer
+    asPt[0] = (gslc_tsPt){nX+nBaseX1,nY+nBaseY1};
+    asPt[1] = (gslc_tsPt){nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY};
+    asPt[2] = (gslc_tsPt){nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY};
+    asPt[3] = (gslc_tsPt){nX+nBaseX2,nY+nBaseY2};
+    gslc_DrawFillQuad(pGui,asPt,colFrame);
+
+    // Tip of pointer
+    asPt[0] = (gslc_tsPt){nX+nBaseX1+nTipBaseX,nY+nBaseY1+nTipBaseY};
+    asPt[1] = (gslc_tsPt){nX+nTipX,nY+nTipY};
+    asPt[2] = (gslc_tsPt){nX+nBaseX2+nTipBaseX,nY+nBaseY2+nTipBaseY};
+    gslc_DrawFillTriangle(pGui,asPt[0].x,asPt[0].y,asPt[1].x,asPt[1].y,asPt[2].x,asPt[2].y,colFrame);
+
+  }
+
+}
+
+bool gslc_ElemXRadialDrawRadial(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXRadial*  pGauge  = (gslc_tsXRadial*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RADIAL,__LINE__);
+
+  uint16_t      nElemW,nElemH,nElemRad;
+  int16_t       nElemX0,nElemY0,nElemX1,nElemY1;
+  int16_t       nElemMidX,nElemMidY;
+  nElemX0   = pElem->rElem.x;
+  nElemY0   = pElem->rElem.y;
+  nElemX1   = pElem->rElem.x + pElem->rElem.w - 1;
+  nElemY1   = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemMidX = (nElemX0+nElemX1)/2;
+  nElemMidY = (nElemY0+nElemY1)/2;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+  nElemRad  = (nElemW>=nElemH)? nElemH/2 : nElemW/2;
+
+  int16_t   nMax            = pGauge->nMax;
+  int16_t   nMin            = pGauge->nMin;
+  int16_t   nRng            = pGauge->nMax - pGauge->nMin;
+  int16_t   nVal            = pGauge->nVal;
+  int16_t   nValLast        = pGauge->nValLast;
+  bool      bValLastValid   = pGauge->bValLastValid;
+  uint16_t  nTickLen        = pGauge->nTickLen;
+  uint16_t  nTickAng        = 360 / pGauge->nTickCnt;
+  uint16_t  nArrowLen       = pGauge->nIndicLen;
+  uint16_t  nArrowSize      = pGauge->nIndicTip;
+  bool      bFill           = pGauge->bIndicFill;
+
+  int16_t   n64Ang,n64AngLast;
+  int16_t   nInd;
+
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXRadialDraw() Zero range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  // Support reversing of direction
+  // TODO: Clean up excess integer typecasting
+  if (pGauge->bFlip) {
+    n64Ang      = (int32_t)(nMax - nVal    )* 360*64 /nRng;
+    n64AngLast  = (int32_t)(nMax - nValLast)* 360*64 /nRng;
+  } else {
+    n64Ang      = (int32_t)(nVal     - nMin)* 360*64 /nRng;
+    n64AngLast  = (int32_t)(nValLast - nMin)* 360*64 /nRng;
+  }
+
+  // Clear old
+  if (bValLastValid) {
+    gslc_ElemXRadialDrawRadialHelp(pGui,nElemMidX,nElemMidY,nArrowLen,nArrowSize,n64AngLast,bFill,pElem->colElemFill);
+  }
+
+  // Draw frame
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFillCircle(pGui,nElemMidX,nElemMidY,nElemRad,pElem->colElemFill);  // Erase first
+    gslc_DrawFrameCircle(pGui,nElemMidX,nElemMidY,nElemRad,pElem->colElemFrame);
+    for (nInd=0;nInd<360;nInd+=nTickAng) {
+      gslc_DrawLinePolar(pGui,nElemMidX,nElemMidY,nElemRad-nTickLen,nElemRad,nInd*64,pGauge->colTick);
+    }
+  }
+
+  // Draw pointer
+  gslc_ElemXRadialDrawRadialHelp(pGui,nElemMidX,nElemMidY,nArrowLen,nArrowSize,n64Ang,bFill,pGauge->colGauge);
+
+  return true;
+}
+
+
+// ============================================================================
diff --git a/src/guislice/XRadial.h b/src/guislice/XRadial.h
new file mode 100644
index 0000000..86af07e
--- /dev/null
+++ b/src/guislice/XRadial.h
@@ -0,0 +1,327 @@
+#ifndef _GUISLICE_EX_XRADIAL_H_
+#define _GUISLICE_EX_XRADIAL_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Radial control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XRadial.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Radial Gauge
+// - A circular gauge that can be used to show direction or other
+//   rotational values. Tick marks can be optionally drawn
+//   around the gauge.
+// - Size, color and fill of the needle can be configured.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_RADIAL GSLC_TYPE_BASE_EXTEND + 61
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Gauge element
+typedef struct {
+  // Range config
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+
+  // Current value
+  int16_t             nVal;           ///< Current control value
+  // Previous value
+  int16_t             nValLast;       ///< Last value
+  bool                bValLastValid;  ///< Last value valid?
+
+  // Appearance config
+  gslc_tsColor        colGauge;       ///< Color of gauge fill bar
+  gslc_tsColor        colTick;        ///< Color of gauge tick marks
+  uint16_t            nTickCnt;       ///< Number of gauge tick marks
+  uint16_t            nTickLen;       ///< Length of gauge tick marks
+  bool                bFlip;          ///< Reverse direction of gauge
+  uint16_t            nIndicLen;      ///< Indicator length
+  uint16_t            nIndicTip;      ///< Size of tip at end of indicator
+  bool                bIndicFill;     ///< Fill the indicator if true
+
+} gslc_tsXRadial;
+
+
+///
+/// Create a Radial Gauge Element
+/// - Draws a gauge element that represents a proportion (nVal)
+///   between nMin and nMax.
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining gauge size
+/// \param[in]  nMin:        Minimum value of gauge for nVal comparison
+/// \param[in]  nMax:        Maximum value of gauge for nVal comparison
+/// \param[in]  nVal:        Starting value of gauge
+/// \param[in]  colGauge:    Color for the gauge indicator
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXRadialCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXRadial* pXData,gslc_tsRect rElem,int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge);
+
+
+
+///
+/// Configure the appearance of the Gauge indicator
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colGauge:    Color of the indicator
+/// \param[in]  nIndicLen:   Length of the indicator
+/// \param[in]  nIndicTip:   Size of the indicator tip
+/// \param[in]  bIndicFill:  Fill in the indicator if true
+///
+/// \return none
+///
+void gslc_ElemXRadialSetIndicator(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colGauge,
+        uint16_t nIndicLen,uint16_t nIndicTip,bool bIndicFill);
+
+
+///
+/// Configure the appearance of the Gauge ticks
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colTick:     Color of the gauge ticks
+/// \param[in]  nTickCnt:    Number of ticks to draw around / along gauge
+/// \param[in]  nTickLen:    Length of the tick marks to draw
+///
+/// \return none
+///
+void gslc_ElemXRadialSetTicks(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor colTick,uint16_t nTickCnt,uint16_t nTickLen);
+
+
+///
+/// Update a Gauge element's current value
+/// - Note that min & max values are assigned in create()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New value to show in gauge
+///
+/// \return none
+///
+void gslc_ElemXRadialSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+///
+/// Set a Gauge element's rotation direction
+/// - Setting bFlip reverses the rotation direction
+/// - Default rotation is clockwise. When bFlip is set, uses counter-clockwise
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bFlip:       If set, reverse direction of rotation from default
+///
+/// \return none
+///
+void gslc_ElemXRadialSetFlip(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bFlip);
+
+
+///
+/// Draw a gauge element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \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]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRadialDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Helper function to draw a gauge with style: radial
+/// - Called from gslc_ElemXRadialDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRadialDrawRadial(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+/// \def gslc_ElemXRadialCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_)
+///
+/// Create a Gauge Element in Flash
+///
+/// \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]  nMin_:       Minimum value of gauge for nVal comparison
+/// \param[in]  nMax_:       Maximum value of gauge for nVal comparison
+/// \param[in]  nVal_:       Starting value of gauge
+/// \param[in]  colFrame_:   Color for the gauge frame
+/// \param[in]  colFill_:    Color for the gauge background fill
+/// \param[in]  colGauge_:   Color for the gauge indicator
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXRadialCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXRadial sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.colTick = GSLC_COL_GRAY;                        \
+  sGauge##nElemId.nTickCnt = 8;                                   \
+  sGauge##nElemId.nTickLen = 5;                                   \
+  sGauge##nElemId.bFlip = false;                                  \
+  sGauge##nElemId.nIndicLen = 10;                                 \
+  sGauge##nElemId.nIndicTip = 3;                                  \
+  sGauge##nElemId.bIndicFill = false;                             \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_RADIAL,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXRadialDraw,                                       \
+      NULL,                                                       \
+      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_ElemXRadialCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_,colGauge_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXRadial sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  sGauge##nElemId.colGauge = colGauge_;                           \
+  sGauge##nElemId.colTick = GSLC_COL_GRAY;                        \
+  sGauge##nElemId.nTickCnt = 8;                                   \
+  sGauge##nElemId.nTickLen = 5;                                   \
+  sGauge##nElemId.bFlip = false;                                  \
+  sGauge##nElemId.nIndicLen = 10;                                 \
+  sGauge##nElemId.nIndicTip = 3;                                  \
+  sGauge##nElemId.bIndicFill = false;                             \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_RADIAL,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXRadialDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XRADIAL_H_
+
diff --git a/src/guislice/XRamp.c b/src/guislice/XRamp.c
new file mode 100644
index 0000000..defc850
--- /dev/null
+++ b/src/guislice/XRamp.c
@@ -0,0 +1,300 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XRamp.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XRamp.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Ramp Gauge
+// - Demonstration of a gradient ramp (green-yellow-red) visual
+//   control similar to certain linear tachometers.
+// - The ramp rises up and to the right according to the
+//   current value.
+// - Note that this element is mainly intended as a demonstration
+//   example. Additional APIs would be recommended to make it
+//   more configurable.
+// ============================================================================
+
+// Create a gauge element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw but does not track touch/click
+gslc_tsElemRef* gslc_ElemXRampCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXRamp* pXData,gslc_tsRect rElem,
+  int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRampCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_RAMP,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;  // Element is not "clickable"
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+  pXData->nMin            = nMin;
+  pXData->nMax            = nMax;
+  pXData->nVal            = nVal;
+  sElem.pXData            = (void*)(pXData);
+  sElem.pfuncXDraw        = &gslc_ElemXRampDraw;
+  sElem.pfuncXTouch       = NULL;           // No need to track touches
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// Update the gauge control's current position
+void gslc_ElemXRampSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRampSetVal";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXRamp*  pGauge  = (gslc_tsXRamp*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RAMP,__LINE__);
+
+  // Update the data element
+  int16_t nValOld = pGauge->nVal;
+  pGauge->nVal = nVal;
+
+  // Element needs redraw
+  if (nVal != nValOld) {
+    // We only need an incremental redraw
+    // NOTE: If the user configures the indicator to be
+    //       long enough that it overlaps some of the gauge indicators
+    //       then a full redraw should be done instead.
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+
+// Redraw the gauge
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXRampDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRampDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXRamp*  pGauge  = (gslc_tsXRamp*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RAMP,__LINE__);
+
+  gslc_ElemXRampDrawHelp(pGui,pElemRef,eRedraw);
+
+  // Save as "last state" to support incremental erase/redraw
+  pGauge->nValLast      = pGauge->nVal;
+  pGauge->bValLastValid = true;
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+}
+
+
+bool gslc_ElemXRampDrawHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsElem*   pElem   = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXRamp*  pGauge  = (gslc_tsXRamp*)gslc_GetXDataFromRef(pGui,pElemRef,GSLC_TYPEX_RAMP,__LINE__);
+
+  uint16_t      nElemW,nElemH;
+  int16_t       nElemX0,nElemY1;
+  nElemX0   = pElem->rElem.x;
+  nElemY1   = pElem->rElem.y + pElem->rElem.h - 1;
+  nElemW    = pElem->rElem.w;
+  nElemH    = pElem->rElem.h;
+
+  int16_t   nMax            = pGauge->nMax;
+  int16_t   nMin            = pGauge->nMin;
+  int16_t   nRng            = pGauge->nMax - pGauge->nMin;
+  int16_t   nVal            = pGauge->nVal;
+  int16_t   nValLast        = pGauge->nValLast;
+  bool      bValLastValid   = pGauge->bValLastValid;
+  int16_t   nInd;
+
+  if (nRng == 0) {
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXRampDrawHelp() Zero range [%d,%d]\n",nMin,nMax);
+    return false;
+  }
+
+  uint32_t  nSclFX;
+  uint16_t  nHeight;
+  int32_t   nHeightTmp;
+  uint16_t  nHeightBot;
+  uint16_t  nX;
+  uint16_t  nColInd;
+
+  // Calculate region to draw or clear
+  bool      bModeErase;
+  int16_t   nValStart;
+  int16_t   nValEnd;
+  if ((eRedraw == GSLC_REDRAW_INC) && (!bValLastValid)) {
+    // - If the request was incremental (GSLC_REDRAW_INC) but
+    //   the last value wasn't marked as valid (!bValLastValid)
+    //   then we want to force a full redraw.
+    // - We don't expect to enter here since bValLastValid
+    //   should always be set after we perform our first
+    //   redraw.
+    eRedraw = GSLC_REDRAW_FULL;
+  }
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    // If we haven't drawn anything before, draw full range from zero
+    bModeErase  = false;
+    nValStart   = 0;
+    nValEnd     = nVal;
+  } else {
+    if (nVal >= nValLast) {
+      // As we are advancing the control, we just draw the new range
+      bModeErase  = false;
+      nValStart   = nValLast;
+      nValEnd     = nVal;
+    } else {
+      // Since we are retracting the control, we erase the new range
+      bModeErase  = true;
+      nValStart   = nVal;
+      nValEnd     = nValLast;
+    }
+  }
+
+  // Calculate the scaled gauge position
+  // - TODO: Also support reversing of direction
+  int16_t   nPosXStart,nPosXEnd;
+  nPosXStart  = (nValStart - nMin)*nElemW/nRng;
+  nPosXEnd    = (nValEnd   - nMin)*nElemW/nRng;
+
+  nSclFX = (uint32_t)nElemH*32767/(nElemW*nElemW);
+
+  for (nX=nPosXStart;nX<nPosXEnd;nX++) {
+    nInd = nElemW-nX;
+    nHeightTmp = nSclFX * nInd*nInd /32767;
+    nHeight = nElemH-nHeightTmp;
+    if (nHeight >= 20) {
+      nHeightBot = nHeight-20;
+    } else {
+      nHeightBot = 0;
+    }
+    gslc_tsColor  nCol;
+    uint16_t      nSteps = 10;
+    uint16_t      nGap = 3;
+
+    if (nSteps == 0) {
+      nColInd = nX*1000/nElemW;
+      nCol = gslc_ColorBlend3(GSLC_COL_GREEN,GSLC_COL_YELLOW,GSLC_COL_RED,500,nColInd);
+    } else {
+      uint16_t  nBlockLen,nSegLen,nSegInd,nSegOffset,nSegStart;
+      nBlockLen = (nElemW-(nSteps-1)*nGap)/nSteps;
+      nSegLen = nBlockLen + nGap;
+      nSegInd = nX/nSegLen;
+      nSegOffset = nX % nSegLen;
+      nSegStart = nSegInd * nSegLen;
+
+      if (nSegOffset <= nBlockLen) {
+        // Inside block
+        nColInd = (uint32_t)nSegStart*1000/nElemW;
+        nCol = gslc_ColorBlend3(GSLC_COL_GREEN,GSLC_COL_YELLOW,GSLC_COL_RED,500,nColInd);
+
+      } else {
+        // Inside gap
+        // - No draw
+        nCol = pElem->colElemFill;
+      }
+
+    }
+
+    if (bModeErase) {
+      nCol = pElem->colElemFill;
+    }
+    gslc_DrawLine(pGui,nElemX0+nX,nElemY1-nHeightBot,nElemX0+nX,nElemY1-nHeight,nCol);
+
+  }
+
+  return true;
+}
+
+
+// ============================================================================
diff --git a/src/guislice/XRamp.h b/src/guislice/XRamp.h
new file mode 100644
index 0000000..c0a6823
--- /dev/null
+++ b/src/guislice/XRamp.h
@@ -0,0 +1,264 @@
+#ifndef _GUISLICE_EX_XRAMP_H_
+#define _GUISLICE_EX_XRAMP_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Ramp gauge
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XRamp.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Ramp Gauge
+// - Demonstration of a gradient ramp (green-yellow-red) visual
+//   control similar to certain linear tachometers.
+// - The ramp rises up and to the right according to the
+//   current value.
+// - Note that this element is mainly intended as a demonstration
+//   example. Additional APIs would be recommended to make it
+//   more configurable.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_RAMP GSLC_TYPE_BASE_EXTEND + 62
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Gauge element
+typedef struct {
+  // Range config
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+
+  // Current value
+  int16_t             nVal;           ///< Current control value
+  // Previous value
+  int16_t             nValLast;       ///< Last value
+  bool                bValLastValid;  ///< Last value valid?
+
+  // Appearance config
+
+} gslc_tsXRamp;
+
+
+///
+/// Create a Ramp Gauge Element
+/// - Draws a gauge element that represents a proportion (nVal)
+///   between nMin and nMax.
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining gauge size
+/// \param[in]  nMin:        Minimum value of gauge for nVal comparison
+/// \param[in]  nMax:        Maximum value of gauge for nVal comparison
+/// \param[in]  nVal:        Starting value of gauge
+/// \param[in]  colGauge:    Color for the gauge indicator
+/// \param[in]  bVert:       Flag to indicate vertical vs horizontal action
+///                          (true = vertical, false = horizontal)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXRampCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXRamp* pXData,gslc_tsRect rElem,int16_t nMin,int16_t nMax,int16_t nVal,gslc_tsColor colGauge,bool bVert);
+
+
+
+///
+/// Update a Gauge element's current value
+/// - Note that min & max values are assigned in create()
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New value to show in gauge
+///
+/// \return none
+///
+void gslc_ElemXRampSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+
+
+///
+/// Draw a gauge element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \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]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRampDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Helper function to draw a gauge with style: ramp
+/// - Called from gslc_ElemXRampDraw()
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pElemRef:    Ptr to Element reference
+/// \param[in]  eRedraw:     Redraw status
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRampDrawHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_teRedrawType eRedraw);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXRampCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nMin_,nMax_,nVal_,colFrame_,colFill_)
+///
+/// Create a Gauge Element in Flash
+///
+/// \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]  nMin_:       Minimum value of gauge for nVal comparison
+/// \param[in]  nMax_:       Maximum value of gauge for nVal comparison
+/// \param[in]  nVal_:       Starting value of gauge
+/// \param[in]  colFrame_:   Color for the gauge frame
+/// \param[in]  colFill_:    Color for the gauge background fill
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXRampCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXRamp sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_RAMP,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXRampDraw,                                       \
+      NULL,                                                       \
+      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_ElemXRampCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,\
+    nMin_,nMax_,nVal_,colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXRamp sGauge##nElemId;                           \
+  sGauge##nElemId.nMin = nMin_;                                   \
+  sGauge##nElemId.nMax = nMax_;                                   \
+  sGauge##nElemId.nVal = nVal_;                                   \
+  sGauge##nElemId.nValLast = nVal_;                               \
+  sGauge##nElemId.bValLastValid = false;                          \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_RAMP,                                           \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sGauge##nElemId),                                  \
+      NULL,                                                       \
+      &gslc_ElemXRampDraw,                                       \
+      NULL,                                                       \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XRAMP_H_
+
diff --git a/src/guislice/XRingGauge.c b/src/guislice/XRingGauge.c
new file mode 100644
index 0000000..87d436a
--- /dev/null
+++ b/src/guislice/XRingGauge.c
@@ -0,0 +1,413 @@
+// =======================================================================
+// GUIslice library (Ring control)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XRingGauge.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XRingGauge.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Ring gauge
+// ============================================================================
+
+// Create a text element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXRingGaugeCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+    gslc_tsXRingGauge* pXData, gslc_tsRect rElem, char* pStrBuf, uint8_t nStrBufMax, int16_t nFontId)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXRingGaugeCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_RING,rElem,pStrBuf,nStrBufMax,nFontId);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_BLUE;
+  sElem.colElemText       = GSLC_COL_YELLOW;
+  sElem.nFeatures         = GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  sElem.eTxtAlign         = GSLC_ALIGN_MID_MID;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Provide default config
+  pXData->nValMin = 0;
+  pXData->nValMax = 100;
+  pXData->nAngStart = 0;
+  pXData->nAngRange = 360;
+  pXData->nThickness = 10;
+
+  pXData->nQuality = 72; // 360/72=5 degree segments
+
+  pXData->bGradient = false;
+  pXData->nSegGap = 0;
+  pXData->colRing1 = GSLC_COL_BLUE_LT4;
+  pXData->colRing2 = GSLC_COL_RED;
+  pXData->colRingRemain = (gslc_tsColor) { 0, 0, 48 };
+
+  pXData->nVal = 0;
+  pXData->nValLast = 0;
+  pXData->acStrLast[0] = 0;
+
+
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXRingGaugeDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch = NULL;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// Redraw the element
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXRingGaugeDraw(void* pvGui, void* pvElemRef, gslc_teRedrawType eRedraw)
+{
+  gslc_tsGui* pGui = (gslc_tsGui*)pvGui;
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)pvElemRef;
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return false;
+
+
+  // --------------------------------------------------------------------------
+  // Init for default drawing
+  // --------------------------------------------------------------------------
+
+  bool      bGlowEn, bGlowing, bGlowNow;
+  int16_t   nElemX, nElemY;
+  uint16_t  nElemW, nElemH;
+
+  nElemX = pElem->rElem.x;
+  nElemY = pElem->rElem.y;
+  nElemW = pElem->rElem.w;
+  nElemH = pElem->rElem.h;
+  bGlowEn = pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN; // Does the element support glow state?
+  bGlowing = gslc_ElemGetGlow(pGui, pElemRef); // Element should be glowing (if enabled)
+  bGlowNow = bGlowEn & bGlowing; // Element is currently glowing
+
+  int16_t nVal = pXRingGauge->nVal;
+  int16_t nValLast = pXRingGauge->nValLast;
+  int16_t nValMin = pXRingGauge->nValMin;
+  int16_t nValMax = pXRingGauge->nValMax;
+  int16_t nValRange = (nValMax == nValMin)? 1 : (nValMax - nValMin); // Guard against div/0
+  int16_t nAngStart = pXRingGauge->nAngStart;
+  int16_t nAngRange = pXRingGauge->nAngRange;
+  //int16_t nAngEnd = nAngStart + nAngRange;
+  int16_t nQuality = pXRingGauge->nQuality;
+
+  gslc_tsColor colRingActive1 = pXRingGauge->colRing1;
+  gslc_tsColor colRingActive2 = pXRingGauge->colRing2;
+  gslc_tsColor colRingInactive = pXRingGauge->colRingRemain;
+  bool bGradient = pXRingGauge->bGradient;
+  gslc_tsColor colBg = pElem->colElemFill; // Background color used for text clearance
+
+  // Calculate the ring center and radius
+  int16_t nMidX = nElemX + nElemW / 2;
+  int16_t nMidY = nElemY + nElemH / 2;
+  int16_t nRad2 = (nElemW < nElemH) ? nElemW / 2 : nElemH / 2;
+  int16_t nRad1 = nRad2 - pXRingGauge->nThickness;
+
+  // --------------------------------------------------------------------------
+
+  // Determine whether we should draw the full range (full redraw)
+  // or a smaller, updated region (incremental redraw)
+  bool bInc = (eRedraw == GSLC_REDRAW_INC) ? true : false;
+
+  int16_t nDrawStart = 0;
+  int16_t nDrawVal = 0;
+  int16_t nDrawEnd = 0;
+
+  bool bDrawActive = false;
+  bool bDrawInactive = false;
+  if (bInc) {
+    if (nVal > nValLast) {
+      // Incremental redraw: adding value, so draw with active color
+      bDrawActive = true;
+      nDrawStart = (int32_t)(nValLast - nValMin) * nAngRange / nValRange;
+      nDrawVal = (int32_t)(nVal - nValMin) * nAngRange / nValRange;
+    }
+    else {
+      // Incremental redraw: reducing value, so draw with inactive color
+      bDrawInactive = true;
+      nDrawVal = (int32_t)(nVal - nValMin) * nAngRange / nValRange;
+      nDrawEnd = (int32_t)(nValLast - nValMin) * nAngRange / nValRange;
+    }
+  } else {
+    // Full redraw: draw both active and inactive regions
+    bDrawActive = true;
+    bDrawInactive = true;
+    nDrawStart = 0;
+    nDrawVal = (int32_t)(nVal - nValMin) * nAngRange / nValRange;
+    nDrawEnd = nAngRange;
+  }
+  
+  #if defined(DBG_REDRAW)
+  GSLC_DEBUG2_PRINT("\n\nRingDraw: Val=%d ValLast=%d ValRange=%d PosMin=%d PosMax=%d Q=%d\n", nVal, nValLast, nValRange, nValMin, nValMax, nQuality);
+  GSLC_DEBUG2_PRINT("RingDraw:  Inc=%d ValLast=%d Val=%d Ang=%d..%d (Range=%d)\n", bInc,nValLast,nVal,nAngStart, nAngStart+nAngRange,nAngRange); //CAL!
+  GSLC_DEBUG2_PRINT("RingDraw:  DrawActive=%d DrawInactive=%d DrawStart=%d DrawVal=%d DrawEnd=%d\n",bDrawActive,bDrawInactive,nDrawStart,nDrawVal,nDrawEnd);//CAL!
+  #endif
+
+  // Adjust for start of angular range
+  nDrawStart += nAngStart;
+  nDrawVal += nAngStart;
+  nDrawEnd += nAngStart;
+
+  if (bDrawActive) {
+    if (bGradient) {
+      #if defined(DBG_REDRAW)
+      GSLC_DEBUG2_PRINT("RingDraw:   ActiveG  start=%d end=%d astart=%d arange=%d\n", nDrawStart, nDrawVal,nAngStart,nAngRange);
+      #endif
+      gslc_DrawFillGradSector(pGui, nQuality, nMidX, nMidY,
+        nRad1, nRad2, colRingActive1, colRingActive2, nDrawStart, nDrawVal, nAngStart, nAngRange);
+    } else {
+      #if defined(DBG_REDRAW)
+      GSLC_DEBUG2_PRINT("RingDraw:   Active   start=%d end=%d\n", nDrawStart, nDrawVal);
+      #endif
+      gslc_DrawFillSector(pGui, nQuality, nMidX, nMidY,
+        nRad1, nRad2, colRingActive1, nDrawStart, nDrawVal);
+    }
+  }
+
+  if (bDrawInactive) {
+    #if defined(DBG_REDRAW)
+    GSLC_DEBUG2_PRINT("RingDraw:   Inactive start=%d end=%d\n", nDrawEnd, nDrawVal);
+    #endif
+    // Since we are erasing, we will reverse the redraw direction (swap Val & End)
+    gslc_DrawFillSector(pGui, nQuality, nMidX, nMidY,
+      nRad1, nRad2, colRingInactive, nDrawEnd, nDrawVal);
+  }
+
+  // --------------------------------------------------------------------------
+  // Text overlays
+  // --------------------------------------------------------------------------
+
+  // Draw text string if defined
+  if (pElem->pStrBuf) {
+    gslc_tsColor  colTxt    = (bGlowNow)? pElem->colElemTextGlow : pElem->colElemText;
+    int8_t        nMarginX  = pElem->nTxtMarginX;
+    int8_t        nMarginY  = pElem->nTxtMarginY;
+
+    // Erase old string content using "background" color
+    if (strlen(pXRingGauge->acStrLast) != 0) {
+      gslc_DrawTxtBase(pGui, pXRingGauge->acStrLast, pElem->rElem, pElem->pTxtFont, pElem->eTxtFlags,
+        pElem->eTxtAlign, colBg, GSLC_COL_BLACK, nMarginX, nMarginY);
+    }
+
+    // Draw new string content
+    gslc_DrawTxtBase(pGui, pElem->pStrBuf, pElem->rElem, pElem->pTxtFont, pElem->eTxtFlags,
+      pElem->eTxtAlign, colTxt, GSLC_COL_BLACK, nMarginX, nMarginY);
+
+    // Save a copy of the new string content so we can support future erase
+    strncpy(pXRingGauge->acStrLast, pElem->pStrBuf, XRING_STR_MAX);
+    pXRingGauge->acStrLast[XRING_STR_MAX - 1] = 0; // Force null terminator
+
+  } // pStrBuf
+
+  // Save the position to enable future incremental calculations
+  pXRingGauge->nValLast = pXRingGauge->nVal;
+
+
+  // --------------------------------------------------------------------------
+
+  // Mark the element as no longer requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+
+}
+
+
+void gslc_ElemXRingGaugeSetVal(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nVal)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  int16_t           nValOld;
+
+  // Clip position
+  if (nVal < pXRingGauge->nValMin) { nVal = pXRingGauge->nValMin; }
+  if (nVal > pXRingGauge->nValMax) { nVal = pXRingGauge->nValMax; }
+
+  // Update
+  nValOld = pXRingGauge->nVal;
+  pXRingGauge->nVal = nVal;
+
+  // Only update if changed
+  if (nVal != nValOld) {
+    // Mark for redraw
+    // - Only need incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+void gslc_ElemXRingGaugeSetValRange(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nValMin, int16_t nValMax)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->nValMin = nValMin;
+  pXRingGauge->nValMax = nValMax;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRingGaugeSetAngleRange(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nStart, int16_t nRange, bool bClockwise)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->nAngStart = nStart;
+  pXRingGauge->nAngRange = nRange;
+
+  nRange = (nRange == 0) ? 1 : nRange; // Guard against div/0
+
+  // TODO: Support bClockwise
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRingGaugeSetThickness(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nThickness)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->nThickness = nThickness;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRingGaugeSetColorActiveFlat(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colActive)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->bGradient = false;
+  pXRingGauge->colRing1 = colActive;
+  pXRingGauge->colRing2 = colActive;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+void gslc_ElemXRingGaugeSetColorActiveGradient(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colStart, gslc_tsColor colEnd)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->bGradient = true;
+  pXRingGauge->colRing1 = colStart;
+  pXRingGauge->colRing2 = colEnd;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+void gslc_ElemXRingGaugeSetColorInactive(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colInactive)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  pXRingGauge->colRingRemain = colInactive;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+
+void gslc_ElemXRingGaugeSetQuality(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nSegments)
+{
+  gslc_tsXRingGauge* pXRingGauge = (gslc_tsXRingGauge*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_RING, __LINE__);
+  if (!pXRingGauge) return;
+
+  nSegments = (nSegments == 0) ? 72 : nSegments; // Guard against div/0 with default
+  pXRingGauge->nQuality = nSegments;
+
+  // Mark for full redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+
+// ============================================================================
diff --git a/src/guislice/XRingGauge.h b/src/guislice/XRingGauge.h
new file mode 100644
index 0000000..e55b6a4
--- /dev/null
+++ b/src/guislice/XRingGauge.h
@@ -0,0 +1,268 @@
+#ifndef _GUISLICE_EX_XRING_H_
+#define _GUISLICE_EX_XRING_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: XRingGauge
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XRingGauge.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: XRingGauge
+// - Creates display element similar to a donut-chart.
+// - The element has an outer and inner radius to create a ring appearance.
+// - The ring has an angular range defined by SetAngleRange, which means that
+//   the ring can be configured to cover a full circle or just a portion of
+//   a circle.
+// - SetAngleRange defines the starting angle and direction of fill.
+// - When drawing the ring within the angular range, it is composed of
+//   an active region (the angular region from the start to the current
+//   position value) and an inactive region (from the current value to the
+//   end of the angular range). The inactive region can be hidden (by
+//   setting it to the background color).
+// - A text value can be drawn in the center of the ring, typically to
+//   show the current value. The color defined by SetColorBackground() is
+//   used when redrawing the text.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_RING GSLC_TYPE_BASE_EXTEND + 23
+
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+#define XRING_STR_MAX 10
+
+/// Extended data for XRingGauge element
+typedef struct {
+  // Config
+  int16_t           nValMin;
+  int16_t           nValMax;
+
+  int16_t           nAngStart;
+  int16_t           nAngRange;
+
+  // Style config
+  int16_t           nQuality;
+  int8_t            nThickness;
+  bool              bGradient;
+  uint8_t           nSegGap;
+  gslc_tsColor      colRing1;
+  gslc_tsColor      colRing2;
+  gslc_tsColor      colRingRemain;
+
+  // State
+  int16_t           nVal;           ///< Current position value
+  int16_t           nValLast;       ///< Previous position value
+  char              acStrLast[XRING_STR_MAX];
+
+  // Callbacks
+
+} gslc_tsXRingGauge;
+
+
+///
+/// Create an XRingGauge element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       The square box that bounds the ring element. If a rectangular region is
+///                          provided, then the ring control will be centered in the long axis.
+/// \param[in]  pStrBuf:     String buffer to use for gauge inner text
+/// \param[in]  nStrBufMax:  Maximum length of string buffer (pStrBuf)
+/// \param[in]  nFontId:     Font ID to use for text display
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXRingGaugeCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXRingGauge* pXData, gslc_tsRect rElem, char* pStrBuf, uint8_t nStrBufMax, int16_t nFontId);
+
+///
+/// Draw the template element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXRingGaugeDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Set an Ring Gauge current indicator value
+///
+/// Updates the current value of the ring gauge. The active region will be drawn up
+/// to the position defined by nVal within the value range defined by SetValRange(nMin,nMax).
+/// A SetVal() close to nMin will cause a very small active region to be drawn and a large
+/// remainder drawn in the inactive color, whereas a SetVal() close to nMax will cause a
+/// more complete active region to be drawn.When SetVal() equals nMax, the entire angular
+/// range will be drawn in the active color (and no inactive region).
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nVal:        New position value
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetVal(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nVal);
+
+///
+/// Defines the angular range of the gauge, including both the active
+/// and inactive regions.
+///
+/// - nStart defines the angle at the beginning of the active region.
+/// - The current position marks the end of the active region and the
+///   beginning of the inactive region.
+/// - nRange defines the angular range from the start of the active
+///   region to the end of the inactive region. In most cases, a
+///   range of 360 degrees is used.
+/// - All angles are measured in units of degrees.
+/// - Angles are measured with 0 at the top, 90 towards the right,
+///   180 towards the bottom, 270 towards the left, etc.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nStart:      Define angle of start of active region (measured in degrees)
+/// \param[in]  nRange:      Define angular range from strt of active region
+///                          to end of the inactive region (measured in degrees)
+/// \param[in]  bClockwise:  Defines the direction in which the active
+///                          region grows (true for clockwise) [FORCED TRUE, FOR FUTURE IMPLEMENTATION]
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetAngleRange(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nStart, int16_t nRange, bool bClockwise);
+
+
+/// Defines the range of values that may be passed into SetVal(), used to
+/// scale the input to SetVal().
+/// - Default is 0..100.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nValMin:     Minimum value
+/// \param[in]  nValMax:     Maximum value
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetValRange(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int16_t nValMin, int16_t nValMax);
+
+
+/// Defines the thickness of the ring arcs. More specifically, it defines the reduction
+/// in radius from the outer radius to the inner radius in pixels.
+/// - Default thickness is 10 pixels
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nThickness:  Thickness of ring
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetThickness(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, int8_t nThickness);
+
+/// Sets the quality of the ring drawing by defining the number of segments that are used when
+/// rendering a 360 degree gauge.The larger the number, the more segments are used and the smoother the curve.
+/// A larger ring gauge may need a higher quality number to maintain a smoothed curve appearance.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nSegments:   Number of arc segments to render a complete circle. The
+///                          higher the value, the smoother the ring.
+///                          Note that 360/nSegments 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. 
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetQuality(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, uint16_t nSegments);
+
+/// Defines the color of the inactive region to be a flat (constant) color.
+/// The inactive color is often set to be the same as the background but it can
+/// be set to a different color to indicate the remainder of the value range that is yet to be filled.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colInactive: Color of inactive region
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetColorInactive(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colInactive);
+
+/// Defines the color of the active region to be a flat (constant) color.
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colActive:   Color of active region
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetColorActiveFlat(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colActive);
+
+/// Defines the color of the active region to be a gradient using two color stops. The
+/// active region will be filled according to the proportion between nMin and nMax.
+/// The gradient is defined by a linear RGB blend between the two color stops(colStart and colEnd)
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  colStart:    Starting color of gradient fill
+/// \param[in]  colEnd:      Ending color of gradient fill
+///
+/// \return none
+///
+void gslc_ElemXRingGaugeSetColorActiveGradient(gslc_tsGui* pGui, gslc_tsElemRef* pElemRef, gslc_tsColor colStart, gslc_tsColor colEnd);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XRING_H_
+
diff --git a/src/guislice/XSeekbar.c b/src/guislice/XSeekbar.c
new file mode 100644
index 0000000..0ecffe6
--- /dev/null
+++ b/src/guislice/XSeekbar.c
@@ -0,0 +1,530 @@
+// =======================================================================
+// GUIslice library extension: Seekbar control
+// - Paul Conti
+// - Seekbar is a modern Slider Control with Android like style
+// - Based on Calvin Hass's Slider control
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XSeekbar.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XSeekbar.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Seekbar
+// - A linear slider control
+// ============================================================================
+
+// Create a slider element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXSeekbarCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSeekbar* pXData,gslc_tsRect rElem,int16_t nPosMin,int16_t nPosMax,int16_t nPos,
+  uint8_t nProgressW,uint8_t nRemainW,uint8_t nThumbSz,
+  gslc_tsColor colProgress,gslc_tsColor colRemain,gslc_tsColor colThumb,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_SEEKBAR,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Range check on nPos
+  if (nPos < nPosMin) { nPos = nPosMin; }
+  if (nPos > nPosMax) { nPos = nPosMax; }
+
+  pXData->bVert           = bVert;
+  pXData->nPosMin         = nPosMin;
+  pXData->nPosMax         = nPosMax;
+  pXData->nPos            = nPos;
+  pXData->nProgressW      = nProgressW;
+  pXData->nRemainW        = nRemainW;
+  pXData->nThumbSz        = nThumbSz;
+  pXData->colProgress     = colProgress;
+  pXData->colRemain       = colRemain;
+  pXData->colThumb        = colThumb;
+  pXData->bTrimThumb      = false;
+  pXData->colTrim         = GSLC_COL_BLACK;
+  pXData->bFrameThumb     = false;
+  pXData->colFrame        = GSLC_COL_BLACK;
+  pXData->nTickDiv        = 0;
+  pXData->nTickLen        = 0;
+  pXData->colTick         = GSLC_COL_BLACK;
+  pXData->pfuncXPos       = NULL;
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXSeekbarDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXSeekbarTouch;
+
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+void gslc_ElemXSeekbarSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        bool bTrimThumb,gslc_tsColor colTrim,bool bFrameThumb,gslc_tsColor colFrame,uint16_t nTickDiv,
+        int16_t nTickLen,gslc_tsColor colTick)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarSetStyle";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSeekbar* pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+
+  pSeekbar->bTrimThumb  = bTrimThumb;
+  pSeekbar->colTrim     = colTrim;
+  pSeekbar->bFrameThumb = bFrameThumb;
+  pSeekbar->colFrame    = colFrame;
+  pSeekbar->nTickDiv    = nTickDiv;
+  pSeekbar->nTickLen    = nTickLen;
+  pSeekbar->colTick     = colTick;
+
+  // Update
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+int gslc_ElemXSeekbarGetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarGetPos";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSeekbar* pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+
+  return pSeekbar->nPos;
+}
+
+// Update the slider control's current state
+void gslc_ElemXSeekbarSetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nPos)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarSetPos";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSeekbar*   pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+  int16_t           nPosOld;
+  // Clip position
+  if (nPos < pSeekbar->nPosMin) { nPos = pSeekbar->nPosMin; }
+  if (nPos > pSeekbar->nPosMax) { nPos = pSeekbar->nPosMax; }
+  // Update
+  nPosOld = pSeekbar->nPos;
+  pSeekbar->nPos = nPos;
+
+  // Only update if changed
+  if (nPos != nPosOld) {
+    // If any position callback is defined, call it now
+    if (pSeekbar->pfuncXPos != NULL) {
+      (*pSeekbar->pfuncXPos)((void*)(pGui),(void*)(pElemRef),nPos);
+    }
+
+    // Mark for redraw
+    // - Only need incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+
+// Assign the position callback function for a slider
+void gslc_ElemXSeekbarSetPosFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XSEEKBAR_POS funcCb)
+{
+  if ((pElemRef == NULL) || (funcCb == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarSetPosFunc";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSeekbar*   pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+  pSeekbar->pfuncXPos = funcCb;
+}
+
+
+// Redraw the slider
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXSeekbarDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXSeekbar* pSeekbar;
+  pSeekbar = (gslc_tsXSeekbar*)(pElem->pXData);
+  if (pSeekbar == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSeekbarDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  bool            bGlow       = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  int16_t         nPos        = pSeekbar->nPos;
+  int16_t         nPosMin     = pSeekbar->nPosMin;
+  int16_t         nPosMax     = pSeekbar->nPosMax;
+  uint8_t         nProgressW  = pSeekbar->nProgressW;
+  uint8_t         nRemainW    = pSeekbar->nRemainW;
+  uint8_t         nThumbSz    = pSeekbar->nThumbSz;
+  bool            bVert       = pSeekbar->bVert;
+  bool            bTrimThumb  = pSeekbar->bTrimThumb;
+  bool            bFrameThumb = pSeekbar->bFrameThumb;
+  uint16_t        nTickDiv    = pSeekbar->nTickDiv;
+  int16_t         nTickLen    = pSeekbar->nTickLen;
+  gslc_tsColor    colProgress = pSeekbar->colProgress;
+  gslc_tsColor    colRemain   = pSeekbar->colRemain;
+  gslc_tsColor    colThumb    = pSeekbar->colThumb;
+  gslc_tsColor    colFrame    = pSeekbar->colFrame;
+  gslc_tsColor    colTrim     = pSeekbar->colTrim;
+  gslc_tsColor    colTick     = pSeekbar->colTick;
+
+  // Range check on nPos
+  if (nPos < nPosMin) { nPos = nPosMin; }
+  if (nPos > nPosMax) { nPos = nPosMax; }
+
+  int16_t nX0,nY0,nX1,nY1,nXMid,nYMid;
+  nX0 = pElem->rElem.x;
+  nY0 = pElem->rElem.y;
+  nX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nXMid = (nX0+nX1)/2;
+  nYMid = (nY0+nY1)/2;
+
+  // Scale the current position
+  int16_t nPosRng = nPosMax-nPosMin;
+  // TODO: Check for nPosRng=0, reversed min/max
+  int16_t nPosOffset = nPos-nPosMin;
+
+  // Provide some margin so thumb doesn't exceed control bounds
+  int16_t nMargin   = nThumbSz;
+  int16_t nCtrlRng;
+  if (!bVert) {
+    nCtrlRng = (nX1-nMargin)-(nX0+nMargin);
+  } else {
+    nCtrlRng = (nY1-nMargin)-(nY0+nMargin);
+  }
+  int16_t nCtrlPos  = (nPosOffset*nCtrlRng/nPosRng)+nMargin;
+
+  int16_t       nCtrlX0,nCtrlY0;
+  gslc_tsRect   rThumb;
+  if (!bVert) {
+    nCtrlX0   = nX0+nCtrlPos-nThumbSz;
+    nCtrlY0   = nYMid-nThumbSz;
+  } else {
+    nCtrlX0   = nXMid-nThumbSz;
+    nCtrlY0   = nY0+nCtrlPos-nThumbSz;
+  }
+  rThumb.x  = nCtrlX0;
+  rThumb.y  = nCtrlY0;
+  rThumb.w  = 2*nThumbSz;
+  rThumb.h  = 2*nThumbSz;
+
+
+  // Draw the thumb control
+  // work out size of thumb circle
+  int16_t  nLeftX   = rThumb.x+nThumbSz;
+  int16_t  nLeftY   = rThumb.y + nThumbSz;
+  
+  // Draw the background
+  // - TODO: To reduce flicker on unbuffered displays, one could consider
+  //         redrawing only the thumb (last drawn position) with fill and
+  //         then redraw other portions. This would prevent the
+  //         track / ticks from flickering needlessly. A full redraw would
+  //         be required if it was first draw action.
+  gslc_DrawFillRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+  
+  // Draw the progress part of track
+  if (!bVert) {
+    gslc_tsRect rTrack = {
+      nX0+nMargin,
+      nYMid-(nProgressW/2),
+      nCtrlPos,
+      nProgressW
+    };
+    gslc_DrawFillRect(pGui,rTrack,colProgress);
+  } else {
+    gslc_tsRect rTrack = {
+      nXMid-(nProgressW/2),
+      nY0+nMargin,
+      nProgressW,
+      nCtrlPos
+    };
+    gslc_DrawFillRect(pGui,rTrack,colProgress);
+  }
+
+  // test for thumb trim color
+  if (bTrimThumb) {
+    // two color thumb
+    gslc_DrawFillCircle(pGui,nLeftX,nLeftY,nThumbSz,colTrim);
+    gslc_DrawFillCircle(pGui,nLeftX,nLeftY,3,colThumb);
+  } else {
+    // one solid color thumb
+    gslc_DrawFillCircle(pGui,nLeftX,nLeftY,nThumbSz,colProgress);
+  }
+  if (bFrameThumb) {
+    gslc_DrawFrameCircle(pGui,nLeftX,nLeftY,nThumbSz,colFrame);
+  }
+  
+  // Draw the remaining part of track
+  if (!bVert) {
+    if (nRemainW == 1) {
+      gslc_DrawLine(pGui,nX0+nMargin,nYMid,nX1-nMargin,nYMid,colRemain);
+    } else {
+      gslc_tsRect rRemain = {
+        nX0+nMargin+nCtrlPos,
+        nYMid-(nRemainW/2),
+        nX1 - (nX0 + nCtrlPos+ nMargin*2) +1,
+        nRemainW
+      };
+      gslc_DrawFillRect(pGui,rRemain,colRemain);
+    }
+  } else {
+    if (nRemainW == 1) {
+      gslc_DrawLine(pGui,nXMid,nY0+nMargin,nXMid,nY1-nMargin,colRemain);
+    } else {
+     gslc_tsRect rRemain = {
+        nXMid-(nRemainW/2),
+        nY0+nMargin+nCtrlPos,
+        nRemainW,
+        (nY1-nMargin)-(nY0+nMargin+nCtrlPos)
+      };
+      gslc_DrawFillRect(pGui,rRemain,colRemain);
+    }
+  }
+
+  // Draw any ticks - we need to do this last or the ticks get over written
+  // - Need at least one tick segment
+  if (nTickDiv>=1) {
+    uint16_t  nTickInd;
+    int16_t   nTickOffset;
+    for (nTickInd=0;nTickInd<=nTickDiv;nTickInd++) {
+      nTickOffset = nTickInd * nCtrlRng / nTickDiv;
+      if (!bVert) {
+        gslc_DrawLine(pGui,nX0+nMargin+nTickOffset,nYMid-(nTickLen/2),
+                nX0+nTickOffset+nMargin,nYMid+(nTickLen/2),colTick);
+      } else {
+        gslc_DrawLine(pGui,nXMid+(nTickLen/2),nY0+nTickOffset+nMargin,nXMid-(nTickLen/2),
+                nY0+nTickOffset+nMargin,colTick);
+      }
+    }
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+bool gslc_ElemXSeekbarTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSeekbarTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+  gslc_tsElem*          pElem = NULL;
+  gslc_tsXSeekbar*       pSeekbar = NULL;
+
+  // Typecast the parameters to match the GUI
+  pGui      = (gslc_tsGui*)(pvGui);
+  pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  pSeekbar   = (gslc_tsXSeekbar*)(pElem->pXData);
+
+  bool    bGlowingOld = gslc_ElemGetGlow(pGui,pElemRef);
+  int16_t nPosRng;
+  int16_t nPos = 0;
+  bool    bUpdatePos = false;
+  bool    bIndexed = false;
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_DOWN_IN:
+      // Start glowing as must be over it
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+
+    case GSLC_TOUCH_MOVE_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+    case GSLC_TOUCH_MOVE_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      bUpdatePos = true;
+      break;
+
+    case GSLC_TOUCH_UP_IN:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+    case GSLC_TOUCH_UP_OUT:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_SET_REL:
+    case GSLC_TOUCH_SET_ABS:
+      bIndexed = true;
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+
+    default:
+      return false;
+      break;
+  }
+
+
+  // If we need to update the slider position, calculate the value
+  // and perform the update
+  if (bUpdatePos) {
+
+    if (bIndexed) {
+      // The position is changed by direct control (eg. keyboard)
+      // instead of touch coordinates
+
+      // FIXME: Change the following to be either absolute or relative
+      // value assignment instead of inc/dec. Then the user code can
+      // define what the magnitude and direction should be.
+
+      if (eTouch == GSLC_TOUCH_SET_REL) {
+        // Overload the "nRelY" parameter
+        nPos = pSeekbar->nPos;
+        nPos += nRelY;
+        nPos = (nPos > pSeekbar->nPosMax)? pSeekbar->nPosMax : nPos;
+        nPos = (nPos < pSeekbar->nPosMin)? pSeekbar->nPosMin : nPos;
+      } else if (eTouch == GSLC_TOUCH_SET_ABS) {
+        // Overload the "nRelY" parameter
+        nPos = nRelY;
+        nPos = (nPos > pSeekbar->nPosMax)? pSeekbar->nPosMax : nPos;
+        nPos = (nPos < pSeekbar->nPosMin)? pSeekbar->nPosMin : nPos;
+      }
+    } else {
+      // Perform additional range checking
+      nRelX = (nRelX < 0)? 0 : nRelX;
+      nRelY = (nRelY < 0)? 0 : nRelY;
+
+      // Calc new position
+      nPosRng = pSeekbar->nPosMax - pSeekbar->nPosMin;
+      if (!pSeekbar->bVert) {
+        nPos = (nRelX * nPosRng / pElem->rElem.w) + pSeekbar->nPosMin;
+      } else {
+        nPos = (nRelY * nPosRng / pElem->rElem.h) + pSeekbar->nPosMin;
+      }
+    }
+    // Update the slider
+    gslc_ElemXSeekbarSetPos(pGui,pElemRef,nPos);
+  }
+
+  // If the slider changed state, redraw
+  if (gslc_ElemGetGlow(pGui,pElemRef) != bGlowingOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+// ============================================================================
diff --git a/src/guislice/XSeekbar.h b/src/guislice/XSeekbar.h
new file mode 100644
index 0000000..15a13c7
--- /dev/null
+++ b/src/guislice/XSeekbar.h
@@ -0,0 +1,336 @@
+#ifndef _GUISLICE_EX_XSEEKBAR_H_
+#define _GUISLICE_EX_XSEEKBAR_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Seekbar control
+// - Paul Conti
+// - Seekbar is a modern Slider Control with Android like style
+// - Based on Calvin Hass's Slider control
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XSeekbar.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Seekbar
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_SEEKBAR GSLC_TYPE_BASE_EXTEND + 6
+
+/// Callback function for slider feedback
+typedef bool (*GSLC_CB_XSEEKBAR_POS)(void* pvGui,void* pvElem,int16_t nPos);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Seekbar element
+typedef struct {
+  // Config
+  bool            bVert;          ///< Orientation: true if vertical, else horizontal
+  uint8_t         nProgressW;     ///< Width of progress track
+  uint8_t         nRemainW;       ///< Width of remaining track
+  uint8_t         nThumbSz;       ///< Size of the thumb control
+  int16_t         nPosMin;        ///< Minimum position value of the slider
+  int16_t         nPosMax;        ///< Maximum position value of the slider
+  // Style config
+  gslc_tsColor    colProgress;    ///< Style: color of progress fill bar
+  gslc_tsColor    colRemain;      ///< Style: color remaining fill bar
+  gslc_tsColor    colThumb;       ///< Style: color of thumb
+  uint16_t        nTickDiv;       ///< Style: number of tickmark divisions (0 for none)
+  int16_t         nTickLen;       ///< Style: length of tickmarks
+  gslc_tsColor    colTick;        ///< Style: color of ticks
+  bool            bTrimThumb;     ///< Style: show a trim color for thumb
+  gslc_tsColor    colTrim;        ///< Style: color of trim
+  bool            bFrameThumb;    ///< Style: draw frame around thumb
+  gslc_tsColor    colFrame;       ///< Style: color of trim
+  // State 
+  int16_t         nPos;           ///< Current position value of the slider
+  // Callbacks
+  GSLC_CB_XSEEKBAR_POS pfuncXPos; ///< Callback func ptr for position update
+} gslc_tsXSeekbar;
+
+
+///
+/// Create a Seekbar Element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining checkbox size
+/// \param[in]  nPosMin:     Minimum position value
+/// \param[in]  nPosMax:     Maximum position value
+/// \param[in]  nPos:        Starting position value
+/// \param[in]  nProgressW:  Width of progress track
+/// \param[in]  nRemainW:    Width of  remaining track
+/// \param[in]  nThumbSz:    Size of the thumb control
+/// \param[in]  colProgress: Color of progress fill bar
+/// \param[in]  colRemain:   Color remaining fill bar
+/// \param[in]  colThumb:    Color for the thumb indicator
+/// \param[in]  bVert:       Orientation (true for vertical)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXSeekbarCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSeekbar* pXData,gslc_tsRect rElem,int16_t nPosMin,int16_t nPosMax,int16_t nPos,
+  uint8_t nProgressW,uint8_t nRemainW,uint8_t nThumbSz,
+  gslc_tsColor colProgress,gslc_tsColor colRemain,gslc_tsColor colThumb,bool bVert);
+
+
+///
+/// Set a Seekbar element's style, this includes thumb customizations and tick marks
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bTrimThumb:  Show a colored trim for thumb?
+/// \param[in]  colTrim:     Color of thumb trim
+/// \param[in]  bFrameThumb: Show a frame around thumb?
+/// \param[in]  colFrame:    Color of thumb frame
+/// \param[in]  nTickDiv:    Number of tick divisions to show (0 for none)
+/// \param[in]  nTickLen:    Length of tick marks
+/// \param[in]  colTick:     Color of ticks
+///
+/// \return none
+///
+void gslc_ElemXSeekbarSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        bool bTrimThumb,gslc_tsColor colTrim,bool bFrameThumb,gslc_tsColor colFrame,uint16_t nTickDiv,
+        int16_t nTickLen,gslc_tsColor colTick);
+
+///
+/// Get a Seekbar element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current slider position
+///
+int gslc_ElemXSeekbarGetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Set a Seekbar element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nPos:        New position value
+///
+/// \return none
+///
+void gslc_ElemXSeekbarSetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nPos);
+
+///
+/// Assign the position callback function for a slider
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to position routine (or NULL for none)
+///
+/// \return none
+///
+void gslc_ElemXSeekbarSetPosFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XSEEKBAR_POS funcCb);
+
+///
+/// Draw a Seekbar element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSeekbarDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Seekbar element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (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
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSeekbarTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+
+/// \def gslc_ElemXSeekbarCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nPosMin_,nPosMax_,nPos_,nThumbSz_,bVert_,colFrame_,colFill_)
+///
+/// Create a Seekbar Element in Flash
+///
+/// \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]  nPosMin_:     Minimum position value
+/// \param[in]  nPosMax_:     Maximum position value
+/// \param[in]  nPos_:        Starting position value
+/// \param[in]  nProgressW_:  Width of progress track
+/// \param[in]  nRemainW_:    Width of  remaining track
+/// \param[in]  nThumbSz_:    Size of the thumb control
+/// \param[in]  colProgress_: Color of progress fill bar
+/// \param[in]  colRemain_:   Color remaining fill bar
+/// \param[in]  colThumb_:    Color for the thumb indicator
+/// \param[in]  bVert_:       Orientation (true for vertical)
+/// \param[in]  colFrame_:    Color of the element frame
+/// \param[in]  colFill_:     Color of the element fill
+///
+/// \return none
+///
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXSeekbarCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,nPosMin_,nPosMax_, \
+    nPos_,nProgressW_,nRemainW_,nThumbSz_,colProgress_,colRemain_,colThumb_,bVert_, \
+    colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXSeekbar sSeekbar##nElemId;                         \
+  sSeekbar##nElemId.bVert = bVert_;                                \
+  sSeekbar##nElemId.nProgressW = nProgressW_;                      \
+  sSeekbar##nElemId.nRemainW = nRemainW_;                          \
+  sSeekbar##nElemId.nThumbSz = nThumbSz_;                          \
+  sSeekbar##nElemId.nPosMin = nPosMin_;                            \
+  sSeekbar##nElemId.nPosMax = nPosMax_;                            \
+  sSeekbar##nElemId.colProgress = colProgress_;                    \
+  sSeekbar##nElemId.colRemain = colRemain_;                        \
+  sSeekbar##nElemId.colThumb = colThumb_;                          \
+  sSeekbar##nElemId.nPos = nPos_;                                  \
+  sSeekbar##nElemId.pfuncXPos = NULL;                              \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_SEEKBAR,                                          \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sSeekbar##nElemId),                                 \
+      NULL,                                                       \
+      &gslc_ElemXSeekbarDraw,                                      \
+      &gslc_ElemXSeekbarTouch,                                     \
+      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_ElemXSeekbarCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,nPosMin_,nPosMax_, \
+    nPos_,nProgressW_,nRemainW_,nThumbSz_,colProgress_,colRemain_,colThumb_,bVert_, \
+    colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXSeekbar sSeekbar##nElemId;                         \
+  sSeekbar##nElemId.bVert = bVert_;                                \
+  sSeekbar##nElemId.nProgressW = nProgressW_;                      \
+  sSeekbar##nElemId.nRemainW = nRemainW_;                          \
+  sSeekbar##nElemId.nThumbSz = nThumbSz_;                          \
+  sSeekbar##nElemId.nPosMin = nPosMin_;                            \
+  sSeekbar##nElemId.nPosMax = nPosMax_;                            \
+  sSeekbar##nElemId.colProgress = colProgress_;                    \
+  sSeekbar##nElemId.colRemain = colRemain_;                        \
+  sSeekbar##nElemId.colThumb = colThumb_;                          \
+  sSeekbar##nElemId.nPos = nPos_;                                  \
+  sSeekbar##nElemId.pfuncXPos = NULL;                              \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_SEEKBAR,                                          \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sSeekbar##nElemId),                                 \
+      NULL,                                                       \
+      &gslc_ElemXSeekbarDraw,                                      \
+      &gslc_ElemXSeekbarTouch,                                     \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XSEEKBAR_H_
diff --git a/src/guislice/XSelNum.c b/src/guislice/XSelNum.c
new file mode 100644
index 0000000..11c5ee8
--- /dev/null
+++ b/src/guislice/XSelNum.c
@@ -0,0 +1,384 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XSelNum.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XSelNum.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: SelNum
+// - SelNum (Select Number) element demonstrates a simple up/down counter
+// - This is a compound element containing two buttons and
+//   a text area to represent the current count
+// ============================================================================
+
+// Private sub Element ID definitions
+static const int16_t  SELNUM_ID_BTN_INC = 100;
+static const int16_t  SELNUM_ID_BTN_DEC = 101;
+static const int16_t  SELNUM_ID_TXT     = 102;
+
+// Create a compound element
+// - For now just two buttons and a text area
+gslc_tsElemRef* gslc_ElemXSelNumCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSelNum* pXData,gslc_tsRect rElem,int8_t nFontId)
+{
+
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSelNumCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem sElem;
+
+
+  // Initialize composite element
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_SELNUM,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;  // Don't need to glow outer element
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  pXData->nCounter      = 0;
+
+  // Determine the maximum number of elements that we can store
+  // in the sub-element array. We do this at run-time with sizeof()
+  // instead of using #define to avoid polluting the global namespace.
+  int16_t nSubElemMax = sizeof(pXData->asElem) / sizeof(pXData->asElem[0]);
+
+  // NOTE: The count parameters in CollectReset() must match the size of
+  //       the asElem[] array. It is used for bounds checking when we
+  //       add new elements.
+  // NOTE: We only use RAM for subelement storage
+  gslc_CollectReset(&pXData->sCollect,pXData->asElem,nSubElemMax,pXData->asElemRef,nSubElemMax);
+
+
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXSelNumDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXSelNumTouch;
+
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+
+
+  // Now create the sub elements
+  // - Ensure page is set to GSLC_PAGE_NONE so that
+  //   we create the element struct but not add it to a specific page.
+  // - When we create an element with GSLC_PAGE_NONE it is
+  //   saved in the GUI's temporary element storage.
+  // - When we have finished creating / styling the element, we then
+  //   copy it into the permanent sub-element storage
+
+  // - The element IDs assigned to the sub-elements are
+  //   arbitrary (with local scope in the compound element),
+  //   so they don't need to be unique globally across the GUI.
+  gslc_tsElemRef* pElemRefTmp   = NULL;
+  gslc_tsElem*    pElemTmp      = NULL;
+  gslc_tsElemRef* pElemRef      = NULL;
+
+  // Determine offset coordinate of compound element so that we can
+  // specify relative positioning during the sub-element Create() operations.
+  int16_t nOffsetX = rElem.x;
+  int16_t nOffsetY = rElem.y;
+
+  gslc_tsRect rSubElem;
+
+  rSubElem = (gslc_tsRect) { nOffsetX+40,nOffsetY+10,30,30 };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  #if (GSLC_LOCAL_STR)
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui,SELNUM_ID_BTN_INC,GSLC_PAGE_NONE,
+    rSubElem,"+",0,nFontId,&gslc_ElemXSelNumClick);
+  #else
+  strncpy(pXData->acElemTxt[0],"+",SELNUM_STR_LEN-1);
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui,SELNUM_ID_BTN_INC,GSLC_PAGE_NONE,
+    rSubElem,pXData->acElemTxt[0],SELNUM_STR_LEN,
+    nFontId,&gslc_ElemXSelNumClick);
+  #endif
+  gslc_ElemSetCol(pGui,pElemRefTmp,(gslc_tsColor){0,0,192},(gslc_tsColor){0,0,128},(gslc_tsColor){0,0,224});
+  gslc_ElemSetTxtCol(pGui,pElemRefTmp,GSLC_COL_WHITE);
+  pElemTmp = gslc_GetElemFromRef(pGui,pElemRefTmp);
+  gslc_CollectElemAdd(pGui,&pXData->sCollect,pElemTmp,GSLC_ELEMREF_DEFAULT);
+
+  rSubElem = (gslc_tsRect) { nOffsetX+80,nOffsetY+10,30,30 };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  #if (GSLC_LOCAL_STR)
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui,SELNUM_ID_BTN_DEC,GSLC_PAGE_NONE,
+    rSubElem,"-",0,nFontId,&gslc_ElemXSelNumClick);
+  #else
+  strncpy(pXData->acElemTxt[1],"-",SELNUM_STR_LEN-1);
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui,SELNUM_ID_BTN_DEC,GSLC_PAGE_NONE,
+    rSubElem,pXData->acElemTxt[1],SELNUM_STR_LEN,
+    nFontId,&gslc_ElemXSelNumClick);
+  #endif
+  gslc_ElemSetCol(pGui,pElemRefTmp,(gslc_tsColor){0,0,192},(gslc_tsColor){0,0,128},(gslc_tsColor){0,0,224});
+  gslc_ElemSetTxtCol(pGui,pElemRefTmp,GSLC_COL_WHITE);
+  pElemTmp = gslc_GetElemFromRef(pGui,pElemRefTmp);
+  gslc_CollectElemAdd(pGui,&pXData->sCollect,pElemTmp,GSLC_ELEMREF_DEFAULT);
+
+  rSubElem = (gslc_tsRect) { nOffsetX+10,nOffsetY+10,20,30 };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  #if (GSLC_LOCAL_STR)
+  pElemRefTmp = gslc_ElemCreateTxt(pGui,SELNUM_ID_TXT,GSLC_PAGE_NONE,
+    rSubElem,"0",0,nFontId);
+  #else
+  strncpy(pXData->acElemTxt[2],"0",SELNUM_STR_LEN-1);
+  pElemRefTmp = gslc_ElemCreateTxt(pGui,SELNUM_ID_TXT,GSLC_PAGE_NONE,
+    rSubElem,pXData->acElemTxt[2],SELNUM_STR_LEN,nFontId);
+  #endif
+  pElemTmp = gslc_GetElemFromRef(pGui,pElemRefTmp);
+  gslc_CollectElemAdd(pGui,&pXData->sCollect,pElemTmp,GSLC_ELEMREF_DEFAULT);
+
+
+  // Now proceed to add the compound element to the page
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+
+    // Now propagate the parent relationship to enable a cascade
+    // of redrawing from low-level elements to the top
+    gslc_CollectSetParent(pGui,&pXData->sCollect,pElemRef);
+
+    return pElemRef;
+  } else {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSelNumCreate(%s) Compound elements inside compound elements not supported\n","");
+    return NULL;
+
+    // TODO: For now, disable compound elements within
+    // compound elements. If we want to enable this, we
+    // would probably use the temporary element reference
+    // the GUI.
+    // Save as temporary element for further processing
+    //pGui->sElemTmp = sElem;   // Need fixing
+    //return &(pGui->sElemTmp); // Need fixing
+  }
+
+}
+
+
+// Redraw the compound element
+// - When drawing a compound element, we clear the background
+//   and then redraw the sub-element collection.
+bool gslc_ElemXSelNumDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSelNum* pSelNum = (gslc_tsXSelNum*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SELNUM, __LINE__);
+  if (!pSelNum) return false;
+
+  bool bGlow = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+
+  // Draw the compound element fill (background)
+  // - Should only need to do this in full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFillRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+  }
+
+  // Draw the sub-elements
+  // - For now, force redraw of entire compound element
+  gslc_tsCollect* pCollect = &pSelNum->sCollect;
+
+  gslc_tsEvent  sEvent = gslc_EventCreate(pGui,GSLC_EVT_DRAW,GSLC_EVTSUB_DRAW_FORCE,(void*)(pCollect),NULL);
+  gslc_CollectEvent(pGui,sEvent);
+
+  // Optionally, draw a frame around the compound element
+  // - This could instead be done by creating a sub-element
+  //   of type box.
+  // - We don't need to show any glowing of the compound element
+
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFrameRect(pGui, pElem->rElem, (bGlow) ? pElem->colElemFrameGlow : pElem->colElemFrame);
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// Fetch the current value of the element's counter
+int gslc_ElemXSelNumGetCounter(gslc_tsGui* pGui,gslc_tsXSelNum* pSelNum)
+{
+  if ((pGui == NULL) || (pSelNum == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSelNumGetCounter";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  return pSelNum->nCounter;
+}
+
+
+void gslc_ElemXSelNumSetCounter(gslc_tsGui* pGui,gslc_tsXSelNum* pSelNum,int16_t nCount)
+{
+  if (pSelNum == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSelNumSetCounter";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pSelNum->nCounter = nCount;
+
+  // Determine new counter text
+  // FIXME: Consider replacing the printf() with an optimized function to
+  //        conserve RAM. Potentially leverage GSLC_DEBUG2_PRINT().
+  char  acStrNew[GSLC_LOCAL_STR_LEN];
+  snprintf(acStrNew,GSLC_LOCAL_STR_LEN,"%hd",pSelNum->nCounter);
+
+  // Update the element
+  gslc_tsElemRef* pElemRef = gslc_CollectFindElemById(pGui,&pSelNum->sCollect,SELNUM_ID_TXT);
+  gslc_ElemSetTxtStr(pGui,pElemRef,acStrNew);
+
+}
+
+
+// Handle the compound element main functionality
+// - This routine is called by gslc_ElemEvent() to handle
+//   any click events that resulted from the touch tracking process.
+// - The code here will generally represent the core
+//   functionality of the compound element and any communication
+//   between sub-elements.
+// - pvElemRef is a void pointer to the element ref being tracked. From
+//   the pElemRefParent member we can get the parent/compound element
+//   data structures.
+bool gslc_ElemXSelNumClick(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  // Fetch the parent of the clicked element which is the compound
+  // element itself. This enables us to access the extra control data.
+  gslc_tsElemRef*    pElemRefParent = pElem->pElemRefParent;
+  if (pElemRefParent == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSelNumClick(%s) parent ElemRef ptr NULL\n","");
+    return false;
+  }
+
+  gslc_tsElem*    pElemParent = gslc_GetElemFromRef(pGui,pElemRefParent);
+  gslc_tsXSelNum* pSelNum     = (gslc_tsXSelNum*)(pElemParent->pXData);
+  if (pSelNum == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSelNumClick() element (ID=%d) has NULL pXData\n",pElem->nId);
+    return false;
+  }
+
+  // Begin the core compound element functionality
+  int nCounter  = pSelNum->nCounter;
+
+  // Handle the various button presses
+  if (eTouch == GSLC_TOUCH_UP_IN) {
+
+    // Get the tracked element ID
+    gslc_tsElemRef* pElemRefTracked = pSelNum->sCollect.pElemRefTracked;
+    gslc_tsElem*    pElemTracked    = gslc_GetElemFromRef(pGui,pElemRefTracked);
+    int nSubElemId = pElemTracked->nId;
+
+    if (nSubElemId == SELNUM_ID_BTN_INC) {
+      // Increment button
+      if (nCounter < 100) {
+        nCounter++;
+      }
+      gslc_ElemXSelNumSetCounter(pGui,pSelNum,nCounter);
+
+    } else if (nSubElemId == SELNUM_ID_BTN_DEC) {
+      // Decrement button
+      if (nCounter > 0) {
+        nCounter--;
+      }
+      gslc_ElemXSelNumSetCounter(pGui,pSelNum,nCounter);
+
+    }
+  } // eTouch
+
+  return true;
+#endif // !DRV_TOUCH_NONE
+}
+
+bool gslc_ElemXSelNumTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsXSelNum* pSelNum = (gslc_tsXSelNum*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SELNUM, __LINE__);
+  if (!pSelNum) return false;
+
+  // Get Collection
+  gslc_tsCollect* pCollect = &pSelNum->sCollect;
+  return gslc_CollectTouchCompound(pvGui, pvElemRef, eTouch, nRelX, nRelY, pCollect);
+
+  #endif // !DRV_TOUCH_NONE
+}
+#endif // GSLC_FEATURE_COMPOUND
+
+
+// ============================================================================
diff --git a/src/guislice/XSelNum.h b/src/guislice/XSelNum.h
new file mode 100644
index 0000000..c3377fa
--- /dev/null
+++ b/src/guislice/XSelNum.h
@@ -0,0 +1,177 @@
+#ifndef _GUISLICE_EX_XSELNUM_H_
+#define _GUISLICE_EX_XSELNUM_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Select Number (SelNum) control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XSelNum.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: SelNum (Number Selector)
+// - Demonstration of a compound element consisting of
+//   a counter text field along with an increment and
+//   decrement button.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_SELNUM GSLC_TYPE_BASE_EXTEND + 3
+
+#define SELNUM_STR_LEN  6
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+/// Extended data for SelNum element
+typedef struct {
+
+  // Core functionality for SelNum
+  int16_t             nCounter;       ///< Counter for demo purposes
+
+  // Internal sub-element members
+  gslc_tsCollect      sCollect;       ///< Collection management for sub-elements
+  gslc_tsElemRef      asElemRef[4];   ///< Storage for sub-element references
+  gslc_tsElem         asElem[4];      ///< Storage for sub-elements
+
+  #if (GSLC_LOCAL_STR == 0)
+  // If elements don't provide their own internal string buffer, then
+  // we need to provide storage here in the extended data of the compound
+  // element. For now, simply provide a fixed-length memory buffer.
+  char                acElemTxt[4][SELNUM_STR_LEN]; ///< Storage for strings
+  #endif
+} gslc_tsXSelNum;
+
+
+
+
+///
+/// Create a SelNum Element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining element size
+/// \param[in]  nFontId:     Font ID to use for drawing the element
+///
+/// \return Pointer to Element or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXSelNumCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSelNum* pXData,gslc_tsRect rElem,int8_t nFontId);
+
+
+///
+/// Draw a SelNum element on the screen
+/// - Called during redraw
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSelNumDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+
+///
+/// Get the current counter associated with SelNum
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pSelNum:     Ptr to Element
+///
+/// \return Current counter value
+///
+int gslc_ElemXSelNumGetCounter(gslc_tsGui* pGui,gslc_tsXSelNum* pSelNum);
+
+
+///
+/// Set the current counter associated with SelNum
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pSelNum:     Ptr to Element
+/// \param[in]  nCount:      New counter value
+///
+/// \return none
+///
+void gslc_ElemXSelNumSetCounter(gslc_tsGui* pGui,gslc_tsXSelNum* pSelNum,int16_t nCount);
+
+
+///
+/// Handle a click event within the SelNum
+/// - This is called internally by the SelNum touch handler
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nX:          Touch X coord
+/// \param[in]  nY:          Touch Y coord
+///
+/// \return none
+///
+bool gslc_ElemXSelNumClick(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);
+
+///
+/// Handle touch (up,down,move) events to SelNum element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (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
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSelNumTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+#endif // GLSC_COMPOUND
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XSELNUM_H_
+
diff --git a/src/guislice/XSlider.c b/src/guislice/XSlider.c
new file mode 100644
index 0000000..a083aa5
--- /dev/null
+++ b/src/guislice/XSlider.c
@@ -0,0 +1,478 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XSlider.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XSlider.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Slider
+// - A linear slider control
+// ============================================================================
+
+// Create a slider element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXSliderCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSlider* pXData,gslc_tsRect rElem,int16_t nPosMin,int16_t nPosMax,int16_t nPos,
+  uint16_t nThumbSz,bool bVert)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_SLIDER,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Range check on nPos
+  if (nPos < nPosMin) { nPos = nPosMin; }
+  if (nPos > nPosMax) { nPos = nPosMax; }
+
+  pXData->nPosMin         = nPosMin;
+  pXData->nPosMax         = nPosMax;
+  pXData->nPos            = nPos;
+  pXData->nThumbSz        = nThumbSz;
+  pXData->bVert           = bVert;
+  pXData->bTrim           = false;
+  pXData->colTrim         = GSLC_COL_BLACK;
+  pXData->nTickDiv        = 0;
+  pXData->pfuncXPos       = NULL;
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXSliderDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXSliderTouch;
+
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+void gslc_ElemXSliderSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        bool bTrim,gslc_tsColor colTrim,uint16_t nTickDiv,
+        int16_t nTickLen,gslc_tsColor colTick)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderSetStyle";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSlider* pSlider = (gslc_tsXSlider*)(pElem->pXData);
+
+  pSlider->bTrim      = bTrim;
+  pSlider->colTrim    = colTrim;
+  pSlider->nTickDiv   = nTickDiv;
+  pSlider->nTickLen   = nTickLen;
+  pSlider->colTick    = colTick;
+
+  // Update
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+}
+
+int gslc_ElemXSliderGetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderGetPos";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  gslc_tsElem*    pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSlider* pSlider = (gslc_tsXSlider*)(pElem->pXData);
+
+  return pSlider->nPos;
+}
+
+// Update the slider control's current state
+void gslc_ElemXSliderSetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nPos)
+{
+  if ((pGui == NULL) || (pElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderSetPos";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSlider*   pSlider = (gslc_tsXSlider*)(pElem->pXData);
+  int16_t           nPosOld;
+  // Clip position
+  if (nPos < pSlider->nPosMin) { nPos = pSlider->nPosMin; }
+  else if (nPos > pSlider->nPosMax) { nPos = pSlider->nPosMax; }
+  // Update
+  nPosOld = pSlider->nPos;
+  pSlider->nPos = nPos;
+
+  // Only update if changed
+  if (nPos != nPosOld) {
+    // If any position callback is defined, call it now
+    if (pSlider->pfuncXPos != NULL) {
+      (*pSlider->pfuncXPos)((void*)(pGui),(void*)(pElemRef),nPos);
+    }
+
+    // Mark for redraw
+    // - Only need incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+
+// Assign the position callback function for a slider
+void gslc_ElemXSliderSetPosFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XSLIDER_POS funcCb)
+{
+  if ((pElemRef == NULL) || (funcCb == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderSetPosFunc";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSlider*   pSlider = (gslc_tsXSlider*)(pElem->pXData);
+  pSlider->pfuncXPos = funcCb;
+}
+
+
+// Redraw the slider
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXSliderDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXSlider* pSlider;
+  pSlider = (gslc_tsXSlider*)(pElem->pXData);
+  if (pSlider == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSliderDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  bool            bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  int16_t         nPos      = pSlider->nPos;
+  int16_t         nPosMin   = pSlider->nPosMin;
+  int16_t         nPosMax   = pSlider->nPosMax;
+  bool            bVert     = pSlider->bVert;
+  int16_t         nThumbSz  = pSlider->nThumbSz;
+  bool            bTrim     = pSlider->bTrim;
+  gslc_tsColor    colTrim   = pSlider->colTrim;
+  uint16_t        nTickDiv  = pSlider->nTickDiv;
+  int16_t         nTickLen  = pSlider->nTickLen;
+  gslc_tsColor    colTick   = pSlider->colTick;
+
+  // Range check on nPos
+  if (nPos < nPosMin) { nPos = nPosMin; }
+  else if (nPos > nPosMax) { nPos = nPosMax; }
+
+  int16_t nX0,nY0,nX1,nY1,nXMid,nYMid;
+  nX0 = pElem->rElem.x;
+  nY0 = pElem->rElem.y;
+  nX1 = pElem->rElem.x + pElem->rElem.w - 1;
+  nY1 = pElem->rElem.y + pElem->rElem.h - 1;
+  nXMid = (nX0+nX1)/2;
+  nYMid = (nY0+nY1)/2;
+
+  // Scale the current position
+  int16_t nPosRng = nPosMax-nPosMin;
+  // TODO: Check for nPosRng=0, reversed min/max
+  int16_t nPosOffset = nPos-nPosMin;
+
+  // Provide some margin so thumb doesn't exceed control bounds
+  // TODO: Handle nCtrlRng <= 0
+  int16_t nMargin   = nThumbSz;
+  int16_t nCtrlRng;
+  if (!bVert) {
+    nCtrlRng = (nX1-nMargin)-(nX0+nMargin);
+  } else {
+    nCtrlRng = (nY1-nMargin)-(nY0+nMargin);
+  }
+
+  int16_t nCtrlPos  = (int16_t)((int32_t)nPosOffset * (int32_t)nCtrlRng / (int32_t)nPosRng) + nMargin;
+
+  // Draw the background
+  // - TODO: To reduce flicker on unbuffered displays, one could consider
+  //         redrawing only the thumb (last drawn position) with fill and
+  //         then redraw other portions. This would prevent the
+  //         track / ticks from flickering needlessly. A full redraw would
+  //         be required if it was first draw action.
+  gslc_DrawFillRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+
+  // Draw any ticks
+  // - Need at least one tick segment
+  if (nTickDiv>=1) {
+    uint16_t  nTickInd;
+    int16_t   nTickOffset;
+    for (nTickInd=0;nTickInd<=nTickDiv;++nTickInd) {
+      nTickOffset = (int16_t)((int32_t)nTickInd * (int32_t)nCtrlRng / (int32_t)nTickDiv);
+      if (!bVert) {
+        gslc_DrawLine(pGui,nX0+nMargin+ nTickOffset,nYMid,
+                nX0+nMargin + nTickOffset,nYMid+nTickLen,colTick);
+      } else {
+        gslc_DrawLine(pGui,nXMid,nY0+nMargin+ nTickOffset,
+                nXMid+nTickLen,nY0+nMargin + nTickOffset,colTick);
+      }
+    }
+  }
+
+
+  // Draw the track
+  if (!bVert) {
+    // Make the track highlight during glow
+    gslc_DrawLine(pGui,nX0+nMargin,nYMid,nX1-nMargin,nYMid,
+            bGlow? pElem->colElemFrameGlow : pElem->colElemFrame);
+    // Optionally draw a trim line
+    if (bTrim) {
+      gslc_DrawLine(pGui,nX0+nMargin,nYMid+1,nX1-nMargin,nYMid+1,colTrim);
+    }
+
+  } else {
+    // Make the track highlight during glow
+    gslc_DrawLine(pGui,nXMid,nY0+nMargin,nXMid,nY1-nMargin,
+            bGlow? pElem->colElemFrameGlow : pElem->colElemFrame);
+    // Optionally draw a trim line
+    if (bTrim) {
+      gslc_DrawLine(pGui,nXMid+1,nY0+nMargin,nXMid+1,nY1-nMargin,colTrim);
+    }
+  }
+
+
+  int16_t       nCtrlX0,nCtrlY0;
+  gslc_tsRect   rThumb;
+  if (!bVert) {
+    nCtrlX0   = nX0+nCtrlPos-nThumbSz;
+    nCtrlY0   = nYMid-nThumbSz;
+  } else {
+    nCtrlX0   = nXMid-nThumbSz;
+    nCtrlY0   = nY0+nCtrlPos-nThumbSz;
+  }
+  rThumb.x  = nCtrlX0;
+  rThumb.y  = nCtrlY0;
+  rThumb.w  = 2*nThumbSz;
+  rThumb.h  = 2*nThumbSz;
+
+  // Draw the thumb control
+  gslc_DrawFillRect(pGui,rThumb,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+  gslc_DrawFrameRect(pGui,rThumb,(bGlow)?pElem->colElemFrameGlow:pElem->colElemFrame);
+  if (bTrim) {
+    gslc_tsRect  rThumbTrim;
+    rThumbTrim = gslc_ExpandRect(rThumb,-1,-1);
+    gslc_DrawFrameRect(pGui,rThumbTrim,pSlider->colTrim);
+  }
+
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+bool gslc_ElemXSliderTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSliderTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+  gslc_tsElem*          pElem = NULL;
+  gslc_tsXSlider*       pSlider = NULL;
+
+  // Typecast the parameters to match the GUI
+  pGui      = (gslc_tsGui*)(pvGui);
+  pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  pSlider   = (gslc_tsXSlider*)(pElem->pXData);
+
+  bool    bGlowingOld = gslc_ElemGetGlow(pGui,pElemRef);
+  int16_t nPosRng;
+  int16_t nPos = 0;
+  bool    bUpdatePos = false;
+  bool    bIndexed = false;
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_DOWN_IN:
+      // Start glowing as must be over it
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+
+    case GSLC_TOUCH_MOVE_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+    case GSLC_TOUCH_MOVE_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      bUpdatePos = true;
+      break;
+
+    case GSLC_TOUCH_UP_IN:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+    case GSLC_TOUCH_UP_OUT:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_SET_REL:
+    case GSLC_TOUCH_SET_ABS:
+      bIndexed = true;
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      bUpdatePos = true;
+      break;
+
+    default:
+      return false;
+      break;
+  }
+
+
+  // If we need to update the slider position, calculate the value
+  // and perform the update
+  if (bUpdatePos) {
+
+    if (bIndexed) {
+      // The position is changed by direct control (eg. keyboard)
+      // instead of touch coordinates
+
+      // FIXME: Change the following to be either absolute or relative
+      // value assignment instead of inc/dec. Then the user code can
+      // define what the magnitude and direction should be.
+
+      if (eTouch == GSLC_TOUCH_SET_REL) {
+        // Overload the "nRelY" parameter
+        nPos = pSlider->nPos;
+        nPos += nRelY;
+        nPos = (nPos > pSlider->nPosMax)? pSlider->nPosMax : nPos;
+        nPos = (nPos < pSlider->nPosMin)? pSlider->nPosMin : nPos;
+      } else if (eTouch == GSLC_TOUCH_SET_ABS) {
+        // Overload the "nRelY" parameter
+        nPos = nRelY;
+        nPos = (nPos > pSlider->nPosMax)? pSlider->nPosMax : nPos;
+        nPos = (nPos < pSlider->nPosMin)? pSlider->nPosMin : nPos;
+      }
+    } else {
+      // Perform additional range checking
+      nRelX = (nRelX < 0)? 0 : nRelX;
+      nRelY = (nRelY < 0)? 0 : nRelY;
+
+      // Calc new position
+      nPosRng = pSlider->nPosMax - pSlider->nPosMin;
+      if (!pSlider->bVert) {
+        nPos = (int16_t)((int32_t)nRelX * (int32_t)nPosRng / (int32_t)pElem->rElem.w) + pSlider->nPosMin;
+      } else {
+        nPos = (int16_t)((int32_t)nRelY * (int32_t)nPosRng / (int32_t)pElem->rElem.h) + pSlider->nPosMin;
+      }
+    }
+    // Update the slider
+    gslc_ElemXSliderSetPos(pGui,pElemRef,nPos);
+  }
+
+  // If the slider changed state, redraw
+  if (gslc_ElemGetGlow(pGui,pElemRef) != bGlowingOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+// ============================================================================
diff --git a/src/guislice/XSlider.h b/src/guislice/XSlider.h
new file mode 100644
index 0000000..c8555bc
--- /dev/null
+++ b/src/guislice/XSlider.h
@@ -0,0 +1,315 @@
+#ifndef _GUISLICE_EX_XSLIDER_H_
+#define _GUISLICE_EX_XSLIDER_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Slider control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XSlider.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Slider
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_SLIDER GSLC_TYPE_BASE_EXTEND + 2
+
+/// Callback function for slider feedback
+typedef bool (*GSLC_CB_XSLIDER_POS)(void* pvGui,void* pvElem,int16_t nPos);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Slider element
+typedef struct {
+  // Config
+  bool            bVert;          ///< Orientation: true if vertical, else horizontal
+  int16_t         nThumbSz;       ///< Size of the thumb control
+  int16_t         nPosMin;        ///< Minimum position value of the slider
+  int16_t         nPosMax;        ///< Maximum position value of the slider
+  // Style config
+  uint16_t        nTickDiv;       ///< Style: number of tickmark divisions (0 for none)
+  int16_t         nTickLen;       ///< Style: length of tickmarks
+  gslc_tsColor    colTick;        ///< Style: color of ticks
+  bool            bTrim;          ///< Style: show a trim color
+  gslc_tsColor    colTrim;        ///< Style: color of trim
+  // State
+  int16_t         nPos;           ///< Current position value of the slider
+  // Callbacks
+  GSLC_CB_XSLIDER_POS pfuncXPos;  ///< Callback func ptr for position update
+} gslc_tsXSlider;
+
+
+///
+/// Create a Slider Element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining checkbox size
+/// \param[in]  nPosMin:     Minimum position value
+/// \param[in]  nPosMax:     Maximum position value
+/// \param[in]  nPos:        Starting position value
+/// \param[in]  nThumbSz:    Size of the thumb control
+/// \param[in]  bVert:       Orientation (true for vertical)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXSliderCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXSlider* pXData,gslc_tsRect rElem,int16_t nPosMin,int16_t nPosMax,int16_t nPos,
+  uint16_t nThumbSz,bool bVert);
+
+
+///
+/// Set a Slider element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bTrim:       Show a colored trim?
+/// \param[in]  colTrim:     Color of trim
+/// \param[in]  nTickDiv:    Number of tick divisions to show (0 for none)
+/// \param[in]  nTickLen:    Length of tickmarks
+/// \param[in]  colTick:     Color of ticks
+///
+/// \return none
+///
+void gslc_ElemXSliderSetStyle(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,
+        bool bTrim,gslc_tsColor colTrim,uint16_t nTickDiv,
+        int16_t nTickLen,gslc_tsColor colTick);
+
+
+///
+/// Get a Slider element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current slider position
+///
+int gslc_ElemXSliderGetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Set a Slider element's current position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nPos:        New position value
+///
+/// \return none
+///
+void gslc_ElemXSliderSetPos(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,int16_t nPos);
+
+///
+/// Assign the position callback function for a slider
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  funcCb:      Function pointer to position routine (or NULL for none)
+///
+/// \return none
+///
+void gslc_ElemXSliderSetPosFunc(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,GSLC_CB_XSLIDER_POS funcCb);
+
+///
+/// Draw a Slider element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSliderDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Slider element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (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
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSliderTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+
+/// \def gslc_ElemXSliderCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,
+///      nPosMin_,nPosMax_,nPos_,nThumbSz_,bVert_,colFrame_,colFill_)
+///
+/// Create a Slider Element in Flash
+///
+/// \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]  nPosMin_:    Minimum position value
+/// \param[in]  nPosMax_:    Maximum position value
+/// \param[in]  nPos_:       Starting position value
+/// \param[in]  nThumbSz_:   Size of the thumb control
+/// \param[in]  bVert_:      Orientation (true for vertical)
+/// \param[in]  colFrame_:   Color of the element frame
+/// \param[in]  colFill_:    Color of the element fill
+///
+/// \return none
+///
+
+
+#if (GSLC_USE_PROGMEM)
+
+
+#define gslc_ElemXSliderCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH, \
+    nPosMin_,nPosMax_,nPos_,nThumbSz_,bVert_,colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXSlider sSlider##nElemId;                         \
+  sSlider##nElemId.bVert = bVert_;                                \
+  sSlider##nElemId.nThumbSz = nThumbSz_;                          \
+  sSlider##nElemId.nPosMin = nPosMin_;                            \
+  sSlider##nElemId.nPosMax = nPosMax_;                            \
+  sSlider##nElemId.nTickDiv = 0;                                  \
+  sSlider##nElemId.nTickLen = 0;                                  \
+  sSlider##nElemId.colTick = GSLC_COL_WHITE;                      \
+  sSlider##nElemId.bTrim = false;                                 \
+  sSlider##nElemId.colTrim = GSLC_COL_BLACK;                      \
+  sSlider##nElemId.nPos = nPos_;                                  \
+  sSlider##nElemId.pfuncXPos = NULL;                              \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_SLIDER,                                          \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sSlider##nElemId),                                 \
+      NULL,                                                       \
+      &gslc_ElemXSliderDraw,                                      \
+      &gslc_ElemXSliderTouch,                                     \
+      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_ElemXSliderCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH, \
+    nPosMin_,nPosMax_,nPos_,nThumbSz_,bVert_,colFrame_,colFill_) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXSlider sSlider##nElemId;                         \
+  sSlider##nElemId.bVert = bVert_;                                \
+  sSlider##nElemId.nThumbSz = nThumbSz_;                          \
+  sSlider##nElemId.nPosMin = nPosMin_;                            \
+  sSlider##nElemId.nPosMax = nPosMax_;                            \
+  sSlider##nElemId.nTickDiv = 0;                                  \
+  sSlider##nElemId.nTickLen = 0;                                  \
+  sSlider##nElemId.colTick = GSLC_COL_WHITE;                      \
+  sSlider##nElemId.bTrim = false;                                 \
+  sSlider##nElemId.colTrim = GSLC_COL_BLACK;                      \
+  sSlider##nElemId.nPos = nPos_;                                  \
+  sSlider##nElemId.pfuncXPos = NULL;                              \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_SLIDER,                                          \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      GSLC_GROUP_ID_NONE,                                         \
+      colFrame_,colFill_,colFrame_,colFill_,                      \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sSlider##nElemId),                                 \
+      NULL,                                                       \
+      &gslc_ElemXSliderDraw,                                      \
+      &gslc_ElemXSliderTouch,                                     \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_CONST | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XSLIDER_H_
+
diff --git a/src/guislice/XSpinner.c b/src/guislice/XSpinner.c
new file mode 100644
index 0000000..01c05af
--- /dev/null
+++ b/src/guislice/XSpinner.c
@@ -0,0 +1,425 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XSpinner.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XSpinner.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: Spinner
+// - Spinner element demonstrates a simple up/down counter
+// - This is a compound element containing two buttons and
+//   a text area to represent the current value
+// ============================================================================
+
+// Private sub Element ID definitions
+static const int16_t  SPINNER_ID_BTN_INC = 100;
+static const int16_t  SPINNER_ID_BTN_DEC = 101;
+static const int16_t  SPINNER_ID_TXT     = 102;
+
+// Create a compound element
+// - For now just two buttons and a text area
+gslc_tsElemRef* gslc_ElemXSpinnerCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage, gslc_tsXSpinner* pXData,
+  gslc_tsRect rElem, int16_t nMin, int16_t nMax, int16_t nVal, int16_t nIncr,
+  int8_t nFontId, int8_t nButtonSz, GSLC_CB_INPUT cbInput)
+{
+
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSpinnerCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL, FUNCSTR);
+    return NULL;
+  }
+
+  // determine size of our text box
+  // first calculate number of digits required
+  int16_t nTxtBoxW,nTxtBoxH,nBtnPosY;
+  char acTxtNum[XSPINNER_STR_LEN];
+  // FIXME: Consider replacing the sprintf() with an optimized function to
+  //        conserve RAM. Potentially leverage GSLC_DEBUG2_PRINT().
+  nTxtBoxW = rElem.w - 2 * (nButtonSz);
+  // Determine the maximum width of a digit, we will use button size for height.
+  // now we can work out our rectangle  
+  nTxtBoxH = rElem.h;
+
+  nBtnPosY = rElem.y + (rElem.h - nButtonSz) / 2;
+
+  // set our intial value for our text field
+  snprintf(acTxtNum, XSPINNER_STR_LEN - 1, "%d", nVal);
+
+  gslc_tsElem sElem;
+
+  // Initialize composite element
+  sElem = gslc_ElemCreate(pGui, nElemId, nPage, GSLC_TYPEX_SPINNER, rElem, NULL, 0, GSLC_FONT_NONE);
+  sElem.nFeatures |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures &= ~GSLC_ELEM_FEA_GLOW_EN;  // Don't need to glow outer element
+  sElem.nGroup = GSLC_GROUP_ID_NONE;
+
+  pXData->nCounter = nVal;
+  pXData->nMin = nMin;
+  pXData->nMax = nMax;
+  pXData->nIncr = nIncr;
+  pXData->pfuncXInput = cbInput;
+  
+
+  // Initialize the collection of sub-elements within the compound element
+  // - XSELNUM_COMP_CNT defines the maximum number of sub-elements we have allocated space for
+  // - Note that this example shows RAM being used for storage
+  gslc_CollectReset(&pXData->sCollect, pXData->asElem, XSPINNER_COMP_CNT, pXData->asElemRef, XSPINNER_COMP_CNT);
+
+
+  sElem.pXData = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw = &gslc_ElemXSpinnerDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch = &gslc_ElemXSpinnerTouch;
+
+  sElem.colElemFill = GSLC_COL_BLACK;
+  sElem.colElemFillGlow = GSLC_COL_BLACK;
+  sElem.colElemFrame = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow = GSLC_COL_WHITE;
+
+
+  // Now create the sub elements
+  // - Ensure page is set to GSLC_PAGE_NONE so that
+  //   we create the element struct but not add it to a specific page.
+  // - When we create an element with GSLC_PAGE_NONE it is
+  //   saved in the GUI's temporary element storage.
+  // - When we have finished creating / styling the element, we then
+  //   copy it into the permanent sub-element storage
+
+  // - The element IDs assigned to the sub-elements are
+  //   arbitrary (with local scope in the compound element),
+  //   so they don't need to be unique globally across the GUI.
+  gslc_tsElemRef* pElemRefTmp = NULL;
+  gslc_tsElem*    pElemTmp = NULL;
+  gslc_tsElemRef* pElemRef = NULL;
+
+  // Determine offset coordinate of compound element so that we can
+  // specify relative positioning during the sub-element Create() operations.
+  int16_t nOffsetX = rElem.x;
+  int16_t nOffsetY = rElem.y;
+
+  gslc_tsRect rSubElem;
+  
+  // Create button sub-element
+  strcpy(pXData->acIncr,"\030");
+  rSubElem = (gslc_tsRect) { nOffsetX+nTxtBoxW, nBtnPosY, nButtonSz, nButtonSz };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui, SPINNER_ID_BTN_INC, GSLC_PAGE_NONE,
+    rSubElem, pXData->acIncr, 2, nFontId, &gslc_ElemXSpinnerClick);
+  gslc_ElemSetCol(pGui, pElemRefTmp, (gslc_tsColor) { 0, 0, 192 }, (gslc_tsColor) { 0, 0, 128 }, (gslc_tsColor) { 0, 0, 224 });
+  gslc_ElemSetTxtCol(pGui, pElemRefTmp, GSLC_COL_WHITE);
+  pElemTmp = gslc_GetElemFromRef(pGui, pElemRefTmp);
+  gslc_CollectElemAdd(pGui, &pXData->sCollect, pElemTmp, GSLC_ELEMREF_DEFAULT);
+
+  // Create button sub-element
+  strcpy(pXData->acDecr,"\031");
+  rSubElem = (gslc_tsRect) { nOffsetX+nTxtBoxW+nButtonSz, nBtnPosY, nButtonSz, nButtonSz };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  pElemRefTmp = gslc_ElemCreateBtnTxt(pGui, SPINNER_ID_BTN_DEC, GSLC_PAGE_NONE,
+    rSubElem, pXData->acDecr, 2, nFontId, &gslc_ElemXSpinnerClick);
+  gslc_ElemSetCol(pGui, pElemRefTmp, (gslc_tsColor) { 0, 0, 192 }, (gslc_tsColor) { 0, 0, 128 }, (gslc_tsColor) { 0, 0, 224 });
+  gslc_ElemSetTxtCol(pGui, pElemRefTmp, GSLC_COL_WHITE);
+  pElemTmp = gslc_GetElemFromRef(pGui, pElemRefTmp);
+  gslc_CollectElemAdd(pGui, &pXData->sCollect, pElemTmp, GSLC_ELEMREF_DEFAULT);
+
+  // Create dynamic text sub-element
+  // - Note that we are using string storage in the extended element data
+  //   structure (pXData).
+  rSubElem = (gslc_tsRect) { nOffsetX, nOffsetY, nTxtBoxW, nTxtBoxH };
+  rSubElem = gslc_ExpandRect(rSubElem, -1, -1);
+  strncpy(pXData->acElemTxt[0], acTxtNum, XSPINNER_STR_LEN - 1);
+  pElemRefTmp = gslc_ElemCreateTxt(pGui, SPINNER_ID_TXT, GSLC_PAGE_NONE,
+    rSubElem, pXData->acElemTxt[0], XSPINNER_STR_LEN, nFontId);
+  gslc_ElemSetTxtAlign(pGui, pElemRefTmp, GSLC_ALIGN_MID_MID);
+  pElemTmp = gslc_GetElemFromRef(pGui, pElemRefTmp);
+  gslc_CollectElemAdd(pGui, &pXData->sCollect, pElemTmp, GSLC_ELEMREF_DEFAULT);
+
+
+  // Now proceed to add the compound element to the page
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui, nPage, &sElem, GSLC_ELEMREF_DEFAULT);
+
+    // save our ElemRef for the callback
+    pXData->pElemRef = pElemRef;
+
+    // Now propagate the parent relationship to enable a cascade
+    // of redrawing from low-level elements to the top
+    gslc_CollectSetParent(pGui, &pXData->sCollect, pElemRef);
+
+    return pElemRef;
+  }
+  else {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSpinnerCreate(%s) Compound elements inside compound elements not supported\n", "");
+    return NULL;
+
+    // TODO: For now, disable compound elements within
+    // compound elements. If we want to enable this, we
+    // would probably use the temporary element reference
+    // the GUI.
+    // Save as temporary element for further processing
+    //pGui->sElemTmp = sElem;   // Need fixing
+    //return &(pGui->sElemTmp); // Need fixing
+
+  }
+
+}
+
+bool gslc_ElemXSpinnerSetChars(void* pvGui,gslc_tsElemRef* pElemRef,uint8_t cIncr, uint8_t cDecr)
+{
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+  gslc_tsXSpinner* pSpinner = (gslc_tsXSpinner*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SPINNER, __LINE__);
+  if (!pSpinner) return false;
+
+  char acIncr[2] = { cIncr, '\0'};
+  char acDecr[2] = { cDecr, '\0'};
+  gslc_tsElemRef* pElemRefUp = gslc_CollectFindElemById(pGui,&pSpinner->sCollect,SPINNER_ID_BTN_INC);
+  gslc_ElemSetTxtStr(pGui,pElemRefUp,acIncr);        
+  gslc_tsElemRef* pElemRefDown = gslc_CollectFindElemById(pGui,&pSpinner->sCollect,SPINNER_ID_BTN_DEC);
+  gslc_ElemSetTxtStr(pGui,pElemRefDown,acDecr);
+  
+  return true;  
+}
+
+
+// Redraw the compound element
+// - When drawing a compound element, we clear the background
+//   and then redraw the sub-element collection.
+bool gslc_ElemXSpinnerDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsXSpinner* pSpinner = (gslc_tsXSpinner*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SPINNER, __LINE__);
+  if (!pSpinner) return false;
+
+  bool bGlow = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+
+  // Draw the compound element fill (background)
+  // - Should only need to do this in full redraw
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFillRect(pGui,pElem->rElem,(bGlow)?pElem->colElemFillGlow:pElem->colElemFill);
+  }
+
+  // Draw the sub-elements
+  // - For now, force redraw of entire compound element
+  gslc_tsCollect* pCollect = &pSpinner->sCollect;
+  if (eRedraw != GSLC_REDRAW_NONE) {
+    uint8_t sEventSubType = GSLC_EVTSUB_DRAW_NEEDED;
+    if (eRedraw == GSLC_REDRAW_FULL) {
+      sEventSubType = GSLC_EVTSUB_DRAW_FORCE;
+    }
+    gslc_tsEvent  sEvent = gslc_EventCreate(pGui, GSLC_EVT_DRAW, sEventSubType, (void*)(pCollect), NULL);
+    gslc_CollectEvent(pGui, sEvent);
+  }
+
+  // Optionally, draw a frame around the compound element
+  // - This could instead be done by creating a sub-element
+  //   of type box.
+  // - We don't need to show any glowing of the compound element
+
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    gslc_DrawFrameRect(pGui, pElem->rElem, (bGlow) ? pElem->colElemFrameGlow : pElem->colElemFrame);
+  }
+
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// Fetch the current value of the element's counter
+int gslc_ElemXSpinnerGetCounter(gslc_tsGui* pGui,gslc_tsXSpinner* pSpinner)
+{
+  if ((pGui == NULL) || (pSpinner == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSpinnerGetCounter";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return 0;
+  }
+  return pSpinner->nCounter;
+}
+
+
+void gslc_ElemXSpinnerSetCounter(gslc_tsGui* pGui,gslc_tsXSpinner* pSpinner,int16_t nCount)
+{
+  if (pSpinner == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXSpinnerSetCounter";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  pSpinner->nCounter = nCount;
+
+  // Determine new counter text
+  // FIXME: Consider replacing the printf() with an optimized function to
+  //        conserve RAM. Potentially leverage GSLC_DEBUG2_PRINT().
+  char  acStrNew[GSLC_LOCAL_STR_LEN];
+  snprintf(acStrNew,GSLC_LOCAL_STR_LEN,"%hd",pSpinner->nCounter);
+
+  // Update the element
+  gslc_tsElemRef* pElemRef = gslc_CollectFindElemById(pGui,&pSpinner->sCollect,SPINNER_ID_TXT);
+  gslc_ElemSetTxtStr(pGui,pElemRef,acStrNew);
+
+}
+
+
+// Handle the compound element main functionality
+// - This routine is called by gslc_ElemEvent() to handle
+//   any click events that resulted from the touch tracking process.
+// - The code here will generally represent the core
+//   functionality of the compound element and any communication
+//   between sub-elements.
+// - pvElemRef is a void pointer to the element ref being tracked. From
+//   the pElemRefParent member we can get the parent/compound element
+//   data structures.
+bool gslc_ElemXSpinnerClick(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem* pElem = gslc_GetElemFromRefD(pGui, pElemRef, __LINE__);
+  if (!pElem) return false;
+
+  // Fetch the parent of the clicked element which is the compound
+  // element itself. This enables us to access the extra control data.
+  gslc_tsElemRef*    pElemRefParent = pElem->pElemRefParent;
+  if (pElemRefParent == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSpinnerClick(%s) parent ElemRef ptr NULL\n","");
+    return false;
+  }
+
+  gslc_tsElem*    pElemParent = gslc_GetElemFromRef(pGui,pElemRefParent);
+  gslc_tsXSpinner* pSpinner     = (gslc_tsXSpinner*)(pElemParent->pXData);
+  if (pSpinner == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXSpinnerClick() element (ID=%d) has NULL pXData\n",pElem->nId);
+    return false;
+  }
+
+  // Begin the core compound element functionality
+  int nCounter  = pSpinner->nCounter;
+
+  // Handle the various button presses
+  GSLC_CB_INPUT pfuncXInput = NULL;
+  if (eTouch == GSLC_TOUCH_UP_IN) {
+
+    // Get the tracked element ID
+    gslc_tsElemRef* pElemRefTracked = pSpinner->sCollect.pElemRefTracked;
+    gslc_tsElem*    pElemTracked    = gslc_GetElemFromRef(pGui,pElemRefTracked);
+    int nSubElemId = pElemTracked->nId;
+
+    if (nSubElemId == SPINNER_ID_BTN_INC) {
+      // Increment button
+      if (nCounter < pSpinner->nMax) {
+        nCounter += pSpinner->nIncr;
+      }
+      gslc_ElemXSpinnerSetCounter(pGui,pSpinner,nCounter);
+
+    } else if (nSubElemId == SPINNER_ID_BTN_DEC) {
+      // Decrement button
+      if (nCounter > pSpinner->nMin) {
+        nCounter -= pSpinner->nIncr;
+      }
+      gslc_ElemXSpinnerSetCounter(pGui,pSpinner,nCounter);
+
+    }
+
+    // Invoke the callback function
+    pfuncXInput = pSpinner->pfuncXInput;
+    if (pfuncXInput != NULL) {
+      (*pfuncXInput)(pvGui, (void*)(pSpinner->pElemRef), XSPINNER_CB_STATE_UPDATE, NULL);
+    }
+
+  } // eTouch
+
+  return true;
+#endif // !DRV_TOUCH_NONE
+}
+
+bool gslc_ElemXSpinnerTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+  gslc_tsGui* pGui = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsXSpinner* pSpinner = (gslc_tsXSpinner*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_SPINNER, __LINE__);
+  if (!pSpinner) return false;
+
+  // Get Collection
+  gslc_tsCollect* pCollect = &pSpinner->sCollect;
+
+  return gslc_CollectTouchCompound(pvGui, pvElemRef, eTouch, nRelX, nRelY, pCollect);
+
+  #endif // !DRV_TOUCH_NONE
+}
+#endif // GSLC_FEATURE_COMPOUND
+
+
+// ============================================================================
diff --git a/src/guislice/XSpinner.h b/src/guislice/XSpinner.h
new file mode 100644
index 0000000..d00833b
--- /dev/null
+++ b/src/guislice/XSpinner.h
@@ -0,0 +1,210 @@
+#ifndef _GUISLICE_EX_XSPINNER_H_
+#define _GUISLICE_EX_XSPINNER_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Spinner (number selection) control
+// - Extension by Paul Conti, Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XSpinner.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+#if (GSLC_FEATURE_COMPOUND)
+// ============================================================================
+// Extended Element: Spinner (Number Selector)
+// - Demonstration of a compound element consisting of
+//   a counter text field along with an increment and
+//   decrement button.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_SPINNER GSLC_TYPE_BASE_EXTEND + 15
+
+// Define the max number of sub-elements in compound element
+#define XSPINNER_COMP_CNT 3
+
+// Define the max string length to allocate for dynamic text elements
+#define XSPINNER_STR_LEN  8
+
+// Define the status for GSLC_CB_INPUT callback
+#define XSPINNER_CB_STATE_UPDATE 3
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+/// Extended data for Spinner element
+typedef struct {
+
+  // Core functionality for Spinner
+  int16_t             nMin;           ///< Minimum control value
+  int16_t             nMax;           ///< Maximum control value
+  int16_t             nIncr;          ///< Increment by value
+  int16_t             nCounter;       ///< Current value
+  GSLC_CB_INPUT       pfuncXInput;    ///< Callback func ptr for input ready
+  gslc_tsElemRef*     pElemRef;       ///< Save our ElemRef for the callback
+
+  // Internal sub-element members
+  gslc_tsCollect      sCollect;                      ///< Collection management for sub-elements
+  gslc_tsElemRef      asElemRef[XSPINNER_COMP_CNT];   ///< Storage for sub-element references
+  gslc_tsElem         asElem[XSPINNER_COMP_CNT];      ///< Storage for sub-elements
+
+  // Provide storage for any dynamic text elements
+  // Simple example here uses fixed-length character array
+  char                acElemTxt[1][XSPINNER_STR_LEN]; ///< Storage for strings
+  char                acIncr[2];       ///< Increment character string
+  char                acDecr[2];       ///< Decrement character string
+
+} gslc_tsXSpinner;
+
+
+
+
+///
+/// Create a Spinner Element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining overall size
+/// \param[in]  nMin:        Minimum value of Spinner
+/// \param[in]  nMax:        Maximum value of Spinner
+/// \param[in]  nVal:        Starting value of Spinner
+/// \param[in]  nIncr:       Increment Spinner by this value
+/// \param[in]  nFontId:     Font ID to use for drawing the element
+/// \param[in]  nButtonSz:   Size of individual buttons
+/// \param[in]  cbInput:     Callback for touch events
+///
+/// \return Pointer to Element or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXSpinnerCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage, gslc_tsXSpinner* pXData,
+  gslc_tsRect rElem, int16_t nMin, int16_t nMax, int16_t nVal, int16_t nIncr,
+  int8_t nFontId, int8_t nButtonSz, GSLC_CB_INPUT cbInput);
+
+
+///
+/// Set Up and Down characters for the Spinner element
+/// - Called during redraw
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pElemRef:    Ptr to ElementRef
+/// \param[in]  cIncr:       Character to use to indicate incrementing the spinner
+/// \param[in]  cDecr:       Character to use to indicate decrementing the spinner
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSpinnerSetChars(void* pvGui,gslc_tsElemRef* pElemRef,uint8_t cIncr, uint8_t cDecr);
+
+
+///
+/// Draw a Spinner element on the screen
+/// - Called during redraw
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSpinnerDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Get the current counter associated with Spinner
+///
+/// \param[in]  pGui:        Ptr to GUI
+/// \param[in]  pSpinner:     Ptr to Element
+///
+/// \return Current counter value
+///
+int gslc_ElemXSpinnerGetCounter(gslc_tsGui* pGui,gslc_tsXSpinner* pSpinner);
+
+
+///
+/// Set the current counter associated with Spinner
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pSpinner:     Ptr to Element
+/// \param[in]  nCount:      New counter value
+///
+/// \return none
+///
+void gslc_ElemXSpinnerSetCounter(gslc_tsGui* pGui,gslc_tsXSpinner* pSpinner,int16_t nCount);
+
+
+///
+/// Handle a click event within the Spinner
+/// - This is called internally by the Spinner touch handler
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef    Void ptr to Element ref (typecast to gslc_tsElemRef*)
+/// \param[in]  eTouch:      Touch event type
+/// \param[in]  nX:          Touch X coord
+/// \param[in]  nY:          Touch Y coord
+///
+/// \return none
+///
+bool gslc_ElemXSpinnerClick(void* pvGui,void *pvElemRef,gslc_teTouch eTouch,int16_t nX,int16_t nY);
+
+///
+/// Handle touch (up,down,move) events to Spinner element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (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
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXSpinnerTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+#endif // GLSC_COMPOUND
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XSPINNER_H_
+
diff --git a/src/guislice/XTemplate.c b/src/guislice/XTemplate.c
new file mode 100644
index 0000000..bcaf738
--- /dev/null
+++ b/src/guislice/XTemplate.c
@@ -0,0 +1,307 @@
+// =======================================================================
+// GUIslice library (extensions template)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XTemplate.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XTemplate.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+// Extended Element: Template example
+// - Demonstrates minimum code to implement an extended element
+// ============================================================================
+
+// Create a text element and add it to the GUI element list
+// - Defines default styling for the element
+// - Defines callback for redraw and touch
+gslc_tsElemRef* gslc_ElemXTemplateCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+  gslc_tsXTemplate* pXData, gslc_tsRect rElem, char* pStrBuf, uint8_t nStrBufMax, int16_t nFontId)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTemplateCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_TEMPLATE,rElem,pStrBuf,nStrBufMax,nFontId);
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_GRAY;
+  sElem.colElemText       = GSLC_COL_WHITE;
+  sElem.colElemTextGlow   = GSLC_COL_WHITE;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+  sElem.eTxtAlign         = GSLC_ALIGN_MID_LEFT;
+
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // TODO:
+  // - Initialize any pxData members with the constructor parameters
+  //   eg. pXData->nPos = nPos;
+
+  sElem.pXData            = (void*)(pXData);
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXTemplateDraw;
+  // Specify the custom touch tracking callback
+  sElem.pfuncXTouch       = &gslc_ElemXTemplateTouch;
+
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+// Redraw the element
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+bool gslc_ElemXTemplateDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTemplateDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  // Fetch the element's extended data structure
+  gslc_tsXTemplate* pTemplate = (gslc_tsXTemplate*)(pElem->pXData);
+  if (pTemplate == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXTemplateDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  // Template example drawing routine implements formatted text field
+
+  // --------------------------------------------------------------------------
+  // Init for default drawing
+  // --------------------------------------------------------------------------
+
+  bool      bGlowEn,bGlowing,bGlowNow;
+  //int16_t   nElemX,nElemY;
+  //uint16_t  nElemW,nElemH;
+
+  //nElemX    = pElem->rElem.x;
+  //nElemY    = pElem->rElem.y;
+  //nElemW    = pElem->rElem.w;
+  //nElemH    = pElem->rElem.h;
+  bGlowEn   = pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN; // Does the element support glow state?
+  bGlowing  = gslc_ElemGetGlow(pGui,pElemRef); // Element should be glowing (if enabled)
+  bGlowNow  = bGlowEn & bGlowing; // Element is currently glowing
+  gslc_tsColor colBg = GSLC_COL_BLACK;
+
+  // --------------------------------------------------------------------------
+  // Background
+  // --------------------------------------------------------------------------
+
+  // Fill in the background
+  gslc_tsRect rElemInner = pElem->rElem;
+  // - If both fill and frame are enabled then contract
+  //   the fill region slightly so that we don't overdraw
+  //   the frame (prevent unnecessary flicker).
+  if ((pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN) && (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN)) {
+    // NOTE: If the region is already too small to shrink (eg. w=1 or h=1)
+    // then a zero dimension box will be returned by ExpandRect() and not drawn
+    rElemInner = gslc_ExpandRect(rElemInner,-1,-1);
+  }
+  // - This also changes the fill color if selected and glow state is enabled
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FILL_EN) {
+    if (bGlowEn && bGlowing) {
+      colBg = pElem->colElemFillGlow;
+    } else {
+      colBg = pElem->colElemFill;
+    }
+    if (pElem->nFeatures & GSLC_ELEM_FEA_ROUND_EN) {
+      gslc_DrawFillRoundRect(pGui, rElemInner, pGui->nRoundRadius, colBg);
+    } else {
+      gslc_DrawFillRect(pGui, rElemInner, colBg);
+    }
+  } else {
+    // TODO: If unfilled, then we might need
+    // to redraw the background layer(s)
+  }
+
+  // --------------------------------------------------------------------------
+  // Frame
+  // --------------------------------------------------------------------------
+
+  // Frame the region
+  if (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN) {
+    if (pElem->nFeatures & GSLC_ELEM_FEA_ROUND_EN) {
+      gslc_DrawFrameRoundRect(pGui, pElem->rElem, pGui->nRoundRadius, pElem->colElemFrame);
+    } else {
+      gslc_DrawFrameRect(pGui, pElem->rElem, pElem->colElemFrame);
+    }
+  }
+
+  // --------------------------------------------------------------------------
+  // Text overlays
+  // --------------------------------------------------------------------------
+
+  // Draw text string if defined
+  if (pElem->pStrBuf) {
+    gslc_tsColor  colTxt    = (bGlowNow)? pElem->colElemTextGlow : pElem->colElemText;
+    int8_t        nMarginX  = pElem->nTxtMarginX;
+    int8_t        nMarginY  = pElem->nTxtMarginY;
+
+    gslc_DrawTxtBase(pGui, pElem->pStrBuf, pElem->rElem, pElem->pTxtFont, pElem->eTxtFlags,
+      pElem->eTxtAlign, colTxt, colBg, nMarginX, nMarginY);
+  }
+
+  // --------------------------------------------------------------------------
+
+  // Mark the element as no longer requiring redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  return true;
+
+}
+
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+bool gslc_ElemXTemplateTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  // Define any specific touch handling here
+
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTemplateTouch";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  gslc_tsGui*           pGui = NULL;
+  gslc_tsElemRef*       pElemRef = NULL;
+  //gslc_tsElem*          pElem = NULL;
+  //gslc_tsXTemplate*     pTemplate = NULL;
+
+  // Typecast the parameters to match the GUI
+  pGui      = (gslc_tsGui*)(pvGui);
+  pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  //pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  //pTemplate = (gslc_tsXTemplate*)(pElem->pXData);
+
+  bool    bGlowingOld = gslc_ElemGetGlow(pGui,pElemRef);
+
+  // Example touch handler simply tracks "glowing" status
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_DOWN_IN:
+      // Start glowing as must be over it
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+
+    case GSLC_TOUCH_MOVE_IN:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+    case GSLC_TOUCH_MOVE_OUT:
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_UP_IN:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+    case GSLC_TOUCH_UP_OUT:
+      // End glow
+      gslc_ElemSetGlow(pGui,pElemRef,false);
+      break;
+
+    case GSLC_TOUCH_SET_REL:
+    case GSLC_TOUCH_SET_ABS:
+      gslc_ElemSetGlow(pGui,pElemRef,true);
+      break;
+
+    default:
+      return false;
+      break;
+  }
+
+  // If the slider changed state, redraw
+  if (gslc_ElemGetGlow(pGui,pElemRef) != bGlowingOld) {
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_FULL);
+  }
+
+  return true;
+
+  #endif // !DRV_TOUCH_NONE
+}
+
+// ============================================================================
diff --git a/src/guislice/XTemplate.h b/src/guislice/XTemplate.h
new file mode 100644
index 0000000..53cac45
--- /dev/null
+++ b/src/guislice/XTemplate.h
@@ -0,0 +1,128 @@
+#ifndef _GUISLICE_EX_XTEMPLATE_H_
+#define _GUISLICE_EX_XTEMPLATE_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Example template
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XTemplate.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+// ============================================================================
+// Extended Element: Example template
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_TEMPLATE GSLC_TYPE_BASE_EXTEND + 12
+
+/// Callback function for slider feedback
+//typedef bool (*GSLC_CB_XTEMPLATE_POS)(void* pvGui,void* pvElem,int16_t nPos);
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Slider element
+typedef struct {
+  // Config
+  // Style config
+  // State
+  //int16_t         nPos;           ///< Example position value
+  // Callbacks
+  //GSLC_CB_XTEXTEX_POS pfuncXPos;  ///< Callback func ptr for position update
+} gslc_tsXTemplate;
+
+
+///
+/// Create an Extended Text Field Element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining element size
+/// \param[in]  pStrBuf:     Ptr to string buffer
+/// \param[in]  nStrBufMax:  Maximum buffer alength allocated to pStrBuf
+/// \param[in]  nFontId:     ID of font to use for text output
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXTemplateCreate(gslc_tsGui* pGui, int16_t nElemId, int16_t nPage,
+	gslc_tsXTemplate* pXData, gslc_tsRect rElem, char* pStrBuf, uint8_t nStrBufMax, int16_t nFontId);
+
+
+///
+/// Draw the template element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element (typecast to gslc_tsElemRef*)
+/// \param[in]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTemplateDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to template element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \param[in]  pvGui:       Void ptr to GUI (typecast to gslc_tsGui*)
+/// \param[in]  pvElemRef:   Void ptr to Element ref (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
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTemplateTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XTEMPLATE_H_
+
diff --git a/src/guislice/XTextbox.c b/src/guislice/XTextbox.c
new file mode 100644
index 0000000..28b4bee
--- /dev/null
+++ b/src/guislice/XTextbox.c
@@ -0,0 +1,663 @@
+// =======================================================================
+// GUIslice library (extensions)
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XTextbox.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+#include "XTextbox.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+
+// ============================================================================
+
+gslc_tsElemRef* gslc_ElemXTextboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXTextbox* pXData,gslc_tsRect rElem,int16_t nFontId,char* pBuf,
+    uint16_t nBufRows,uint16_t nBufCols)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTextboxCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_TEXTBOX,rElem,NULL,0,nFontId);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        &= ~GSLC_ELEM_FEA_GLOW_EN;
+  // Default group assignment. Can override later with ElemSetGroup()
+  sElem.nGroup            = GSLC_GROUP_ID_NONE;
+
+  // Define other extended data
+  pXData->pBuf            = pBuf;
+  pXData->nMarginX        = 5;
+  pXData->nMarginY        = 5;
+  pXData->bWrapEn         = true;
+  pXData->nCurPosX        = 0;
+  pXData->nCurPosY        = 0;
+
+  pXData->nBufRows        = nBufRows;
+  pXData->nBufCols        = nBufCols;
+  pXData->nBufPosX        = 0;
+  pXData->nBufPosY        = 0;
+  pXData->nWndRowStart    = 0;
+
+  pXData->nRedrawRow = XTEXTBOX_REDRAW_ALL;
+
+  // Clear the buffer
+  memset(pBuf,0,nBufRows*nBufCols*sizeof(char));
+
+  // Precalculate certain parameters
+  // Determine the maximum size of a character
+  // - For now, assume we are using a monospaced font and derive
+  //   text pixel coords from the size of a worst-case character.
+  int16_t       nChOffsetX, nChOffsetY, nChOffsetTmp;
+  uint16_t      nChSzW,nChSzH,nChSzTmp;
+
+  // Fetch X & Y sizing and offsets independently, based on characters that
+  // are likely to maximize the ascenders / descenders / width attributes
+  char          acMonoH[3] = "p$";
+  char          acMonoW[2] = "W";
+
+  gslc_DrvGetTxtSize(pGui, sElem.pTxtFont, (char*)&acMonoH, sElem.eTxtFlags, &nChOffsetTmp, &nChOffsetY, &nChSzTmp, &nChSzH);
+  gslc_DrvGetTxtSize(pGui, sElem.pTxtFont, (char*)&acMonoW, sElem.eTxtFlags, &nChOffsetX, &nChOffsetTmp, &nChSzW, &nChSzTmp);
+
+  pXData->nWndCols = (rElem.w - (2*pXData->nMarginX)) / nChSzW;
+  pXData->nWndRows = (rElem.h - (2*pXData->nMarginY)) / nChSzH;
+  
+  // Adjust margin to correct for character offsets
+  pXData->nMarginX -= nChOffsetX;
+  pXData->nMarginY -= nChOffsetY;
+
+  pXData->nChSizeX = nChSzW;
+  pXData->nChSizeY = nChSzH;
+
+  // Determine if scrollbar should be enabled
+  if (pXData->nWndRows >= pXData->nBufRows) {
+    // Disable scrollbar as the window is larger
+    // than the number of rows in the buffer
+    pXData->bScrollEn   = false;
+    pXData->nScrollPos  = 0;
+  } else {
+    // Scrollbar is enabled
+    pXData->bScrollEn   = true;
+    pXData->nScrollPos  = 0;
+  }
+
+  sElem.pXData            = (void*)(pXData);
+
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXTextboxDraw;
+  sElem.pfuncXTouch       = NULL;
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+
+void gslc_ElemXTextboxReset(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTextboxReset";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXTextbox*  pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  // Reset the positional state
+  pBox->nCurPosX        = 0;
+  pBox->nCurPosY        = 0;
+  pBox->nBufPosX        = 0;
+  pBox->nBufPosY        = 0;
+  pBox->nWndRowStart    = 0;
+
+  // Clear the buffer
+  memset(pBox->pBuf,0,pBox->nBufRows*pBox->nBufCols*sizeof(char));
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  pBox->nRedrawRow = XTEXTBOX_REDRAW_ALL; // All-row update
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+// Advance the buffer writer to the next line
+// The window is also shifted if we are eating the first row
+void gslc_ElemXTextboxLineWrAdv(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTextboxLineWrAdv";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  gslc_tsXTextbox*  pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  pBox->nBufPosX = 0;
+  pBox->nBufPosY++;
+
+  // Wrap the pointers around end of buffer
+  pBox->nBufPosY      = pBox->nBufPosY % pBox->nBufRows;
+
+  // Did the buffer write pointer start to encroach upon
+  // the visible window region? If so, shift the window
+  if (pBox->nBufPosY == pBox->nWndRowStart) {
+    // Advance the window (with wrap if needed)
+    pBox->nWndRowStart = (pBox->nWndRowStart + 1) % pBox->nBufRows;
+    // Ensure all rows get redrawn
+    pBox->nRedrawRow = XTEXTBOX_REDRAW_ALL;
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+}
+
+void gslc_ElemXTextboxScrollSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nScrollPos,uint8_t nScrollMax)
+{
+
+  gslc_tsXTextbox*  pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  // Ensure scrollbar is enabled
+  if (!pBox->bScrollEn) {
+    // Scrollbar is disabled, so ignore
+    return;
+  }
+
+  // Check for out-of-range values
+  if (nScrollPos > nScrollMax) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXTextboxScrollSet() pos [%u] exceeds max [%u]\n", nScrollPos,nScrollMax);
+    // Force the position to the max
+    nScrollPos = nScrollMax;
+  }
+
+  // Assign proportional value based on visible window region
+  uint16_t nScrollPosOld = pBox->nScrollPos;
+  pBox->nScrollPos = nScrollPos * (pBox->nBufRows - pBox->nWndRows) / nScrollMax;
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  // - Only redraw if changed actual scroll row
+  if (pBox->nScrollPos != nScrollPosOld) {
+    // Ensure all rows get redrawn
+    pBox->nRedrawRow = XTEXTBOX_REDRAW_ALL;
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+}
+
+// Write a character to the buffer
+// - Advance the write ptr, wrap if needed
+// - If encroach upon buffer read ptr, then drop the oldest line from the buffer
+// NOTE: This should not be called with newline char!
+void gslc_ElemXTextboxBufAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,unsigned char chNew,bool bAdvance)
+{
+  gslc_tsXTextbox*  pBox;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  // Ensure that we haven't gone past end of line
+  // - Note that we have to leave one extra byte for the line terminator (NULL)
+  if ((pBox->nBufPosX+1) >= pBox->nBufCols) {
+    if (pBox->bWrapEn) {
+      // Perform line wrap
+      // - Force a null at the end of the current line first
+      pBox->pBuf[pBox->nBufPosY * pBox->nBufCols + (pBox->nBufCols-1)] = 0;
+      gslc_ElemXTextboxLineWrAdv(pGui,pElemRef);
+    } else {
+      // Ignore the write
+      return;
+    }
+  }
+
+  uint16_t    nBufPos = pBox->nBufPosY * pBox->nBufCols + pBox->nBufPosX;
+
+  // Add the character
+  pBox->pBuf[nBufPos] = chNew;
+
+  // Only trigger redraw if we have output a printable character
+  // to the display buffer. For simplicity, just check for
+  // null for now.
+  // TODO: Consider checking isprint()
+  if (chNew == 0) {
+    // Don't update redraw on non-printing characters
+  } else {
+
+    // Mark this specific row as needing redraw
+    if (pBox->nRedrawRow == XTEXTBOX_REDRAW_NONE) {
+      // No redraw was pending, so mark single row pending
+      pBox->nRedrawRow = pBox->nBufPosY;
+    }
+    else if (pBox->nRedrawRow == XTEXTBOX_REDRAW_ALL) {
+      // All-row redraw was pending, so no change
+    }
+    else {
+      // Single row redraw was pending
+      if (pBox->nRedrawRow != pBox->nBufPosY) {
+        // But the pending row differs from the current row,
+        // so promote redraw to all lines
+        pBox->nRedrawRow = XTEXTBOX_REDRAW_ALL;
+      }
+      else {
+        // Pending row is the same, so no change
+      }
+    }
+  } // chNew
+
+  // Optionally advance the pointer
+  // - The only time we don't advance is if we added NULL
+  //   but note that in some special commands there may be
+  //   zero values added, so we still need to advance these
+  if (bAdvance) {
+    pBox->nBufPosX++;
+  }
+
+}
+
+void gslc_ElemXTextboxColSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor nCol)
+{
+#if (GSLC_FEATURE_XTEXTBOX_EMBED == 0)
+  GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXTextboxColSet() not enabled. Requires GSLC_FEATURE_XTEXTBOX_EMBED=1 %s\n","");
+  return;
+#else
+  gslc_tsXTextbox*  pBox = NULL;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+
+  // Ensure that there are enough free columns in current
+  // buffer row to accommodate the color code (4 bytes)
+  if (pBox->nBufPosX +4 >= pBox->nBufCols) {
+    // Not enough space for the code, so ignore it
+    GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXTextboxColSet() not enough cols [Pos=%u Cols=%u]\n",pBox->nBufPosX,pBox->nBufCols);
+    return;
+  }
+
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,GSLC_XTEXTBOX_CODE_COL_SET,true);
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,nCol.r,true);
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,nCol.g,true);
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,nCol.b,true);
+#endif
+}
+
+void gslc_ElemXTextboxColReset(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+#if (GSLC_FEATURE_XTEXTBOX_EMBED == 0)
+  GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXTextboxColReset() not enabled. Requires GSLC_FEATURE_XTEXTBOX_EMBED=1 %s\n","");
+  return;
+#else
+  gslc_tsXTextbox*  pBox = NULL;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+  (void)pBox; // Unused
+  gslc_ElemXTextboxBufAdd(pGui,pElemRef,GSLC_XTEXTBOX_CODE_COL_RESET,true);
+#endif
+}
+
+void gslc_ElemXTextboxWrapSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bWrapEn)
+{
+  gslc_tsXTextbox*  pBox = NULL;
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+  pBox->bWrapEn = bWrapEn;
+}
+
+
+void gslc_ElemXTextboxAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,char* pTxt)
+{
+
+  // Warn the user about mode compatibility
+#if (GSLC_FEATURE_XTEXTBOX_EMBED)
+  gslc_tsElem*      pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  //gslc_tsXTextbox* pBox = (gslc_tsXTextbox*)(pElem->pXData);
+  static bool bWarned = false;  // Warn only once
+  bool bEncUtf8 = ((pElem->eTxtFlags & GSLC_TXT_ENC) == GSLC_TXT_ENC_UTF8);
+  if ((!bWarned) && (bEncUtf8)) {
+    // Continue to render the text, but issue warning to the user
+    GSLC_DEBUG2_PRINT("WARNING: ElemXTextboxAdd(%s) UTF-8 encoding not supported in GSLC_FEATURE_XTEXTBOX_EMBED=1 mode\n","");
+    bWarned = true;
+  }
+#endif
+
+  // Add null-terminated string to the bottom of the buffer
+  // If the string exceeds the buffer length then it will wrap
+  // back to the beginning.
+  // TODO: Ensure that buffer wrap doesn't encroach upon visible region!
+  // TODO: Assert (pBox)
+  bool            bDone = false;
+  uint16_t        nTxtPos = 0;
+  unsigned char   chNext;
+
+  if (pTxt == NULL) { bDone = true; }
+  while (!bDone) {
+    chNext = pTxt[nTxtPos];
+    nTxtPos++;
+    if (chNext == 0) {
+      // Reached terminator character
+      // Add terminator to buffer but don't advance write pointer
+      // since we want next write to overwrite this
+      gslc_ElemXTextboxBufAdd(pGui,pElemRef,0,false);
+
+      bDone = true;
+      continue;
+    }
+
+    // FIXME: It is possible that the following check may no longer be
+    // appropriate when using UTF-8 encoding mode.
+    if (chNext == '\n') {
+      // Terminate the line
+      gslc_ElemXTextboxBufAdd(pGui,pElemRef,0,false);
+      // Advance the writer by one line
+      gslc_ElemXTextboxLineWrAdv(pGui,pElemRef);
+    } else {
+      // TODO: Check to see if we are in mask/truncate state
+      // Note that this routine also handles line wrap
+      gslc_ElemXTextboxBufAdd(pGui,pElemRef,chNext,true);
+    }
+  }
+
+  // Set the redraw flag
+  // - Only need incremental redraw
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+}
+
+bool gslc_ElemXTextboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  if ((pvGui == NULL) || (pvElemRef == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTextboxDraw";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return false;
+  }
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*     pGui      = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef* pElemRef  = (gslc_tsElemRef*)(pvElemRef);
+  gslc_tsElem*    pElem     = gslc_GetElemFromRef(pGui,pElemRef);
+  gslc_tsColor colBg = GSLC_COL_BLACK;
+  // Fetch the element's extended data structure
+  gslc_tsXTextbox* pBox;
+  pBox = (gslc_tsXTextbox*)(pElem->pXData);
+  if (pBox == NULL) {
+    GSLC_DEBUG2_PRINT("ERROR: ElemXTextboxDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  bool     bGlow     = (pElem->nFeatures & GSLC_ELEM_FEA_GLOW_EN) && gslc_ElemGetGlow(pGui,pElemRef);
+  bool     bFrameEn  = (pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN);
+
+  // Draw the frame
+  if (eRedraw == GSLC_REDRAW_FULL) {
+    if (bFrameEn) {
+      gslc_DrawFrameRect(pGui,pElem->rElem,pElem->colElemFrame);
+    }
+  }
+
+  // Clear the background (inset from frame)
+  // - Only do this if we need to redraw all rows
+  if ((eRedraw == GSLC_REDRAW_FULL) || (pBox->nRedrawRow == XTEXTBOX_REDRAW_ALL)) {
+    gslc_tsRect rInner = gslc_ExpandRect(pElem->rElem, -1, -1);
+    colBg = (bGlow) ? pElem->colElemFillGlow : pElem->colElemFill;
+    gslc_DrawFillRect(pGui, rInner, colBg);
+  }
+
+  uint16_t          nBufPos = 0;
+
+  uint16_t          nTxtPixX;
+  uint16_t          nTxtPixY;
+  gslc_tsColor      colTxt;
+  //bool            bEncUtf8;
+  bool              bRedrawLine;
+
+  // Determine what encoding method is used for text
+  // Not used at the moment
+  //bEncUtf8 = ((pElem->eTxtFlags & GSLC_TXT_ENC) == GSLC_TXT_ENC_UTF8);
+
+  // Initialize color state
+  colTxt = pElem->colElemText;
+
+  // Calculate the starting row for the window
+  uint16_t nWndRowStartScr = pBox->nWndRowStart;
+
+  // Only correct for scrollbar position if enabled
+  if (pBox->bScrollEn) {
+    nWndRowStartScr = (pBox->nWndRowStart + pBox->nScrollPos) % pBox->nBufRows;
+  }
+
+#if (GSLC_FEATURE_XTEXTBOX_EMBED == 0)
+
+  // Normal mode support (no embedded text color)
+  // - This mode is much faster and is able to support UTF-8 text encoding
+
+  uint8_t nCurY = 0;
+
+  uint8_t nOutRow = 0;
+  uint8_t nMaxRow = 0;
+
+  nMaxRow = (pBox->nBufRows < pBox->nWndRows)? pBox->nBufRows : pBox->nWndRows;
+  for (nOutRow=0;nOutRow<nMaxRow;nOutRow++) {
+
+    bRedrawLine = true; // Default to drawing the row
+
+    // Calculate row offset after accounting for buffer wrap
+    // and current window starting offset
+    uint16_t nRowCur = nWndRowStartScr + nOutRow;
+    nRowCur = nRowCur % pBox->nBufRows;
+
+    // If we are doing incremental redraw and only a single
+    // row has been marked as requiring redraw, then skip
+    // all other rows
+    if (eRedraw == GSLC_REDRAW_INC) {
+      if ((pBox->nRedrawRow >= 0) && (pBox->nRedrawRow != nRowCur)) {
+        // Single-row redraw, but we are not on that row, so skip
+        bRedrawLine = false;
+      }
+    }
+
+    // NOTE: At the start of buffer fill where we have
+    // only written a couple rows, we don't stop reading
+    // across all of the rows. We are dependent upon
+    // the reset to initialize all rows with NULL terminator
+    // so that we don't show garbage.
+
+    if (bRedrawLine) {
+      nBufPos = nRowCur * pBox->nBufCols;
+
+      nTxtPixX = pElem->rElem.x + pBox->nMarginX + 0 * pBox->nChSizeX;
+      nTxtPixY = pElem->rElem.y + pBox->nMarginY + nCurY * pBox->nChSizeY;
+#if (DRV_OVERRIDE_TXT_ALIGN)
+      gslc_DrvDrawTxtAlign(pGui,nTxtPixX,nTxtPixY,nTxtPixX,nTxtPixY,GSLC_ALIGN_TOP_LEFT,pElem->pTxtFont,
+            (char*)&(pBox->pBuf[nBufPos]),pElem->eTxtFlags,colTxt,colBg);
+#else
+      gslc_DrvDrawTxt(pGui, nTxtPixX, nTxtPixY, pElem->pTxtFont, (char*)&(pBox->pBuf[nBufPos]), pElem->eTxtFlags, colTxt, colBg);
+#endif
+    }
+
+    nCurY++;
+  } // nOutRow
+
+#else
+
+  // Embedded color mode support
+  // - This mode supports inline changing of text color
+  // - However, it does not support UTF-8 character encoding
+  // - It is also slower since rendering is per-character
+
+  enum              {TBOX_NORM, TBOX_COL_SET};
+  int16_t           eTBoxState = TBOX_NORM;
+  uint16_t          nTBoxStateCnt = 0;
+
+  unsigned char     chNext;
+  uint8_t           nCurX = 0;
+  uint8_t           nCurY = 0;
+
+  uint8_t nOutRow = 0;
+  uint8_t nOutCol = 0;
+  uint8_t nMaxCol = 0;
+  uint8_t nMaxRow = 0;
+  bool    bRowDone = false;
+  nMaxCol = (pBox->nBufCols < pBox->nWndCols)? pBox->nBufCols : pBox->nWndCols;
+  nMaxRow = (pBox->nBufRows < pBox->nWndRows)? pBox->nBufRows : pBox->nWndRows;
+  for (nOutRow=0;nOutRow<nMaxRow;nOutRow++) {
+
+    bRedrawLine = true; // Default to drawing the row
+
+    // Calculate row offset after accounting for buffer wrap
+    // and current window starting offset
+    uint16_t nRowCur = nWndRowStartScr + nOutRow;
+    nRowCur = nRowCur % pBox->nBufRows;
+
+    // If we are doing incremental redraw and only a single
+    // row has been marked as requiring redraw, then skip
+    // all other rows
+    if (eRedraw == GSLC_REDRAW_INC) {
+      if ((pBox->nRedrawRow >= 0) && (pBox->nRedrawRow != nRowCur)) {
+        // Single-row redraw, but we are not on that row, so skip
+        bRedrawLine = false;
+      }
+    }
+
+    bRowDone = false;
+    nCurX = 0;
+    for (nOutCol=0;(!bRowDone)&&(bRedrawLine)&&(nOutCol<nMaxCol);nOutCol++) {
+
+
+
+
+
+      // NOTE: At the start of buffer fill where we have
+      // only written a couple rows, we don't stop reading
+      // across all of the rows. We are dependent upon
+      // the reset to initialize all rows with NULL terminator
+      // so that we don't show garbage.
+
+      nBufPos = nRowCur * pBox->nBufCols + nOutCol;
+      chNext = pBox->pBuf[nBufPos];
+
+      if (eTBoxState == TBOX_NORM) {
+        if (chNext == 0) {
+          // Reached early terminator
+          bRowDone = true;
+          continue;
+        } else if (chNext == GSLC_XTEXTBOX_CODE_COL_SET) {
+          // Set color (enter FSM)
+          eTBoxState = TBOX_COL_SET;
+          nTBoxStateCnt = 0;
+        } else if (chNext == GSLC_XTEXTBOX_CODE_COL_RESET) {
+          // Reset color
+          colTxt = pElem->colElemText;
+        } else {
+
+          // Render the character
+          // TODO: Optimize by coalescing all characters in row before calling DrvDrawTxt
+          //       - Note that this would make it harder to change aspects (such as color)
+          //         in mid-line.
+          char  acChToDraw[2] = "";
+          acChToDraw[0] = chNext;
+          acChToDraw[1] = 0;
+          nTxtPixX = pElem->rElem.x + pBox->nMarginX + nCurX * pBox->nChSizeX;
+          nTxtPixY = pElem->rElem.y + pBox->nMarginY + nCurY * pBox->nChSizeY;
+#if (DRV_OVERRIDE_TXT_ALIGN)
+          gslc_DrvDrawTxtAlign(pGui,nTxtPixX,nTxtPixY,nTxtPixX,nTxtPixY,GSLC_ALIGN_TOP_LEFT,pElem->pTxtFont,
+            (char*)&acChToDraw,pElem->eTxtFlags,colTxt,colBg);
+#else
+          gslc_DrvDrawTxt(pGui,nTxtPixX,nTxtPixY,pElem->pTxtFont,(char*)&acChToDraw,pElem->eTxtFlags,colTxt,colBg);
+#endif
+          nCurX++;
+
+        }
+
+      } else if (eTBoxState == TBOX_COL_SET) {
+        nTBoxStateCnt++;
+        if      (nTBoxStateCnt == 1) { colTxt.r = chNext; }
+        else if (nTBoxStateCnt == 2) { colTxt.g = chNext; }
+        else if (nTBoxStateCnt == 3) {
+          colTxt.b = chNext;
+          eTBoxState = TBOX_NORM;
+        }
+      } // eTBoxState
+
+    } // nOutCol
+    nCurY++;
+  } // nOutRow
+
+#endif // GSLC_FEATURE_XTEXTBOX_EMBED
+
+  // Clear the redraw flag
+  pBox->nRedrawRow = XTEXTBOX_REDRAW_NONE;
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+   
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+
+// ============================================================================
diff --git a/src/guislice/XTextbox.h b/src/guislice/XTextbox.h
new file mode 100644
index 0000000..7dca66f
--- /dev/null
+++ b/src/guislice/XTextbox.h
@@ -0,0 +1,221 @@
+#ifndef _GUISLICE_EX_XTEXTBOX_H_
+#define _GUISLICE_EX_XTEXTBOX_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Textbox control
+// - Calvin Hass
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// 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 XTextbox.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+
+// ============================================================================
+// Extended Element: Textbox
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_TEXTBOX GSLC_TYPE_BASE_EXTEND + 4
+
+/// Definitions for textbox special inline codes
+#define GSLC_XTEXTBOX_CODE_COL_SET    187
+#define GSLC_XTEXTBOX_CODE_COL_RESET  188
+
+#define XTEXTBOX_REDRAW_NONE   -1
+#define XTEXTBOX_REDRAW_ALL    -2
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Textbox element
+typedef struct {
+  // Config
+  char*                       pBuf;         ///< Ptr to the text buffer (circular buffer))
+  int8_t                      nMarginX;     ///< Margin for text area within element rect (X)
+  int8_t                      nMarginY;     ///< Margin for text area within element rect (Y)
+  bool                        bWrapEn;      ///< Enable for line wrapping
+
+  uint16_t                    nBufRows;     ///< Number of rows in buffer
+  uint16_t                    nBufCols;     ///< Number of columns in buffer
+  bool                        bScrollEn;    ///< Enable for scrollbar
+  uint16_t                    nScrollPos;   ///< Current scrollbar position
+
+  // Precalculated params
+  uint8_t                     nChSizeX;     ///< Width of characters (pixels)
+  uint8_t                     nChSizeY;     ///< Height of characters (pixels)
+  uint8_t                     nWndCols;     ///< Window X size
+  uint8_t                     nWndRows;     ///< Window Y size
+  // Current status
+  uint8_t                     nCurPosX;     ///< Cursor X position
+  uint8_t                     nCurPosY;     ///< Cursor Y position
+  uint8_t                     nBufPosX;     ///< Buffer X position
+  uint8_t                     nBufPosY;     ///< Buffer Y position
+  uint8_t                     nWndRowStart; ///< First row of current window
+  // Redraw
+  int16_t                     nRedrawRow;   ///< Specific row to update in redraw (if not -1)
+
+} gslc_tsXTextbox;
+
+
+
+///
+/// Create a Textbox Element
+/// - The textbox is a scrolling window designed for displaying multi-line
+///   text using a monospaced font. A character buffer is defined by nBufRows*nBufCols
+///   to capture the added text. If the allocation buffer is larger than the
+///   display size (defined by rElem), then a scrollbar will be shown.
+/// - Support for changing color within a row can be enabled with GSLC_FEATURE_XTEXTBOX_EMBED 1
+/// - Note that each color change command will consume 4 of the available "column" bytes.
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining textbox size
+/// \param[in]  nFontId:     Font ID to use for text area
+/// \param[in]  pBuf:        Ptr to text buffer (already allocated)
+///                          with size (nBufRows*nBufCols) chars
+/// \param[in]  nBufRows:    Number of rows in buffer
+/// \param[in]  nBufCols:    Number of columns in buffer (incl special codes)
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXTextboxCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXTextbox* pXData,gslc_tsRect rElem,int16_t nFontId,char* pBuf,
+        uint16_t nBufRows,uint16_t nBufCols);
+
+
+/// Reset the contents of the textbox
+/// - Clears the buffer and resets the position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return none
+///
+void gslc_ElemXTextboxReset(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+
+///
+/// Draw a Textbox element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \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]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTextboxDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+/// Add a text string to the textbox
+/// - If it includes a newline then the buffer will
+///   advance to the next row
+/// - If wrap has been enabled, then a newline will
+///   be forced
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  pTxt         Pointer to text string (null-terminated)
+///
+/// \return none
+///
+void gslc_ElemXTextboxAdd(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,char* pTxt);
+
+///
+/// Insert a color set code into the current buffer position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nCol:        Color to assign for next text written to textbox
+///
+/// \return none
+///
+void gslc_ElemXTextboxColSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,gslc_tsColor nCol);
+
+///
+/// Insert a color reset code into the current buffer position
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return none
+///
+void gslc_ElemXTextboxColReset(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Enable or disable line wrap within textbox
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bWrapEn:     Enable line wrap if true
+///
+/// \return none
+///
+void gslc_ElemXTextboxWrapSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bWrapEn);
+
+
+///
+/// Set the textbox scroll position (nScrollPos) as a fraction of
+/// nScrollMax
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  nScrollPos:  New scroll position
+/// \param[in]  nScrollMax:  Maximum scroll position
+///
+/// \return none
+///
+void gslc_ElemXTextboxScrollSet(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,uint8_t nScrollPos,uint8_t nScrollMax);
+
+
+
+
+// ============================================================================
+
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XTEXTBOX_H_
+
diff --git a/src/guislice/XTogglebtn.c b/src/guislice/XTogglebtn.c
new file mode 100644
index 0000000..b50489d
--- /dev/null
+++ b/src/guislice/XTogglebtn.c
@@ -0,0 +1,453 @@
+// =======================================================================
+// GUIslice library extension: Toggle button control
+// - Paul Conti
+// - Toggle button with Android and iOS like styles
+// - Based on Calvin Hass' Checkbox control
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass and Paul Conti
+//
+// 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 XTogglebtn.c
+
+
+
+// GUIslice library
+#include "GUIslice.h"
+#include "GUIslice_drv.h"
+
+//#include "XTogglebtn.h"
+#include "XTogglebtn.h"
+
+#include <stdio.h>
+
+#if (GSLC_USE_PROGMEM)
+    #include <avr/pgmspace.h>
+#endif
+
+// ----------------------------------------------------------------------------
+// Error Messages
+// ----------------------------------------------------------------------------
+
+extern const char GSLC_PMEM ERRSTR_NULL[];
+extern const char GSLC_PMEM ERRSTR_PXD_NULL[];
+
+
+// ----------------------------------------------------------------------------
+// Extended element definitions
+// ----------------------------------------------------------------------------
+//
+// - This file extends the core GUIslice functionality with
+//   additional widget types
+//
+// ----------------------------------------------------------------------------
+
+// ============================================================================
+// Extended Element: Togglebtn
+// - Togglebtn 
+//   Acts much like a checkbox but with styles that are similar to iOS and 
+//   Android slider buttons.
+// ============================================================================
+
+// Create a togglebtn element and add it to the GUI element list
+gslc_tsElemRef* gslc_ElemXTogglebtnCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXTogglebtn* pXData,gslc_tsRect rElem,
+  gslc_tsColor colThumb,gslc_tsColor colOnState,gslc_tsColor colOffState,
+  bool bCircular,bool bChecked,GSLC_CB_TOUCH cbTouch)
+{
+  if ((pGui == NULL) || (pXData == NULL)) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTogglebtnCreate";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+  gslc_tsElem     sElem;
+  gslc_tsElemRef* pElemRef = NULL;
+  sElem = gslc_ElemCreate(pGui,nElemId,nPage,GSLC_TYPEX_TOGGLEBTN,rElem,NULL,0,GSLC_FONT_NONE);
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FRAME_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_FILL_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_CLICK_EN;
+  sElem.nFeatures        |= GSLC_ELEM_FEA_GLOW_EN;
+
+  // Define other extended data
+  sElem.pXData            = (void*)(pXData);
+  pXData->bOn             = bChecked;    // save on/off status
+  pXData->pfunctUser      = cbTouch;     // save user's callback in our extra data
+  pXData->nMyPageId       = nPage;       // save our page id for group by access later, if needed.
+  pXData->colThumb        = colThumb;    // save thumb color
+  pXData->colOnState      = colOnState;  // save on color
+  pXData->colOffState     = colOffState; // save off color
+  pXData->bCircular       = bCircular;   // save button style
+  
+  // Specify the custom drawing callback
+  sElem.pfuncXDraw        = &gslc_ElemXTogglebtnDraw;
+  
+  // Specify the custom touch handler
+  sElem.pfuncXTouch       = &gslc_ElemXTogglebtnTouch;
+  sElem.colElemFill       = GSLC_COL_BLACK;
+  sElem.colElemFillGlow   = GSLC_COL_BLACK;
+  sElem.colElemFrame      = GSLC_COL_GRAY;
+  sElem.colElemFrameGlow  = GSLC_COL_WHITE;
+  
+  if (nPage != GSLC_PAGE_NONE) {
+    pElemRef = gslc_ElemAdd(pGui,nPage,&sElem,GSLC_ELEMREF_DEFAULT);
+    return pElemRef;
+#if (GSLC_FEATURE_COMPOUND)
+  } else {
+    // Save as temporary element
+    pGui->sElemTmp = sElem;
+    pGui->sElemRefTmp.pElem = &(pGui->sElemTmp);
+    pGui->sElemRefTmp.eElemFlags = GSLC_ELEMREF_DEFAULT | GSLC_ELEMREF_REDRAW_FULL;
+    return &(pGui->sElemRefTmp);
+#endif
+  }
+  return NULL;
+}
+
+bool gslc_ElemXTogglebtnGetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) return false;
+
+  return pTogglebtn->bOn;
+}
+
+// Helper routine for gslc_ElemXTogglebtnSetState()
+// - Updates the togglebtn control's state but does
+//   not touch any other controls in the group
+void gslc_ElemXTogglebtnSetStateHelp(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bOn)
+{
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) return;
+
+  // Update our data element
+  bool  bStateOld = pTogglebtn->bOn;
+  pTogglebtn->bOn = bOn;
+
+  // Element needs redraw
+  if (bOn != bStateOld) {
+    // Only need an incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+}
+
+// Update the togglebtn control's state. If it's part of a group
+// then also update the state of all other buttons in the group.
+void gslc_ElemXTogglebtnSetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bOn)
+{
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) return;
+
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+
+  int16_t             nGroup    = pElem->nGroup;
+  int16_t             nElemId   = pElem->nId;
+
+  if (bOn && pElem->nGroup != GSLC_GROUP_ID_NONE) {
+
+    // If we are selecting a button that is already
+    // selected, then skip further update events.
+    // NOTE: This check is not very efficient, but it avoids
+    // the creation of extra events.
+    gslc_tsElemRef* pTmpRef = gslc_ElemXTogglebtnFindSelected(pGui, nGroup);
+    if (pTmpRef == pElemRef) {
+      // Same element, so skip
+      return;
+    }
+
+    // Proceed to deselect any other selected items in the group.
+    // Note that SetState calls itself to deselect other items so it
+    // is important to qualify this logic with bOn=true
+    int16_t           nCurInd;
+    int16_t           nCurId;
+    gslc_tsElem*      pCurElem = NULL;
+    gslc_tsElemRef*   pCurElemRef = NULL;
+    int16_t           nCurGroup;
+
+    /* 
+     * The elements must be grouped on the same layer but do not need to be on the current
+     * page.  This allows us to place grouped elements on the base page.
+     * p conti.
+     */
+    // Find our page layer
+    gslc_tsPage* pPage = gslc_PageFindById(pGui, pTogglebtn->nMyPageId);
+    if (pPage == NULL) {
+      GSLC_DEBUG2_PRINT("ERROR: gslc_ElemXTogglebtnSetState() can't find page (ID=%d)\n", 
+         pTogglebtn->nMyPageId);
+      return;
+    }
+
+    gslc_tsCollect* pCollect = &pPage->sCollect;
+    for (nCurInd=0;nCurInd<pCollect->nElemRefCnt;nCurInd++) {
+      // Fetch extended data
+      pCurElemRef   = &pCollect->asElemRef[nCurInd];
+      pCurElem      = gslc_GetElemFromRef(pGui,pCurElemRef);
+
+      // NOTE: Sorry but I have no idea what this FIXME is talking about - p conti
+      // FIXME: Handle pCurElemRef->eElemFlags 
+      nCurId        = pCurElem->nId;
+
+      nCurGroup     = pCurElem->nGroup;
+
+      // If this is in a different group, ignore it
+      if (nCurGroup != nGroup) {
+        continue;
+      }
+
+      // Is this our element? If so, ignore the deselect operation
+      if (nCurId == nElemId) {
+        continue;
+      }
+
+      // Deselect all other elements
+      gslc_ElemSetGlow(pGui,pCurElemRef,false);  // trurn off glow state
+      gslc_ElemXTogglebtnSetStateHelp(pGui,pCurElemRef,false);
+
+    } // nInd
+
+  } // bOn
+
+  // Set the state of the current element
+  gslc_ElemXTogglebtnSetStateHelp(pGui,pElemRef,bOn);
+}
+
+// Toggle the togglebtn control's state
+void gslc_ElemXTogglebtnToggleState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef)
+{
+  if (pElemRef == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTogglebtnToggleState";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return;
+  }
+  // Toggle the data element value
+  bool bStateNew = (gslc_ElemXTogglebtnGetState(pGui,pElemRef))? false : true;
+  gslc_ElemXTogglebtnSetState(pGui,pElemRef,bStateNew);
+}
+
+void gslc_ElemXTogglebtnDrawCircularHelp(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsXTogglebtn* pTogglebtn) 
+{
+  // frame enabled?
+  bool bFrameEn  = pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN;
+
+  // Work out the sizes of the inner rectangles 
+  gslc_tsRect rInner = gslc_ExpandRect(pElem->rElem,-1,-1);
+
+  // work out our circle positions
+  uint16_t nRadius  = rInner.h / 2;
+  int16_t  nLeftX   = rInner.x + nRadius;
+  int16_t  nLeftY   = rInner.y + nRadius;
+  int16_t  nRightX  = rInner.x + pElem->rElem.w - nRadius -1;
+  int16_t  nRightY  = rInner.y + nRadius;
+    
+  if (pTogglebtn->bOn) {
+    // draw our main body
+    gslc_DrawFillRoundRect(pGui,rInner,rInner.h,pTogglebtn->colOnState);
+    // place thumb on left-hand side
+    gslc_DrawFillCircle(pGui,nLeftX,nLeftY,nRadius-1,pTogglebtn->colThumb);
+    if (bFrameEn) {
+      gslc_DrawFrameRoundRect(pGui,pElem->rElem,pElem->rElem.h,pElem->colElemFrame);
+      gslc_DrawFrameCircle(pGui,nLeftX,nLeftY,nRadius,pElem->colElemFrame);
+    }
+  } else {
+    // draw our main body
+    gslc_DrawFillRoundRect(pGui,rInner,rInner.h,pTogglebtn->colOffState);
+    // place thumb on right-hand side
+    gslc_DrawFillCircle(pGui,nRightX,nRightY,nRadius-1,pTogglebtn->colThumb);
+    if (bFrameEn) {
+      gslc_DrawFrameRoundRect(pGui,pElem->rElem,pElem->rElem.h,pElem->colElemFrame);
+      gslc_DrawFrameCircle(pGui,nRightX,nRightY,nRadius,pElem->colElemFrame);
+    }
+  }
+}
+
+void gslc_ElemXTogglebtnDrawRectangularHelp(gslc_tsGui* pGui,gslc_tsElem* pElem,gslc_tsXTogglebtn* pTogglebtn) 
+{
+  // frame enabled?
+  bool bFrameEn  = pElem->nFeatures & GSLC_ELEM_FEA_FRAME_EN;
+
+  // Work out the sizes of the inner rectangles 
+  gslc_tsRect rSquare = {
+    pElem->rElem.x,
+    pElem->rElem.y,
+    pElem->rElem.h, // force a square
+    pElem->rElem.h
+  };
+  gslc_tsRect rInner = gslc_ExpandRect(pElem->rElem,-1,-1);
+
+  if (pTogglebtn->bOn) {
+    gslc_DrawFillRect(pGui,rInner,pTogglebtn->colOnState);
+    // place thumb on left-hand side
+    gslc_DrawFillRect(pGui,rSquare,pTogglebtn->colThumb);
+    if (bFrameEn) {
+      gslc_DrawFrameRect(pGui,pElem->rElem,pElem->colElemFrame);
+      gslc_DrawFrameRect(pGui,rSquare,pElem->colElemFrame);
+    }
+  } else {
+    gslc_DrawFillRect(pGui,rInner,pTogglebtn->colOffState);
+    // place thumb on right-hand side
+    rSquare.x = rInner.x + rInner.w - rInner.h - 1;
+    gslc_DrawFillRect(pGui,rSquare,pTogglebtn->colThumb);
+    if (bFrameEn) {
+      gslc_DrawFrameRect(pGui,pElem->rElem,pElem->colElemFrame);
+      gslc_DrawFrameRect(pGui,rSquare,pElem->colElemFrame);
+    }
+  }
+}
+
+// Redraw the togglebtn
+// - Note that this redraw is for the entire element rect region
+// - The Draw function parameters use void pointers to allow for
+//   simpler callback function definition & scalability.
+
+bool gslc_ElemXTogglebtnDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw)
+{
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) {
+    GSLC_DEBUG_PRINT("ERROR: gslc_ElemXTogglebtnDraw(%s) pXData is NULL\n","");
+    return false;
+  }
+
+  gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+ 
+  if (pTogglebtn->bCircular) {
+    gslc_ElemXTogglebtnDrawCircularHelp(pGui, pElem, pTogglebtn);
+  } else {
+    gslc_ElemXTogglebtnDrawRectangularHelp(pGui, pElem, pTogglebtn);
+  }
+  
+  // Clear the redraw flag
+  gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_NONE);
+
+  // Mark page as needing flip
+  gslc_PageFlipSet(pGui,true);
+
+  return true;
+}
+
+// This callback function is called by gslc_ElemSendEventTouch()
+// after any touch event
+// - NOTE: Adding this touch callback is optional. Without it, we
+//   can still have a functional togglebtn, but doing the touch
+//   tracking allows us to change the glow state of the element
+//   dynamically, as well as updating the togglebtn state if the
+//   user releases over it (ie. a click event).
+//
+bool gslc_ElemXTogglebtnTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY)
+{
+#if defined(DRV_TOUCH_NONE)
+  return false;
+#else
+
+  // Typecast the parameters to match the GUI and element types
+  gslc_tsGui*       pGui  = (gslc_tsGui*)(pvGui);
+  gslc_tsElemRef*   pElemRef = (gslc_tsElemRef*)(pvElemRef);
+
+  gslc_tsXTogglebtn* pTogglebtn = (gslc_tsXTogglebtn*)gslc_GetXDataFromRef(pGui, pElemRef, GSLC_TYPEX_TOGGLEBTN, __LINE__);
+  if (!pTogglebtn) return false;
+
+  //gslc_tsElem* pElem = gslc_GetElemFromRef(pGui,pElemRef);
+  bool  bStateOld = pTogglebtn->bOn;
+
+  switch(eTouch) {
+
+    case GSLC_TOUCH_UP_IN:
+      // Now that we released on element, update the state
+      // Togglebtn button action: toggle
+      gslc_ElemXTogglebtnToggleState(pGui,pElemRef);
+      break;
+    default:
+      return false;
+      break;
+  }
+
+  // If the togglebtn changed state, redraw and notify user
+  if (pTogglebtn->bOn != bStateOld) {
+    // Now send the callback notification
+    (*pTogglebtn->pfunctUser)((void*)(pGui), (void*)(pElemRef), eTouch, nRelX, nRelY);
+    // Incremental redraw
+    gslc_ElemSetRedraw(pGui,pElemRef,GSLC_REDRAW_INC);
+  }
+
+  return true;
+  #endif // !DRV_TOUCH_NONE
+}
+
+// Determine which togglebtn in the group is selected "on"
+gslc_tsElemRef* gslc_ElemXTogglebtnFindSelected(gslc_tsGui* pGui,int16_t nGroupId)
+{
+  int16_t             nCurInd;
+  gslc_tsElemRef*     pCurElemRef = NULL;
+  gslc_tsElem*        pCurElem = NULL;
+  int16_t             nCurType;
+  int16_t             nCurGroup;
+  bool                bCurSelected;
+  gslc_tsElemRef*     pFoundElemRef = NULL;
+
+  // Operate on current page
+  // TODO: Support other page layers
+  gslc_tsPage* pPage = pGui->apPageStack[GSLC_STACK_CUR];
+  if (pPage == NULL) {
+    return NULL; // No page added yet
+  }
+  
+  if (pGui == NULL) {
+    static const char GSLC_PMEM FUNCSTR[] = "ElemXTogglebtnFindChecked";
+    GSLC_DEBUG2_PRINT_CONST(ERRSTR_NULL,FUNCSTR);
+    return NULL;
+  }
+
+  gslc_tsCollect* pCollect = &pPage->sCollect;
+  for (nCurInd=0;nCurInd<pCollect->nElemCnt;nCurInd++) {
+    // Fetch extended data
+    pCurElemRef   = &(pCollect->asElemRef[nCurInd]);
+    pCurElem      = gslc_GetElemFromRef(pGui,pCurElemRef);
+    nCurType      = pCurElem->nType;
+    // Only want to proceed if it is a togglebtn
+    if (nCurType != GSLC_TYPEX_TOGGLEBTN) {
+      continue;
+    }
+
+    nCurGroup     = pCurElem->nGroup;
+    bCurSelected   = gslc_ElemXTogglebtnGetState(pGui,pCurElemRef);
+
+    // If this is in a different group, ignore it
+    if (nCurGroup != nGroupId) {
+      continue;
+    }
+
+    // Did we find an element in the group that was checked?
+    if (bCurSelected) {
+      pFoundElemRef = pCurElemRef;
+      break;
+    }
+  } // nCurInd
+  return pFoundElemRef;
+}
+
+// ============================================================================
diff --git a/src/guislice/XTogglebtn.h b/src/guislice/XTogglebtn.h
new file mode 100644
index 0000000..6fedea6
--- /dev/null
+++ b/src/guislice/XTogglebtn.h
@@ -0,0 +1,282 @@
+#ifndef _GUISLICE_EX_XTOGGLEBTN_H_
+#define _GUISLICE_EX_XTOGGLEBTN_H_
+
+#include "GUIslice.h"
+
+
+// =======================================================================
+// GUIslice library extension: Toggle button control
+// - Paul Conti
+// - Toggle button with Android and iOS like styles
+// - Based on Calvin Hass' Checkbox control
+// - https://www.impulseadventure.com/elec/guislice-gui.html
+// - https://github.com/ImpulseAdventure/GUIslice
+// =======================================================================
+//
+// The MIT License
+//
+// Copyright 2016-2020 Calvin Hass and Paul Conti
+//
+// 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 XTogglebtn.h
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+// ============================================================================
+// Extended Element: Togglebtn
+// - Togglebtn 
+//   Acts much like a checkbox but with styles that are similar to iOS and 
+//   Android slider buttons.
+// ============================================================================
+
+// Define unique identifier for extended element type
+// - Select any number above GSLC_TYPE_BASE_EXTEND
+#define  GSLC_TYPEX_TOGGLEBTN GSLC_TYPE_BASE_EXTEND + 40
+
+// Extended element data structures
+// - These data structures are maintained in the gslc_tsElem
+//   structure via the pXData pointer
+
+/// Extended data for Togglebtn element
+typedef struct {
+  bool                        bOn;          ///< Indicates if button is ON or OFF
+  int16_t                     nMyPageId;    ///< We need to track our page in case of grouping elements 
+                                            ///< on a non current layer, like base layer
+  gslc_tsColor                colThumb;     ///< Color of thumb
+  gslc_tsColor                colOnState;   ///< Color of button in ON state
+  gslc_tsColor                colOffState;  ///< Color of button in OFF state
+  bool                        bCircular;    ///< Style of the toggle button circular or rectangular
+  GSLC_CB_TOUCH               pfunctUser;   ///< User's Callback event to say element has changed
+} gslc_tsXTogglebtn;
+
+
+///
+/// Create a Togglebtn button Element
+///
+/// \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]  pXData:      Ptr to extended element data structure
+/// \param[in]  rElem:       Rectangle coordinates defining togglebtn size
+/// \param[in]  colThumb:    Color of thumb
+/// \param[in]  colOnState:  Color to indicate on position
+/// \param[in]  colOffState: Color to indicate off position
+/// \param[in]  bCircular:   Style of the toggle button circular or rectangular
+/// \param[in]  bChecked:    Default state
+/// \param[in]  cbTouch:     Callback for touch events
+///
+/// \return Pointer to Element reference or NULL if failure
+///
+gslc_tsElemRef* gslc_ElemXTogglebtnCreate(gslc_tsGui* pGui,int16_t nElemId,int16_t nPage,
+  gslc_tsXTogglebtn* pXData,gslc_tsRect rElem,
+  gslc_tsColor colThumb,gslc_tsColor colOnState,gslc_tsColor colOffState,
+  bool bCircular,bool bChecked,GSLC_CB_TOUCH cbTouch);
+
+
+///
+/// Get a Togglebtn element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return Current state
+///
+bool gslc_ElemXTogglebtnGetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Set a Togglebtn element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+/// \param[in]  bOn:    New state
+///
+/// \return none
+///
+void gslc_ElemXTogglebtnSetState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef,bool bOn);
+
+///
+/// Toggle a Togglebtn element's current state
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  pElemRef:    Pointer to Element reference
+///
+/// \return none
+///
+void gslc_ElemXTogglebtnToggleState(gslc_tsGui* pGui,gslc_tsElemRef* pElemRef);
+
+///
+/// Draw a Togglebtn element on the screen
+/// - Called from gslc_ElemDraw()
+///
+/// \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]  eRedraw:     Redraw mode
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTogglebtnDraw(void* pvGui,void* pvElemRef,gslc_teRedrawType eRedraw);
+
+///
+/// Handle touch events to Togglebtn element
+/// - Called from gslc_ElemSendEventTouch()
+///
+/// \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
+///
+/// \return true if success, false otherwise
+///
+bool gslc_ElemXTogglebtnTouch(void* pvGui,void* pvElemRef,gslc_teTouch eTouch,int16_t nRelX,int16_t nRelY);
+
+///
+/// Find the togglebtn within a group that has been selected
+///
+/// \param[in]  pGui:        Pointer to GUI
+/// \param[in]  nGroupId:    Group ID to search
+///
+/// \return Element Ptr or NULL if none selected
+///
+gslc_tsElemRef* gslc_ElemXTogglebtnFindSelected(gslc_tsGui* pGui,int16_t nGroupId);
+
+// ============================================================================
+// ------------------------------------------------------------------------
+// Read-only element macros
+// ------------------------------------------------------------------------
+
+// Macro initializers for Read-Only Elements in Flash/PROGMEM
+//
+
+
+/// \def gslc_ElemXTogglebtnCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,nGroup,bRadio_,nStyle_,colCheck_,bChecked_)
+///
+/// Create a Togglebtn button Element
+///
+/// \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]  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]  colThumb_:    Color of thumb
+/// \param[in]  colOnState_:  Color to indicate on position
+/// \param[in]  colOffState_: Color to indicate off position
+/// \param[in]  bCircular_:   Style of the toggle button circular or rectangular
+/// \param[in]  bChecked_:    Default state
+/// \param[in]  cbTouch:      Callback for touch events
+///
+/// \return none
+///
+
+#if (GSLC_USE_PROGMEM)
+
+#define gslc_ElemXTogglebtnCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,colThumb_,colOnState_,colOffState_,bCircular_,bChecked_,cbTouch) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXTogglebtn sTogglebtn##nElemId;                   \
+  sTogglebtn##nElemId.bOn = bChecked_;                            \
+  sTogglebtn##nElemId.nMyPageId = nPage;                          \
+  sTogglebtn##nElemId.colThumb = colThumb_;                       \
+  sTogglebtn##nElemId.colOnState = colOnState_;                   \
+  sTogglebtn##nElemId.colOffState = colOffState_;                 \
+  sTogglebtn##nElemId.bCircular = bCircular_;                     \
+  sTogglebtn##nElemId.pfunctUser = cbTouch;                       \
+  static const gslc_tsElem sElem##nElemId PROGMEM = {             \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_TOGGLEBTN,                                       \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      0,                                                          \
+      GSLC_COL_GRAY,GSLC_COL_BLACK,GSLC_COL_WHITE,GSLC_COL_BLACK, \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sTogglebtn##nElemId),                              \
+      NULL,                                                       \
+      &gslc_ElemXTogglebtnDraw,                                   \
+      &gslc_ElemXTogglebtnTouch,                                  \
+      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_ElemXTogglebtnCreate_P(pGui,nElemId,nPage,nX,nY,nW,nH,colThumb_,colOnState_,colOffState_,bCircular_,bChecked_,cbTouch) \
+  static const uint8_t nFeatures##nElemId = GSLC_ELEM_FEA_VALID | \
+    GSLC_ELEM_FEA_GLOW_EN | GSLC_ELEM_FEA_CLICK_EN | GSLC_ELEM_FEA_FILL_EN; \
+  static gslc_tsXTogglebtn sTogglebtn##nElemId;                   \
+  sTogglebtn##nElemId.bOn = bChecked_;                            \
+  sTogglebtn##nElemId.nMyPageId = nPage;                          \
+  sTogglebtn##nElemId.colThumb = colThumb_;                       \
+  sTogglebtn##nElemId.colOnState = colOnState_;                   \
+  sTogglebtn##nElemId.colOffState = colOffState_;                 \
+  sTogglebtn##nElemId.bCircular = bCircular_;                     \
+  sTogglebtn##nElemId.pfunctUser = cbTouch;                       \
+  static const gslc_tsElem sElem##nElemId = {                     \
+      nElemId,                                                    \
+      nFeatures##nElemId,                                         \
+      GSLC_TYPEX_TOGGLEBTN,                                       \
+      (gslc_tsRect){nX,nY,nW,nH},                                 \
+      0,                                                          \
+      GSLC_COL_GRAY,GSLC_COL_BLACK,GSLC_COL_WHITE,GSLC_COL_BLACK, \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      (gslc_tsImgRef){NULL,NULL,GSLC_IMGREF_NONE,NULL},           \
+      NULL,                                                       \
+      NULL,                                                       \
+      0,                                                          \
+      (gslc_teTxtFlags)(GSLC_TXT_DEFAULT),                        \
+      GSLC_COL_WHITE,                                             \
+      GSLC_COL_WHITE,                                             \
+      GSLC_ALIGN_MID_MID,                                         \
+      0,                                                          \
+      0,                                                          \
+      NULL,                                                       \
+      (void*)(&sTogglebtn##nElemId),                              \
+      NULL,                                                       \
+      &gslc_ElemXTogglebtnDraw,                                   \
+      &gslc_ElemXTogglebtnTouch,                                  \
+      NULL,                                                       \
+  };                                                              \
+  gslc_ElemAdd(pGui,nPage,(gslc_tsElem*)&sElem##nElemId,          \
+    (gslc_teElemRefFlags)(GSLC_ELEMREF_SRC_PROG | GSLC_ELEMREF_VISIBLE | GSLC_ELEMREF_REDRAW_FULL));
+
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_EX_XTOGGLEBTN_H_
diff --git a/src/guislice/ard-adagfx-ili9341-notouch.h b/src/guislice/ard-adagfx-ili9341-notouch.h
new file mode 100644
index 0000000..8306c09
--- /dev/null
+++ b/src/guislice/ard-adagfx-ili9341-notouch.h
@@ -0,0 +1,207 @@
+#ifndef _GUISLICE_CONFIG_ARD_H_
+#define _GUISLICE_CONFIG_ARD_H_
+
+// =============================================================================
+// GUIslice library (example user configuration) for:
+//   - CPU:     Arduino UNO / MEGA / etc
+//   - Display: ILI9341
+//   - Touch:   None
+//   - Wiring:  Custom breakout
+//              - Pinout:
+//
+//   - Example display:
+//     -
+//
+// DIRECTIONS:
+// - To use this example configuration, include in "GUIslice_config.h"
+//
+// WIRING:
+// - As this config file is designed for a breakout board, customization
+//   of the Pinout in SECTION 2 will be required to match your display.
+//
+// =============================================================================
+// - Calvin Hass
+// - https://github.com/ImpulseAdventure/GUIslice
+// =============================================================================
+//
+// 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_config_ard.h
+
+// =============================================================================
+// User Configuration
+// - This file can be modified by the user to match the
+//   intended target configuration
+// =============================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+  // =============================================================================
+  // USER DEFINED CONFIGURATION
+  // =============================================================================
+
+  // -----------------------------------------------------------------------------
+  // SECTION 1: Device Mode Selection
+  // - The following defines the display and touch drivers
+  //   and should not require modifications for this example config
+  // -----------------------------------------------------------------------------
+  #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  #define DRV_DISP_ADAGFX_ILI9341   // Adafruit ILI9341
+  #define DRV_TOUCH_NONE            // No touch enabled
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 2: Pinout
+  // -----------------------------------------------------------------------------
+
+  // For shields, the following pinouts are typically hardcoded
+  #define ADAGFX_PIN_CS       9    // Display chip select
+  #define ADAGFX_PIN_DC       10     // Display SPI data/command
+  #define ADAGFX_PIN_RST      0     // Display Reset
+
+  // Display interface type
+  #define ADAGFX_SPI_HW       1	    // Display uses SPI interface: 1=hardware 0=software
+
+  // Display interface software SPI
+  // - Hardware SPI: the following definitions are unused
+  // - Software SPI: the following pins need to be defined
+  #define ADAGFX_PIN_MOSI     11
+  #define ADAGFX_PIN_MISO     12
+  #define ADAGFX_PIN_CLK      13
+
+  // SD Card
+  #define ADAGFX_PIN_SDCS     5     // SD card chip select (if GSLC_SD_EN=1)
+
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 3: Orientation
+  // -----------------------------------------------------------------------------
+
+  // Set Default rotation of the display
+  // - Values 0,1,2,3. Rotation is clockwise
+  #define GSLC_ROTATE     1
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 5: Diagnostics
+  // -----------------------------------------------------------------------------
+
+  // Error reporting
+  // - Set DEBUG_ERR to >0 to enable error reporting via the Serial connection
+  // - Enabling DEBUG_ERR increases FLASH memory consumption which may be
+  //   limited on the baseline Arduino (ATmega328P) devices.
+  //   - DEBUG_ERR 0 = Disable all error messaging
+  //   - DEBUG_ERR 1 = Enable critical error messaging (eg. init)
+  //   - DEBUG_ERR 2 = Enable verbose error messaging (eg. bad parameters, etc.)
+  // - For baseline Arduino UNO, recommended to disable this after one has
+  //   confirmed basic operation of the library is successful.
+  #define DEBUG_ERR               1   // 1,2 to enable, 0 to disable
+
+  // Debug initialization message
+  // - By default, GUIslice outputs a message in DEBUG_ERR mode
+  //   to indicate the initialization status, even during success.
+  // - To disable the messages during successful initialization,
+  //   uncomment the following line.
+  //#define INIT_MSG_DISABLE
+
+  // -----------------------------------------------------------------------------
+  // SECTION 6: Optional Features
+  // -----------------------------------------------------------------------------
+
+  // Enable of optional features
+  // - For memory constrained devices such as Arduino, it is best to
+  //   set the following features to 0 (to disable) unless they are
+  //   required.
+  #define GSLC_FEATURE_COMPOUND       1   // Compound elements (eg. XSelNum)
+  #define GSLC_FEATURE_XTEXTBOX_EMBED 1   // XTextbox control with embedded color
+  #define GSLC_FEATURE_INPUT          1   // Keyboard / GPIO input control
+
+  // Enable support for SD card
+  // - Set to 1 to enable, 0 to disable
+  // - Note that the inclusion of the SD library consumes considerable
+  //   RAM and flash memory which could be problematic for Arduino models
+  //   with limited resources.
+  #define GSLC_SD_EN    0
+
+
+  // =============================================================================
+  // SECTION 10: INTERNAL CONFIGURATION
+  // - The following settings should not require modification by users
+  // =============================================================================
+
+  // -----------------------------------------------------------------------------
+  // Touch Handling
+  // -----------------------------------------------------------------------------
+
+  // Define the maximum number of touch events that are handled
+  // per gslc_Update() call. Normally this can be set to 1 but certain
+  // displays may require a greater value (eg. 30) in order to increase
+  // responsiveness of the touch functionality.
+  #define GSLC_TOUCH_MAX_EVT    1
+
+  // -----------------------------------------------------------------------------
+  // Misc
+  // -----------------------------------------------------------------------------
+
+  // Define buffer size for loading images from SD
+  // - A larger buffer will be faster but at the cost of RAM
+  #define GSLC_SD_BUFFPIXEL   50
+
+  // Enable support for graphics clipping (DrvSetClipRect)
+  // - Note that this will impact performance of drawing graphics primitives
+  #define GSLC_CLIP_EN 1
+
+  // Enable for bitmap transparency and definition of color to use
+  #define GSLC_BMP_TRANS_EN     1               // 1 = enabled, 0 = disabled
+  #define GSLC_BMP_TRANS_RGB    0xFF,0x00,0xFF  // RGB color (default: MAGENTA)
+
+  #define GSLC_USE_FLOAT        1   // 1=Use floating pt library, 0=Fixed-point lookup tables
+
+  #define GSLC_DEV_TOUCH ""
+  #define GSLC_USE_PROGMEM      0
+
+  #define GSLC_LOCAL_STR        1   // 1=Use local strings (in element array), 0=External
+  #define GSLC_LOCAL_STR_LEN    30  // Max string length of text elements
+
+  // -----------------------------------------------------------------------------
+  // Debug diagnostic modes
+  // -----------------------------------------------------------------------------
+  // - Uncomment any of the following to enable specific debug modes
+  //#define DBG_LOG           // Enable debugging log output
+  //#define DBG_TOUCH         // Enable debugging of touch-presses
+  //#define DBG_FRAME_RATE    // Enable diagnostic frame rate reporting
+  //#define DBG_DRAW_IMM      // Enable immediate rendering of drawing primitives
+  //#define DBG_DRIVER        // Enable graphics driver debug reporting
+
+
+  // =============================================================================
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_ARD_H_
diff --git a/src/guislice/ard-adagfx-ili9341-stmpe610.h b/src/guislice/ard-adagfx-ili9341-stmpe610.h
new file mode 100644
index 0000000..ec61a60
--- /dev/null
+++ b/src/guislice/ard-adagfx-ili9341-stmpe610.h
@@ -0,0 +1,246 @@
+#ifndef _GUISLICE_CONFIG_ARD_H_
+#define _GUISLICE_CONFIG_ARD_H_
+
+// =============================================================================
+// GUIslice library (example user configuration) for:
+//   - CPU:     Arduino UNO / MEGA / etc
+//   - Display: ILI9341
+//   - Touch:   STMPE610 (Resistive)
+//   - Wiring:  Custom breakout
+//              - Pinout:
+//
+//   - Example display:
+//     - Adafruit 2.8" TFT LCD Shield w/ Touchscreen (resistive)
+//
+// DIRECTIONS:
+// - To use this example configuration, include in "GUIslice_config.h"
+//
+// WIRING:
+// - As this config file is designed for a breakout board, customization
+//   of the Pinout in SECTION 2 will be required to match your display.
+//
+// =============================================================================
+// - Calvin Hass
+// - https://github.com/ImpulseAdventure/GUIslice
+// =============================================================================
+//
+// 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_config_ard.h
+
+// =============================================================================
+// User Configuration
+// - This file can be modified by the user to match the
+//   intended target configuration
+// =============================================================================
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+
+  // =============================================================================
+  // USER DEFINED CONFIGURATION
+  // =============================================================================
+
+  // -----------------------------------------------------------------------------
+  // SECTION 1: Device Mode Selection
+  // - The following defines the display and touch drivers
+  //   and should not require modifications for this example config
+  // -----------------------------------------------------------------------------
+  #define DRV_DISP_ADAGFX           // Adafruit-GFX library
+  #define DRV_DISP_ADAGFX_ILI9341   // Adafruit ILI9341
+  #define DRV_TOUCH_ADA_STMPE610    // Adafruit STMPE610 touch driver
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 2: Pinout
+  // -----------------------------------------------------------------------------
+
+  // For shields, the following pinouts are typically hardcoded
+  #define ADAGFX_PIN_CS       9    // Display chip select
+  #define ADAGFX_PIN_DC       10     // Display SPI data/command
+  #define ADAGFX_PIN_RST      0     // Display Reset
+
+  // Display interface type
+  #define ADAGFX_SPI_HW       1	    // Display uses SPI interface: 1=hardware 0=software
+
+  // Display interface software SPI
+  // - Hardware SPI: the following definitions are unused
+  // - Software SPI: the following pins need to be defined
+  #define ADAGFX_PIN_MOSI     11
+  #define ADAGFX_PIN_MISO     12
+  #define ADAGFX_PIN_CLK      13
+
+  // SD Card
+  #define ADAGFX_PIN_SDCS     5     // SD card chip select (if GSLC_SD_EN=1)
+
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 3: Orientation
+  // -----------------------------------------------------------------------------
+
+  // Set Default rotation of the display
+  // - Values 0,1,2,3. Rotation is clockwise
+  #define GSLC_ROTATE     1
+
+  // -----------------------------------------------------------------------------
+  // SECTION 4: Touch Handling
+  // - Documentation for configuring touch support can be found at:
+  //   https://github.com/ImpulseAdventure/GUIslice/wiki/Configure-Touch-Support
+  // -----------------------------------------------------------------------------
+
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+  // SECTION 4A: Update your pin connections here
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+  // Select touch device wiring method by setting one of the following to 1, others to 0
+  #define ADATOUCH_I2C_HW 0  // Touch controller via hardware I2C (uses ADATOUCH_I2C_ADDR)
+  #define ADATOUCH_SPI_HW 1  // Touch controller via hardware SPI (uses ADATOUCH_PIN_CS)
+  #define ADATOUCH_SPI_SW 0  // Touch controller via software SPI [not yet supported]
+
+  // Touch bus & pinout
+  #define ADATOUCH_I2C_ADDR   0x41  // Touch device I2C address (for ADATOUCH_I2C_HW=1)
+  #define ADATOUCH_PIN_CS     6     // Touch device chip select (for ADATOUCH_SPI_HW=1)
+
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+  // SECTION 4B: Update your calibration settings here
+  // - These values should come from the diag_ard_touch_calib sketch output
+  // - Please update the values to the right of ADATOUCH_X/Y_MIN/MAX_* accordingly
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+  // Calibration settings from diag_ard_touch_calib:
+  // DRV_TOUCH_ADA_STMPE610 [240x320]:
+  #define ADATOUCH_X_MIN    150
+  #define ADATOUCH_X_MAX    3800
+  #define ADATOUCH_Y_MIN    130
+  #define ADATOUCH_Y_MAX    4000
+  #define ADATOUCH_REMAP_YX 0    // Some touch controllers may swap X & Y coords
+
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+  // SECTION 4D: Additional touch configuration
+  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+
+  // -----------------------------------------------------------------------------
+  // SECTION 5: Diagnostics
+  // -----------------------------------------------------------------------------
+
+  // Error reporting
+  // - Set DEBUG_ERR to >0 to enable error reporting via the Serial connection
+  // - Enabling DEBUG_ERR increases FLASH memory consumption which may be
+  //   limited on the baseline Arduino (ATmega328P) devices.
+  //   - DEBUG_ERR 0 = Disable all error messaging
+  //   - DEBUG_ERR 1 = Enable critical error messaging (eg. init)
+  //   - DEBUG_ERR 2 = Enable verbose error messaging (eg. bad parameters, etc.)
+  // - For baseline Arduino UNO, recommended to disable this after one has
+  //   confirmed basic operation of the library is successful.
+  #define DEBUG_ERR               1   // 1,2 to enable, 0 to disable
+
+  // Debug initialization message
+  // - By default, GUIslice outputs a message in DEBUG_ERR mode
+  //   to indicate the initialization status, even during success.
+  // - To disable the messages during successful initialization,
+  //   uncomment the following line.
+  //#define INIT_MSG_DISABLE
+
+  // -----------------------------------------------------------------------------
+  // SECTION 6: Optional Features
+  // -----------------------------------------------------------------------------
+
+  // Enable of optional features
+  // - For memory constrained devices such as Arduino, it is best to
+  //   set the following features to 0 (to disable) unless they are
+  //   required.
+  #define GSLC_FEATURE_COMPOUND       1   // Compound elements (eg. XSelNum)
+  #define GSLC_FEATURE_XTEXTBOX_EMBED 1   // XTextbox control with embedded color
+  #define GSLC_FEATURE_INPUT          1   // Keyboard / GPIO input control
+
+  // Enable support for SD card
+  // - Set to 1 to enable, 0 to disable
+  // - Note that the inclusion of the SD library consumes considerable
+  //   RAM and flash memory which could be problematic for Arduino models
+  //   with limited resources.
+  #define GSLC_SD_EN    0
+
+
+  // =============================================================================
+  // SECTION 10: INTERNAL CONFIGURATION
+  // - The following settings should not require modification by users
+  // =============================================================================
+
+  // -----------------------------------------------------------------------------
+  // Touch Handling
+  // -----------------------------------------------------------------------------
+
+  // Define the maximum number of touch events that are handled
+  // per gslc_Update() call. Normally this can be set to 1 but certain
+  // displays may require a greater value (eg. 30) in order to increase
+  // responsiveness of the touch functionality.
+  #define GSLC_TOUCH_MAX_EVT    1
+
+  // -----------------------------------------------------------------------------
+  // Misc
+  // -----------------------------------------------------------------------------
+
+  // Define buffer size for loading images from SD
+  // - A larger buffer will be faster but at the cost of RAM
+  #define GSLC_SD_BUFFPIXEL   50
+
+  // Enable support for graphics clipping (DrvSetClipRect)
+  // - Note that this will impact performance of drawing graphics primitives
+  #define GSLC_CLIP_EN 1
+
+  // Enable for bitmap transparency and definition of color to use
+  #define GSLC_BMP_TRANS_EN     1               // 1 = enabled, 0 = disabled
+  #define GSLC_BMP_TRANS_RGB    0xFF,0x00,0xFF  // RGB color (default: MAGENTA)
+
+  #define GSLC_USE_FLOAT        1   // 1=Use floating pt library, 0=Fixed-point lookup tables
+
+  #define GSLC_DEV_TOUCH ""
+  #define GSLC_USE_PROGMEM      0
+
+  #define GSLC_LOCAL_STR        1   // 1=Use local strings (in element array), 0=External
+  #define GSLC_LOCAL_STR_LEN    30  // Max string length of text elements
+
+  // -----------------------------------------------------------------------------
+  // Debug diagnostic modes
+  // -----------------------------------------------------------------------------
+  // - Uncomment any of the following to enable specific debug modes
+  //#define DBG_LOG           // Enable debugging log output
+  //#define DBG_TOUCH         // Enable debugging of touch-presses
+  //#define DBG_FRAME_RATE    // Enable diagnostic frame rate reporting
+  //#define DBG_DRAW_IMM      // Enable immediate rendering of drawing primitives
+  //#define DBG_DRIVER        // Enable graphics driver debug reporting
+
+
+  // =============================================================================
+
+#ifdef __cplusplus
+}
+#endif // __cplusplus
+#endif // _GUISLICE_CONFIG_ARD_H_