fabutils.h

Go to the documentation of this file.

/*
  Created by Fabrizio Di Vittorio (fdivitto2013@gmail.com) - <http://www.fabgl.com>
  Copyright (c) 2019-2022 Fabrizio Di Vittorio.
  All rights reserved.
 
 
* Please contact fdivitto2013@gmail.com if you need a commercial license.
 
 
* This library and related software is available under GPL v3.
 
  FabGL is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
 
  FabGL is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with FabGL.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 
#pragma once
 
 
#include "freertos/FreeRTOS.h"
#include "freertos/semphr.h"
 
#include <driver/adc.h>
#include <esp_system.h>
#include "sdmmc_cmd.h"
#include "soc/frc_timer_reg.h"
 
 
namespace fabgl {
 
 
// manage IDF versioning
#ifdef ESP_IDF_VERSION
  #define FABGL_ESP_IDF_VERSION_VAL                      ESP_IDF_VERSION_VAL
  #define FABGL_ESP_IDF_VERSION                          ESP_IDF_VERSION
#else
  #define FABGL_ESP_IDF_VERSION_VAL(major, minor, patch) ((major << 16) | (minor << 8) | (patch))
  #define FABGL_ESP_IDF_VERSION                          FABGL_ESP_IDF_VERSION_VAL(0, 0, 0)
#endif
 
 
 
#define GPIO_UNUSED (GPIO_NUM_MAX)
#define GPIO_AUTO   ((gpio_num_t)(GPIO_NUM_MAX + 1))
 
 
// PSRAM_HACK
// ESP32 Revision 1 has following bug: "When the CPU accesses external SRAM through cache, under certain conditions read and write errors occur"
// A workaround is done by the compiler, so whenever PSRAM is enabled the workaround is automatically applied (-mfix-esp32-psram-cache-issue compiler option).
// Unfortunately this workaround reduces performance, even when SRAM is not access, like in VGAXController interrupt handler. This is unacceptable for the interrupt routine.
// In order to confuse the compiler and prevent the workaround from being applied, a "nop" is added between load and store instructions (PSRAM_HACK).
 
#ifdef ARDUINO
  #ifdef BOARD_HAS_PSRAM
    #define FABGL_NEED_PSRAM_DISABLE_HACK
  #endif
#else
  #ifdef CONFIG_SPIRAM_SUPPORT
    #define FABGL_NEED_PSRAM_DISABLE_HACK
  #endif
#endif
 
#ifdef FABGL_NEED_PSRAM_DISABLE_HACK
  #define PSRAM_HACK asm(" nop")
#else
  #define PSRAM_HACK
#endif
 
// ESP32 PSRAM bug workaround (use when the library is NOT compiled with PSRAM hack enabled)
// Place between a write and a read PSRAM operation (write->ASM_MEMW->read), not viceversa
#define ASM_MEMW asm(" MEMW");
 
#define ASM_NOP asm(" NOP");
 
#define PSRAM_WORKAROUND1 asm(" nop;nop;nop;nop");
#define PSRAM_WORKAROUND2 asm(" memw");
 
 
 
 
 
 
#define TORAD(a) ((a) * M_PI / 180.)
 
 
// Integer square root by Halleck's method, with Legalize's speedup
int isqrt (int x);
 
 
template <typename T>
const T & tmax(const T & a, const T & b)
{
  return (a < b) ? b : a;
}
 
 
constexpr auto imax = tmax<int>;
 
 
template <typename T>
const T & tmin(const T & a, const T & b)
{
  return !(b < a) ? a : b;
}
 
 
constexpr auto imin = tmin<int>;
 
 
 
template <typename T>
const T & tclamp(const T & v, const T & lo, const T & hi)
{
  return (v < lo ? lo : (v > hi ? hi : v));
}
 
 
constexpr auto iclamp = tclamp<int>;
 
 
template <typename T>
const T & twrap(const T & v, const T & lo, const T & hi)
{
  return (v < lo ? hi : (v > hi ? lo : v));
}
 
 
template <typename T>
void tswap(T & v1, T & v2)
{
  T t = v1;
  v1 = v2;
  v2 = t;
}
 
 
constexpr auto iswap = tswap<int>;
 
 
template <typename T>
T moveItems(T dest, T src, size_t n)
{
  T pd = dest;
  T ps = src;
  if (pd != ps) {
    if (ps < pd)
      for (pd += n, ps += n; n--;)
        *--pd = *--ps;
    else
      while (n--)
        *pd++ = *ps++;
  }
  return dest;
}
 
 
void rgb222_to_hsv(int R, int G, int B, double * h, double * s, double * v);
 
 
inline uint16_t changeEndiannesWord(uint16_t value)
{
  return ((value & 0xff00) >> 8) | ((value & 0x00ff) << 8);
}
 
 
inline uint32_t changeEndiannesDWord(uint32_t value)
{
  return ((value & 0xff) << 24) | ((value & 0xff00) << 8) | ((value & 0xff0000) >> 8) | ((value & 0xff000000) >> 24);
}
 
 
struct APLLParams {
  uint8_t sdm0;
  uint8_t sdm1;
  uint8_t sdm2;
  uint8_t o_div;
};
 
void APLLCalcParams(double freq, APLLParams * params, uint8_t * a, uint8_t * b, double * out_freq, double * error);
 
int calcI2STimingParams(int sampleRate, int * outA, int * outB, int * outN, int * outM);
 
 
 
 
struct Point {
  int16_t X;    
  int16_t Y;    
  Point() : X(0), Y(0) { }
  Point(int X_, int Y_) : X(X_), Y(Y_) { }
  
  Point add(Point const & p) const { return Point(X + p.X, Y + p.Y); }
  Point sub(Point const & p) const { return Point(X - p.X, Y - p.Y); }
  Point neg() const                { return Point(-X, -Y); }
  bool operator==(Point const & r) { return X == r.X && Y == r.Y; }
  bool operator!=(Point const & r) { return X != r.X || Y != r.Y; }
} __attribute__ ((packed));
 
 
struct Size {
  int16_t width;   
  int16_t height;  
  Size() : width(0), height(0) { }
  Size(int width_, int height_) : width(width_), height(height_) { }
  bool operator==(Size const & r) { return width == r.width && height == r.height; }
  bool operator!=(Size const & r) { return width != r.width || height != r.height; }
} __attribute__ ((packed));
 
 
 
struct Rect {
  int16_t X1;   
  int16_t Y1;   
  int16_t X2;   
  int16_t Y2;   
  Rect() : X1(0), Y1(0), X2(0), Y2(0) { }
  Rect(int X1_, int Y1_, int X2_, int Y2_) : X1(X1_), Y1(Y1_), X2(X2_), Y2(Y2_) { }
  Rect(Rect const & r) { X1 = r.X1; Y1 = r.Y1; X2 = r.X2; Y2 = r.Y2; }
 
  bool operator==(Rect const & r)                { return X1 == r.X1 && Y1 == r.Y1 && X2 == r.X2 && Y2 == r.Y2; }
  bool operator!=(Rect const & r)                { return X1 != r.X1 || Y1 != r.Y1 || X2 != r.X2 || Y2 != r.Y2; }
  Point pos() const                              { return Point(X1, Y1); }
  Size size() const                              { return Size(X2 - X1 + 1, Y2 - Y1 + 1); }
  int width() const                              { return X2 - X1 + 1; }
  int height() const                             { return Y2 - Y1 + 1; }
  Rect translate(int offsetX, int offsetY) const { return Rect(X1 + offsetX, Y1 + offsetY, X2 + offsetX, Y2 + offsetY); }
  Rect translate(Point const & offset) const     { return Rect(X1 + offset.X, Y1 + offset.Y, X2 + offset.X, Y2 + offset.Y); }
  Rect move(Point const & position) const        { return Rect(position.X, position.Y, position.X + width() - 1, position.Y + height() - 1); }
  Rect move(int x, int y) const                  { return Rect(x, y, x + width() - 1, y + height() - 1); }
  Rect shrink(int value) const                   { return Rect(X1 + value, Y1 + value, X2 - value, Y2 - value); }
  Rect hShrink(int value) const                  { return Rect(X1 + value, Y1, X2 - value, Y2); }
  Rect vShrink(int value) const                  { return Rect(X1, Y1 + value, X2, Y2 - value); }
  Rect resize(int width, int height) const       { return Rect(X1, Y1, X1 + width - 1, Y1 + height - 1); }
  Rect resize(Size size) const                   { return Rect(X1, Y1, X1 + size.width - 1, Y1 + size.height - 1); }
  Rect intersection(Rect const & rect) const;
  bool intersects(Rect const & rect) const       { return X1 <= rect.X2 && X2 >= rect.X1 && Y1 <= rect.Y2 && Y2 >= rect.Y1; }
  bool contains(Rect const & rect) const         { return (rect.X1 >= X1) && (rect.Y1 >= Y1) && (rect.X2 <= X2) && (rect.Y2 <= Y2); }
  bool contains(Point const & point) const       { return point.X >= X1 && point.Y >= Y1 && point.X <= X2 && point.Y <= Y2; }
  bool contains(int x, int y) const              { return x >= X1 && y >= Y1 && x <= X2 && y <= Y2; }
  Rect merge(Rect const & rect) const;
} __attribute__ ((packed));
 
 
 
struct MouseButtons {
  uint8_t left   : 1;   
  uint8_t middle : 1;   
  uint8_t right  : 1;   
  MouseButtons() : left(0), middle(0), right(0) { }
};
 
 
 
struct MouseStatus {
  int16_t      X;           
  int16_t      Y;           
  int8_t       wheelDelta;  
  MouseButtons buttons;     
  MouseStatus() : X(0), Y(0), wheelDelta(0) { }
};
 
 
 
#define FONTINFOFLAGS_ITALIC    1
#define FONTINFOFLAGS_UNDERLINE 2
#define FONTINFODLAFS_STRIKEOUT 4
#define FONTINFOFLAGS_VARWIDTH  8
 
 
struct FontInfo {
  uint8_t  pointSize;
  uint8_t  width;   // used only for fixed width fonts (FONTINFOFLAGS_VARWIDTH = 0)
  uint8_t  height;
  uint8_t  ascent;
  uint8_t  inleading;
  uint8_t  exleading;
  uint8_t  flags;
  uint16_t weight;
  uint16_t charset;
  // when FONTINFOFLAGS_VARWIDTH = 0:
  //   data[] contains 256 items each one representing a single character
  // when FONTINFOFLAGS_VARWIDTH = 1:
  //   data[] contains 256 items each one representing a single character. First byte contains the
  //   character width. "chptr" is filled with an array of pointers to the single characters.
  uint8_t const *  data;
  uint32_t const * chptr;  // used only for variable width fonts (FONTINFOFLAGS_VARWIDTH = 1)
  uint16_t codepage;
};
 
 
 
 
// TimeOut
 
 
struct TimeOut {
  TimeOut();
 
  // -1 means "infinite", never times out
  bool expired(int valueMS);
 
private:
  int64_t m_start;
};
 
 
 
// Stack
 
 
template <typename T>
struct StackItem {
  StackItem * next;
  T           item;
  StackItem(StackItem * next_, T const & item_) : next(next_), item(item_) { }
};
 
template <typename T>
class Stack {
public:
  Stack() : m_items(nullptr) { }
  bool isEmpty() { return m_items == nullptr; }
  void push(T const & value) {
    m_items = new StackItem<T>(m_items, value);
  }
  T pop() {
    if (m_items) {
      StackItem<T> * iptr = m_items;
      m_items = iptr->next;
      T r = iptr->item;
      delete iptr;
      return r;
    } else
      return T();
  }
  int count() {
    int r = 0;
    for (auto i = m_items; i; i = i->next)
      ++r;
    return r;
  }
private:
  StackItem<T> * m_items;
};
 
 
 
// Delegate
 
template <typename ...Params>
struct Delegate {
 
  // empty constructor
  Delegate() : m_func(nullptr) {
  }
 
  // denied copy
  Delegate(const Delegate & c) = delete;
 
  // construct from lambda
  template <typename Func>
  Delegate(Func f) : Delegate() {
    *this = f;
  }
 
  ~Delegate() {
    cleanUp();
  }
 
  // assignment operator from Func
  template <typename Func>
  void operator=(Func f) {
    cleanUp();
    m_closure  = [] (void * func, const Params & ...params) -> void { (*(Func *)func)(params...); };
    m_func     = heap_caps_malloc(sizeof(Func), MALLOC_CAP_32BIT | MALLOC_CAP_INTERNAL);
    moveItems<uint32_t*>((uint32_t*)m_func, (uint32_t*)&f, sizeof(Func) / sizeof(uint32_t));
  }
 
  // denied assignment from Delegate
  void operator=(const Delegate&) = delete;
 
  void operator()(const Params & ...params) {
    if (m_func)
      m_closure(m_func, params...);
  }
 
private:
 
  void (*m_closure)(void * func, const Params & ...params);
  void * m_func;
 
  void cleanUp() {
    if (m_func)
      heap_caps_free(m_func);
  }
};
 
 
 
// StringList
 
class StringList {
 
public:
  StringList();
  ~StringList();
  int append(char const * str);
  int appendFmt(const char *format, ...);
  void append(char const * strlist[], int count);
  void appendSepList(char const * strlist, char separator);
  void insert(int index, char const * str);
  void set(int index, char const * str);
  void remove(int index);
  int count()                 { return m_count; }
  char const * get(int index) { return m_items[index]; }
  void clear();
  void takeStrings();
  void select(int index, bool value);
  void deselectAll();
  bool selected(int index);
  int getFirstSelected();
  void copyFrom(StringList const & src);
  void copySelectionMapFrom(StringList const & src);
 
private:
  void checkAllocatedSpace(int requiredItems);
 
  char const * * m_items;
 
  // each 32 bit word can select up to 32 items, one bit per item
  uint32_t *     m_selMap;
 
  // If true (default is false) all strings added (append/insert/set) are copied.
  // Strings will be released when no more used (destructor, clear(), etc...).
  // This flag is permanently switched to True by takeStrings() call.
  bool           m_ownStrings;
 
  uint16_t       m_count;     // actual items
  uint16_t       m_allocated; // allocated items
 
};
 
 
// LightMemoryPool
// Each allocated block starts with a two bytes header (int16_t). Bit 15 is allocation flag (0=free, 1=allocated).
// Bits 14..0 represent the block size.
// The maximum size of a block is 32767 bytes.
// free() just marks the block header as free.
 
class LightMemoryPool {
public:
  LightMemoryPool(int poolSize);
  ~LightMemoryPool();
  void * alloc(int size);
  void free(void * mem) { if (mem) markFree((uint8_t*)mem - m_mem - 2); }
 
  bool memCheck();
  int totFree();      // get total free memory
  int totAllocated(); // get total allocated memory
  int largestFree();
 
private:
 
  void mark(int pos, int16_t size, bool allocated);
  void markFree(int pos) { m_mem[pos + 1] &= 0x7f; }
  int16_t getSize(int pos);
  bool isFree(int pos);
 
  uint8_t * m_mem;
  int       m_poolSize;
};
 
 
 
// FileBrowser
 
 
struct DirItem {
  bool isDir;          
  char const * name;   
};
 
 
enum class DriveType {
  None,    
  SPIFFS,  
  SDCard,  
};
 
 
class FileBrowser {
public:
 
  FileBrowser();
 
  FileBrowser(char const * path);
 
  ~FileBrowser();
 
  bool setDirectory(const char * path);
 
  void changeDirectory(const char * subdir);
 
  bool reload();
 
  char const * directory() { return m_dir; }
 
  int count() { return m_count; }
 
  DirItem const * get(int index) { return m_items + index; }
 
  bool exists(char const * name, bool caseSensitive = true);
 
  bool filePathExists(char const * filepath);
 
  size_t fileSize(char const * name);
 
  bool fileCreationDate(char const * name, int * year, int * month, int * day, int * hour, int * minutes, int * seconds);
 
  bool fileUpdateDate(char const * name, int * year, int * month, int * day, int * hour, int * minutes, int * seconds);
 
  bool fileAccessDate(char const * name, int * year, int * month, int * day, int * hour, int * minutes, int * seconds);
 
  void setSorted(bool value);
 
  void setIncludeHiddenFiles(bool value) { m_includeHiddenFiles = value; }
 
  void makeDirectory(char const * dirname);
 
  void remove(char const * name);
 
  void rename(char const * oldName, char const * newName);
 
  bool truncate(char const * name, size_t size);
 
  char * createTempFilename();
 
  int getFullPath(char const * name, char * outPath = nullptr, int maxlen = 0);
 
  FILE * openFile(char const * filename, char const * mode);
 
  DriveType getCurrentDriveType();
 
  static DriveType getDriveType(char const * path);
 
  static bool format(DriveType driveType, int drive);
 
  static bool mountSDCard(bool formatOnFail, char const * mountPath, size_t maxFiles = 4, int allocationUnitSize = 16 * 1024, int MISO = 16, int MOSI = 17, int CLK = 14, int CS = 13);
 
  static bool remountSDCard();
 
  static bool mountedSDCard() { return s_SDCardMounted; }
 
  static void unmountSDCard();
 
  static bool mountSPIFFS(bool formatOnFail, char const * mountPath, size_t maxFiles = 4);
 
  static bool remountSPIFFS();
 
  static void unmountSPIFFS();
 
  static bool getFSInfo(DriveType driveType, int drive, int64_t * total, int64_t * used);
 
private:
 
  void clear();
  int countDirEntries(int * namesLength);
 
  // SPIFFS static infos
  static bool           s_SPIFFSMounted;
  static char const *   s_SPIFFSMountPath;
  static size_t         s_SPIFFSMaxFiles;
 
  // SD Card static infos
  static bool           s_SDCardMounted;
  static char const *   s_SDCardMountPath;
  static size_t         s_SDCardMaxFiles;
  static int            s_SDCardAllocationUnitSize;
  static int8_t         s_SDCardMISO;
  static int8_t         s_SDCardMOSI;
  static int8_t         s_SDCardCLK;
  static int8_t         s_SDCardCS;
  static sdmmc_card_t * s_SDCard;
 
  char *    m_dir;
  int       m_count;
  DirItem * m_items;
  bool      m_sorted;
  bool      m_includeHiddenFiles;
  char *    m_namesStorage;
};
 
 
 
 
 
 
 
bool clipLine(int & x1, int & y1, int & x2, int & y2, Rect const & clipRect, bool checkOnly);
 
 
void removeRectangle(Stack<Rect> & rects, Rect const & mainRect, Rect const & rectToRemove);
 
 
bool calcParity(uint8_t v);
 
// why these? this is like heap_caps_malloc with MALLOC_CAP_32BIT. Unfortunately
// heap_caps_realloc crashes, so we need this workaround.
void * realloc32(void * ptr, size_t size);
void free32(void * ptr);
 
 
inline gpio_num_t int2gpio(int gpio)
{
  return gpio == -1 ? GPIO_UNUSED : (gpio_num_t)gpio;
}
 
 
// converts 0..9 -> '0'..'9', 10..15 -> 'a'..'f'
inline char digit2hex(int digit)
{
  return digit < 10 ? '0' + digit : 'a' + digit - 10;
}
 
 
// converts '0'..'9' -> 0..9, 'a'..'f' -> 10..15
inline int hex2digit(char hex)
{
  return hex < 'a' ? hex - '0' : hex - 'a' + 10;
}
 
 
// milliseconds to FreeRTOS ticks.
// ms = -1 => maximum delay (portMAX_DELAY)
uint32_t msToTicks(int ms);
 
 
enum class ChipPackage {
  Unknown,
  ESP32D0WDQ6,  
  ESP32D0WDQ5,  
  ESP32D2WDQ5,  
  ESP32PICOD4,  
};
 
 
ChipPackage getChipPackage();
 
inline __attribute__((always_inline)) uint32_t getCycleCount() {
  uint32_t ccount;
  __asm__ __volatile__(
    "esync \n\t"
    "rsr %0, ccount \n\t"
    : "=a" (ccount)
  );
  return ccount;
}
 
void replacePathSep(char * path, char newSep);
 
 
adc1_channel_t ADC1_GPIO2Channel(gpio_num_t gpio);
 
 
void esp_intr_alloc_pinnedToCore(int source, int flags, intr_handler_t handler, void * arg, intr_handle_t * ret_handle, int core);
 
 
// mode: GPIO_MODE_DISABLE,
//       GPIO_MODE_INPUT,
//       GPIO_MODE_OUTPUT,
//       GPIO_MODE_OUTPUT_OD (open drain),
//       GPIO_MODE_INPUT_OUTPUT_OD (open drain),
//       GPIO_MODE_INPUT_OUTPUT
void configureGPIO(gpio_num_t gpio, gpio_mode_t mode);
 
 
uint32_t getApbFrequency();
 
uint32_t getCPUFrequencyMHz();
 
 
 
 
 
// FRC1 timer has 23 bits (8388608 values)
constexpr int FRC1TimerMax = 8388607;
 
 
// prescaler: FRC_TIMER_PRESCALER_1, FRC_TIMER_PRESCALER_16, FRC_TIMER_PRESCALER_256
// 80Mhz / prescaler = timer frequency
inline void FRC1Timer_init(int prescaler)
{
  REG_WRITE(FRC_TIMER_LOAD_REG(0), 0);
  REG_WRITE(FRC_TIMER_CTRL_REG(0), prescaler | FRC_TIMER_ENABLE);
}
 
 
inline uint32_t FRC1Timer()
{
  return FRC1TimerMax - REG_READ(FRC_TIMER_COUNT_REG(0)); // make timer count up
}
 
 
 
// AutoSemaphore
 
struct AutoSemaphore {
  AutoSemaphore(SemaphoreHandle_t mutex) : m_mutex(mutex) { xSemaphoreTake(m_mutex, portMAX_DELAY); }
  ~AutoSemaphore()                                        { xSemaphoreGive(m_mutex); }
private:
  SemaphoreHandle_t m_mutex;
};
 
 
 
// CoreUsage
 
struct CoreUsage {
 
  static int busiestCore()                 { return s_busiestCore; }
  static int quietCore()                   { return s_busiestCore != -1 ? s_busiestCore ^ 1 : -1; }
  static void setBusiestCore(int core)     { s_busiestCore = core; }
 
  private:
    static int s_busiestCore;  // 0 = core 0, 1 = core 1 (default is FABGLIB_VIDEO_CPUINTENSIVE_TASKS_CORE)
};
 
 
 
// VideoMode
 
enum class VideoMode {
  None,     
  VGA,      
  CVBS,     
  I2C,      
  SPI,      
};
 
 
struct CurrentVideoMode {
 
  static VideoMode get()           { return s_videoMode; }
  static void set(VideoMode value) { s_videoMode = value; }
 
  private:
    static VideoMode s_videoMode;
};
 
 
 
 
 
enum VirtualKey {
  VK_NONE,            
  VK_SPACE,           
  VK_0,               
  VK_1,               
  VK_2,               
  VK_3,               
  VK_4,               
  VK_5,               
  VK_6,               
  VK_7,               
  VK_8,               
  VK_9,               
  VK_KP_0,            
  VK_KP_1,            
  VK_KP_2,            
  VK_KP_3,            
  VK_KP_4,            
  VK_KP_5,            
  VK_KP_6,            
  VK_KP_7,            
  VK_KP_8,            
  VK_KP_9,            
  VK_a,               
  VK_b,               
  VK_c,               
  VK_d,               
  VK_e,               
  VK_f,               
  VK_g,               
  VK_h,               
  VK_i,               
  VK_j,               
  VK_k,               
  VK_l,               
  VK_m,               
  VK_n,               
  VK_o,               
  VK_p,               
  VK_q,               
  VK_r,               
  VK_s,               
  VK_t,               
  VK_u,               
  VK_v,               
  VK_w,               
  VK_x,               
  VK_y,               
  VK_z,               
  VK_A,               
  VK_B,               
  VK_C,               
  VK_D,               
  VK_E,               
  VK_F,               
  VK_G,               
  VK_H,               
  VK_I,               
  VK_J,               
  VK_K,               
  VK_L,               
  VK_M,               
  VK_N,               
  VK_O,               
  VK_P,               
  VK_Q,               
  VK_R,               
  VK_S,               
  VK_T,               
  VK_U,               
  VK_V,               
  VK_W,               
  VK_X,               
  VK_Y,               
  VK_Z,               
  VK_GRAVEACCENT,     
  VK_ACUTEACCENT,     
  VK_QUOTE,           
  VK_QUOTEDBL,        
  VK_EQUALS,          
  VK_MINUS,           
  VK_KP_MINUS,        
  VK_PLUS,            
  VK_KP_PLUS,         
  VK_KP_MULTIPLY,     
  VK_ASTERISK,        
  VK_BACKSLASH,       
  VK_KP_DIVIDE,       
  VK_SLASH,           
  VK_KP_PERIOD,       
  VK_PERIOD,          
  VK_COLON,           
  VK_COMMA,           
  VK_SEMICOLON,       
  VK_AMPERSAND,       
  VK_VERTICALBAR,     
  VK_HASH,            
  VK_AT,              
  VK_CARET,           
  VK_DOLLAR,          
  VK_POUND,           
  VK_EURO,            
  VK_PERCENT,         
  VK_EXCLAIM,         
  VK_QUESTION,        
  VK_LEFTBRACE,       
  VK_RIGHTBRACE,      
  VK_LEFTBRACKET,     
  VK_RIGHTBRACKET,    
  VK_LEFTPAREN,       
  VK_RIGHTPAREN,      
  VK_LESS,            
  VK_GREATER,         
  VK_UNDERSCORE,      
  VK_DEGREE,          
  VK_SECTION,         
  VK_TILDE,           
  VK_NEGATION,        
  VK_LSHIFT,          
  VK_RSHIFT,          
  VK_LALT,            
  VK_RALT,            
  VK_LCTRL,           
  VK_RCTRL,           
  VK_LGUI,            
  VK_RGUI,            
  VK_ESCAPE,          
  VK_PRINTSCREEN,     
  VK_SYSREQ,          
  VK_INSERT,          
  VK_KP_INSERT,       
  VK_DELETE,          
  VK_KP_DELETE,       
  VK_BACKSPACE,       
  VK_HOME,            
  VK_KP_HOME,         
  VK_END,             
  VK_KP_END,          
  VK_PAUSE,           
  VK_BREAK,           
  VK_SCROLLLOCK,      
  VK_NUMLOCK,         
  VK_CAPSLOCK,        
  VK_TAB,             
  VK_RETURN,          
  VK_KP_ENTER,        
  VK_APPLICATION,     
  VK_PAGEUP,          
  VK_KP_PAGEUP,       
  VK_PAGEDOWN,        
  VK_KP_PAGEDOWN,     
  VK_UP,              
  VK_KP_UP,           
  VK_DOWN,            
  VK_KP_DOWN,         
  VK_LEFT,            
  VK_KP_LEFT,         
  VK_RIGHT,           
  VK_KP_RIGHT,        
  VK_KP_CENTER,       
  VK_F1,              
  VK_F2,              
  VK_F3,              
  VK_F4,              
  VK_F5,              
  VK_F6,              
  VK_F7,              
  VK_F8,              
  VK_F9,              
  VK_F10,             
  VK_F11,             
  VK_F12,             
  VK_GRAVE_a,         
  VK_GRAVE_e,         
  VK_GRAVE_i,         
  VK_GRAVE_o,         
  VK_GRAVE_u,         
  VK_GRAVE_y,         
  VK_ACUTE_a,         
  VK_ACUTE_e,         
  VK_ACUTE_i,         
  VK_ACUTE_o,         
  VK_ACUTE_u,         
  VK_ACUTE_y,         
  VK_GRAVE_A,             
  VK_GRAVE_E,             
  VK_GRAVE_I,             
  VK_GRAVE_O,             
  VK_GRAVE_U,             
  VK_GRAVE_Y,         
  VK_ACUTE_A,             
  VK_ACUTE_E,             
  VK_ACUTE_I,             
  VK_ACUTE_O,             
  VK_ACUTE_U,             
  VK_ACUTE_Y,         
  VK_UMLAUT_a,        
  VK_UMLAUT_e,        
  VK_UMLAUT_i,        
  VK_UMLAUT_o,        
  VK_UMLAUT_u,        
  VK_UMLAUT_y,        
  VK_UMLAUT_A,        
  VK_UMLAUT_E,        
  VK_UMLAUT_I,        
  VK_UMLAUT_O,        
  VK_UMLAUT_U,        
  VK_UMLAUT_Y,        
  VK_CARET_a,             
  VK_CARET_e,             
  VK_CARET_i,             
  VK_CARET_o,             
  VK_CARET_u,             
  VK_CARET_y,         
  VK_CARET_A,             
  VK_CARET_E,             
  VK_CARET_I,             
  VK_CARET_O,             
  VK_CARET_U,             
  VK_CARET_Y,         
  VK_CEDILLA_c,       
  VK_CEDILLA_C,       
  VK_TILDE_a,         
  VK_TILDE_o,         
  VK_TILDE_n,             
  VK_TILDE_A,         
  VK_TILDE_O,         
  VK_TILDE_N,             
  VK_UPPER_a,             
  VK_ESZETT,          
  VK_EXCLAIM_INV,     
  VK_QUESTION_INV,    
  VK_INTERPUNCT,        
  VK_DIAERESIS,       
  VK_SQUARE,          
  VK_CURRENCY,        
  VK_MU,              
  VK_aelig,           
  VK_oslash,          
  VK_aring,           
  VK_AELIG,           
  VK_OSLASH,          
  VK_ARING,           
  // Japanese layout support
  VK_YEN,
  VK_MUHENKAN,
  VK_HENKAN,
  VK_KATAKANA_HIRAGANA_ROMAJI,
  VK_HANKAKU_ZENKAKU_KANJI,
  VK_SHIFT_0,
 
  VK_ASCII,           
  VK_LAST,            // marks the last virtual key
 
};
 
 
struct VirtualKeyItem {
  VirtualKey vk;              
  uint8_t    down;            
  uint8_t    scancode[8];     
  uint8_t    ASCII;           
  uint8_t    CTRL       : 1;  
  uint8_t    LALT       : 1;  
  uint8_t    RALT       : 1;  
  uint8_t    SHIFT      : 1;  
  uint8_t    GUI        : 1;  
  uint8_t    CAPSLOCK   : 1;  
  uint8_t    NUMLOCK    : 1;  
  uint8_t    SCROLLLOCK : 1;  
};
 
 
 
// Virtual keys helpers
 
inline bool isSHIFT(VirtualKey value)
{
  return value == VK_LSHIFT || value == VK_RSHIFT;
}
 
 
inline bool isALT(VirtualKey value)
{
  return value == VK_LALT || value == VK_RALT;
}
 
 
inline bool isCTRL(VirtualKey value)
{
  return value == VK_LCTRL || value == VK_RCTRL;
}
 
 
inline bool isGUI(VirtualKey value)
{
  return value == VK_LGUI || value == VK_RGUI;  
}
 
 
 
// ASCII control characters
 
#define ASCII_NUL   0x00   // Null
#define ASCII_SOH   0x01   // Start of Heading
#define ASCII_CTRLA 0x01   // CTRL-A
#define ASCII_STX   0x02   // Start of Text
#define ASCII_CTRLB 0x02   // CTRL-B
#define ASCII_ETX   0x03   // End Of Text
#define ASCII_CTRLC 0x03   // CTRL-C
#define ASCII_EOT   0x04   // End Of Transmission
#define ASCII_CTRLD 0x04   // CTRL-D
#define ASCII_ENQ   0x05   // Enquiry
#define ASCII_CTRLE 0x05   // CTRL-E
#define ASCII_ACK   0x06   // Acknowledge
#define ASCII_CTRLF 0x06   // CTRL-F
#define ASCII_BEL   0x07   // Bell
#define ASCII_CTRLG 0x07   // CTRL-G
#define ASCII_BS    0x08   // Backspace
#define ASCII_CTRLH 0x08   // CTRL-H
#define ASCII_HT    0x09   // Horizontal Tab
#define ASCII_TAB   0x09   // Horizontal Tab
#define ASCII_CTRLI 0x09   // CTRL-I
#define ASCII_LF    0x0A   // Line Feed
#define ASCII_CTRLJ 0x0A   // CTRL-J
#define ASCII_VT    0x0B   // Vertical Tab
#define ASCII_CTRLK 0x0B   // CTRL-K
#define ASCII_FF    0x0C   // Form Feed
#define ASCII_CTRLL 0x0C   // CTRL-L
#define ASCII_CR    0x0D   // Carriage Return
#define ASCII_CTRLM 0x0D   // CTRL-M
#define ASCII_SO    0x0E   // Shift Out
#define ASCII_CTRLN 0x0E   // CTRL-N
#define ASCII_SI    0x0F   // Shift In
#define ASCII_CTRLO 0x0F   // CTRL-O
#define ASCII_DLE   0x10   // Data Link Escape
#define ASCII_CTRLP 0x10   // CTRL-P
#define ASCII_DC1   0x11   // Device Control 1
#define ASCII_CTRLQ 0x11   // CTRL-Q
#define ASCII_XON   0x11   // Transmission On
#define ASCII_DC2   0x12   // Device Control 2
#define ASCII_CTRLR 0x12   // CTRL-R
#define ASCII_DC3   0x13   // Device Control 3
#define ASCII_XOFF  0x13   // Transmission Off
#define ASCII_CTRLS 0x13   // CTRL-S
#define ASCII_DC4   0x14   // Device Control 4
#define ASCII_CTRLT 0x14   // CTRL-T
#define ASCII_NAK   0x15   // Negative Acknowledge
#define ASCII_CTRLU 0x15   // CTRL-U
#define ASCII_SYN   0x16   // Synchronous Idle
#define ASCII_CTRLV 0x16   // CTRL-V
#define ASCII_ETB   0x17   // End-of-Transmission-Block
#define ASCII_CTRLW 0x17   // CTRL-W
#define ASCII_CAN   0x18   // Cancel
#define ASCII_CTRLX 0x18   // CTRL-X
#define ASCII_EM    0x19   // End of Medium
#define ASCII_CTRLY 0x19   // CTRL-Y
#define ASCII_SUB   0x1A   // Substitute
#define ASCII_CTRLZ 0x1A   // CTRL-Z
#define ASCII_ESC   0x1B   // Escape
#define ASCII_FS    0x1C   // File Separator
#define ASCII_GS    0x1D   // Group Separator
#define ASCII_RS    0x1E   // Record Separator
#define ASCII_US    0x1F   // Unit Separator
#define ASCII_SPC   0x20   // Space
#define ASCII_DEL   0x7F   // Delete
 
 
} // end of namespace