dumbdisplay.h

/*
 
============================
 
if want to disable int parameter encoding, define DD_DISABLE_PARAM_ENCODING before including dumbdisplay.h, like
 
#define DD_DISABLE_PARAM_ENCODING
 
=============================
 
*/
 
#ifdef DD_DISABLE_PARAM_ENCODING
  #pragma "message ***** DD_DISABLE_PARAM_ENCODING *****"
#endif
 
 
 
 
#ifndef dumbdisplay_h
#define dumbdisplay_h
 
 
// not used???
// #ifdef DD_4_ESP32
// #include <esp_spp_api.h>
// #include "HardwareSerial.h"
// #endif
 
 
#define DUMBDISPLAY_BAUD  115200
#define DD_SERIAL_BAUD    DUMBDISPLAY_BAUD
#define DD_WIFI_PORT      10201
 
 
#define DD_DEF_SEND_BUFFER_SIZE 128
#define DD_DEF_IDLE_TIMEOUT     5000
#define DD_DEF_TUNNEL_TIMEOUT   150000
 
 
#include "_dd_util.h"
 
 
#define DD_CONDENSE_COMMAND
 
 
#define DD_HEX_COLOR(color) ("#" + String(color, 16))
 
 
#ifdef DD_CONDENSE_COMMAND
  #define DD_INT_COLOR(color) ("+" + DDIntEncoder(color).encoded())
  #if defined(ARDUINO_AVR_UNO) || defined(ARDUINO_AVR_NANO) ||  defined(DD_DISABLE_PARAM_ENCODING)
    #define DD_RGB_COLOR(r, g, b) (String(r) + "-" + String(g) + "-" + String(b))
  #else
    #define DD_RGB_COLOR(r, g, b) ("+" + DDIntEncoder(0xffffff & ((((((int32_t) (r)) << 8) + ((int32_t) (g))) << 8) + ((int32_t) (b)))).encoded())
  #endif
  // #if defined(ARDUINO_AVR_UNO) || defined(ARDUINO_AVR_NANO)
  //   #define DD_RGB_COLOR(r, g, b) (String(r) + "-" + String(g) + "-" + String(b))
  //   //#define DD_RGB_COLOR(r, g, b) (String(r<0?0:(r>255?255:r)) + "-" + String(g<0?0:(g>255?255:g)) + "-" + String(b<0?0:(b>255?255:b)))
  // #else
  //   #if defined(DD_DISABLE_PARAM_ENCODING)
  //     #define DD_RGB_COLOR(r, g, b) ("#" + String(0xffffff & ((((((int32_t) (r)) << 8) + ((int32_t) (g))) << 8) + ((int32_t) (b))), 16))
  //   #else  
  //     #define DD_RGB_COLOR(r, g, b) ("+" + DDIntEncoder(0xffffff & ((((((int32_t) (r)) << 8) + ((int32_t) (g))) << 8) + ((int32_t) (b)))).encoded())
  //   #endif
  // #endif
#else
  #define DD_RGB_COLOR(r, g, b) (String(r<0?0:(r>255?255:r)) + "-" + String(g<0?0:(g>255?255:g)) + "-" + String(b<0?0:(b>255?255:b)))
  #define DD_INT_COLOR(color) ("+" + String(color))
#endif
 
 
 
#define DD_AP_HORI "H(*)"
#define DD_AP_VERT "V(*)"
#define DD_AP_STACK "S(*)"
#define DD_AP_HORI_2(id1, id2) ("H(" + id1 + "+" + id2 + ")")
#define DD_AP_VERT_2(id1, id2) ("V(" + id1 + "+" + id2 + ")")
#define DD_AP_STACK_2(id1, id2) ("S(" + id1 + "+" + id2 + ")")
#define DD_AP_HORI_3(id1, id2, id3) ("H(" + id1 + "+" + id2 + "+" + id3 + ")")
#define DD_AP_VERT_3(id1, id2, id3) ("V(" + id1 + "+" + id2 + "+" + id3 + ")")
#define DD_AP_STACK_3(id1, id2, id3) ("S(" + id1 + "+" + id2 + "+" + id3 + ")")
#define DD_AP_HORI_4(id1, id2, id3, id4) ("H(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + ")")
#define DD_AP_VERT_4(id1, id2, id3, id4) ("V(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + ")")
#define DD_AP_STACK_4(id1, id2, id3, id4) ("S(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + ")")
#define DD_AP_HORI_5(id1, id2, id3, id4, id5) ("H(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + "+" + id5 + ")")
#define DD_AP_VERT_5(id1, id2, id3, id4, id5) ("V(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + "+" + id5 + ")")
#define DD_AP_STACK_5(id1, id2, id3, id4, id5) ("S(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + "+" + id5 + ")")
#define DD_AP_HORI_6(id1, id2, id3, id4, id5, id6) ("H(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + "+" + id5 + ")" + "+" + id6 + ")")
#define DD_AP_VERT_6(id1, id2, id3, id4, id5, id6) ("V(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + "+" + id5 + ")" + "+" + id6 + ")")
#define DD_AP_STACK_6(id1, id2, id3, id4, id5, id6) ("S(" + id1 + "+" + id2 + "+" + id3 + "+" + id4 + "+" + id5 + ")" + "+" + id6 + ")")
 
#define DD_AP_PADDING(lp, tp, rp, bp, id) ("S/" + String(lp) + "-" + String(tp) + "-" + String(rp) + "-" + String(bp) + "(" + id + ")") 
 
#define DD_AP_SPACER(w, h) (String("<") + String(w) + "x" + String(h) + String(">")) 
 
#define DD_PROGRAM_SPACE_COMPRESS_BA_0 '!'
#define DD_COMPRESS_BA_0 '0'
 
#ifndef DD_TUNNEL_DEF_BUFFER_SIZE
  #if defined(ARDUINO_AVR_UNO) || defined(ARDUINO_AVR_NANO)
    #define DD_TUNNEL_DEF_BUFFER_SIZE 2
  #else
    #define DD_TUNNEL_DEF_BUFFER_SIZE 4
  #endif
#endif
#if DD_TUNNEL_DEF_BUFFER_SIZE < 2
  #error "DD_TUNNEL_DEF_BUFFER_SIZE must be at least 2"
#endif 
 
 
#define DDIO_USE_DD_SERIAL
 
#include "_dd_serial.h"
#ifdef DDIO_USE_DD_SERIAL
  extern DDSerial* _The_DD_Serial;
#endif
 
#include "_dd_io.h"
#include "_dd_feedback.h"
#include "_dd_colors.h"
 
 
class DDLayer;
 
typedef void (*DDFeedbackHandler)(DDLayer* pLayer, DDFeedbackType type, const DDFeedback& feedback);
 
 
const int8_t DD_OBJECT_TYPE_LAYER  = 0;
const int8_t DD_OBJECT_TYPE_TUNNEL = 1;
 
 
struct DDObject {
    int8_t objectType;
#ifdef DD_NO_CUSTOM_DATA
  #warning ??? DD_NO_CUSTOM_DATA set ???
#else
    String customData;
#endif
public:
    // since 20230601
    virtual ~DDObject() {}
};
 
 
class DDLayer: public DDObject {
  public:
    void border(float size, const String& color, const String& shape = "flat", float extraSize = 0);
    void noBorder();
    void padding(float size);
    void padding(float left, float top, float right, float bottom);
    void noPadding();
    void margin(float size);
    void margin(float left, float top, float right, float bottom);
    void noMargin();
    void backgroundColor(const String& color, int opacity = 100);
    void noBackgroundColor();
    void visible(bool visible);
    void transparent(bool transparent);
    void disabled(bool disabled = true);
    void opacity(int opacity);
    void alpha(int alpha);
    void blend(const String& color, int alpha = 255, const String& mode = "darken");
    void noblend();
    void clear();
    void flash();
    void flashArea(int x, int y);
    void explicitFeedback(int16_t x = 0, int16_t y = 0, const String& text = "", DDFeedbackType type = CLICK, const String& option = "");
    inline const String& getLayerId() const { return layerId; }
    void setFeedbackHandler(DDFeedbackHandler handler, const String& autoFeedbackMethod = "", const String& allowFeedbackTypes = "");
    void enableFeedback(const String& autoFeedbackMethod = "", const String& allowFeedbackTypes = "");
    void disableFeedback();
    const DDFeedback* getFeedback();
    void debugOnly(int i);
  public:
#ifndef DD_NO_FEEDBACK
    inline DDFeedbackManager* getFeedbackManager() const { return pFeedbackManager; }
    inline DDFeedbackHandler getFeedbackHandler() const { return feedbackHandler; }
#endif    
  protected:
    DDLayer(int8_t layerId);
  public:
    // made virtual since 20230601
    virtual ~DDLayer();
  protected:
    void _enableFeedback();
  protected:
    String layerId;  
#ifndef DD_NO_FEEDBACK
    // either feedbackManager or feedbackHandler is used
    DDFeedbackManager *pFeedbackManager;
    DDFeedbackHandler feedbackHandler;
#endif    
};
 
#define DD_DEF_LAYER_LEVEL_ID "_"
 
class MultiLevelDDLayer: public DDLayer {
  public:
    void addLevel(const String& levelId, float width, float height, bool switchToIt = false);
    inline void addLevel(const String& levelId, bool switchToIt = false) {
      addLevel(levelId, 0, 0, switchToIt);
    }
    void addTopLevel(const String& levelId, float width = 0, float height = 0, bool switchToIt = false);
    inline void addTopLevel(const String& levelId, bool switchToIt) {
      addTopLevel(levelId, 0, 0, switchToIt);
    }
    void switchLevel(const String& levelId, bool addIfMissing = true);
    void pushLevel(); 
    void pushLevelAndSwitchTo(const String& switchTolevelId, bool addIfMissing = true); 
    void popLevel();
    void levelOpacity(int opacity);
    void levelTransparent(bool transparent);
    void setLevelAnchor(float x, float y, long reachInMillis = 0);
    void moveLevelAnchorBy(float byX, float byY, long reachInMillis = 0);
    void registerLevelBackground(const String& backgroundId, const String& backgroundImageName, const String& drawBackgroundOptions = "");
    void setLevelBackground(const String& backgroundId, const String& backgroundImageName = "", const String& drawBackgroundOptions = "");
    void setLevelNoBackground();
    void animateLevelBackground(int fps, bool reset = true, const String& options = "");
    void stopAnimateLevelBackground(bool reset = true);
    void reorderLevel(const String& levelId, const String& how);
    void exportLevelsAsImage(const String& imageFileName, bool cacheItNotSave = false);
    void deleteLevel(const String& levelId);
  protected:
    MultiLevelDDLayer(int8_t layerId): DDLayer(layerId) {}
};
 
 
 
enum MbArrow { North, NorthEast, East, SouthEast, South, SouthWest, West, NorthWest };
enum MbIcon { Heart, SmallHeart, Yes, No, Happy, Sad, Confused, Angry, Asleep, Surprised,
              Silly, Fabulous, Meh, TShirt, Rollerskate, Duck, House, Tortoise, Butterfly, StickFigure,
              Ghost, Sword, Giraffe, Skull, Umbrella, Snake, Rabbit, Cow, QuarterNote, EigthNote,
              Pitchfork, Target, Triangle, LeftTriangle, Chessboard, Diamond, SmallDiamond, Square, SmallSquare, Scissors };
 
class MbImage {
  public:
    MbImage(int8_t imageId) {
      this->imageId = String(imageId);
    }
    inline const String& getImageId() const { return this->imageId; }  
  private:
    String imageId;
};
 
class MbDDLayer: public DDLayer {
  public:
    MbDDLayer(int8_t layerId): DDLayer(layerId) {
    }
    void showIcon(MbIcon icon);
    void showArrow(MbArrow arrow);
    void showNumber(int num);
    void showString(const String& str);
    void plot(int x, int y);
    void unplot(int x, int y);
    void toggle(int x, int y);
    void showLeds(const String& ledPattern);
    void ledColor(const String& color);
    MbImage* createImage(const String& ledPattern);
    void releaseImage(MbImage *pImage);
    void showImage(MbImage *pImage, int xOff);
    void scrollImage(MbImage *pImage, int xOff, long interval);
};
 
class TurtleDDLayer: public MultiLevelDDLayer {
  public:
    TurtleDDLayer(int8_t layerId): MultiLevelDDLayer(layerId) {
    }
    void forward(int distance, bool withPen = true);
    void backward(int distance, bool withPen = true);
    void leftTurn(int angle);
    void rightTurn(int angle);
    void home(bool withPen = true);
    void goTo(int x, int y, bool withPen = true);
    void goBy(int byX, int byY, bool withPen = true);
    void setHeading(int angle);
    void penSize(int size);
    void penColor(const String& color);
    void fillColor(const String& color);
    void noFillColor();
    void penFilled(bool filled);
    void setTextSize(int size);
    void setTextFont(const String& fontName = "", int textSize = 0);
    void penUp();
    void penDown();
    void beginFill();
    void endFill();
    void dot(int size, const String& color);
    void circle(int radius, bool centered = false);
    void oval(int width, int height, bool centered = false);
    void arc(int width, int height, int startAngle, int sweepAngle, bool centered = false);
    void triangle(int side1, int angle, int side2);
    void isoscelesTriangle(int side, int angle);
    void rectangle(int width, int height, bool centered = false);
    void polygon(int side, int vertexCount);
    void centeredPolygon(int radius, int vertexCount, bool inside = false);
    void write(const String& text, bool draw = false);
};
 
class LedGridDDLayer: public DDLayer {
  public:
    LedGridDDLayer(int8_t layerId): DDLayer(layerId) {
    }
    void turnOn(int x = 0, int y = 0);
    void turnOff(int x = 0, int y = 0);
    void toggle(int x = 0, int y = 0);
    void turnOnEx(int x = 0, int y = 0, const String& onColor = "");
    void bitwise(unsigned int bits, int y = 0, bool reverse = false);
    void bitwise2(unsigned int bits_0, unsigned int bits_1, int y = 0, bool reverse = false);
    void bitwise3(unsigned int bits_0, unsigned int bits_1, unsigned int bits_2, int y = 0, bool reverse = false);
    void bitwise4(unsigned int bits_0, unsigned int bits_1, unsigned int bits_2, unsigned int bits_3, int y = 0, bool reverse = false);
    void horizontalBar(int count, bool rightToLeft = false);
    void verticalBar(int count, bool bottomToTop = true);
    void horizontalBarEx(int count, int startX = 0, const String& color = "");
    void verticalBarEx(int count, int startY = 0, const String& color = "");
    void onColor(const String& color);
    void offColor(const String& color);
    void noOffColor();
};
 
class LcdDDLayer: public DDLayer {
  public:
    LcdDDLayer(int8_t layerId): DDLayer(layerId) {
    }
    void print(const String& text);
    void home();
    void setCursor(int x, int y);
    void cursor();
    void noCursor();
    void autoscroll();
    void noAutoscroll();
    void display();
    void noDisplay();
    void scrollDisplayLeft();
    void scrollDisplayRight();
    void writeLine(const String& text, int y = 0, const String& align = "L");
    void writeRightAlignedLine(const String& text, int y = 0);
    void writeCenteredLine(const String& text, int y = 0);
    void pixelColor(const String &color);
    void bgPixelColor(const String &color);
    void noBgPixelColor();
};
 
class SelectionDDLayer: public DDLayer {
  public:
    SelectionDDLayer(int8_t layerId): DDLayer(layerId) {
      _enableFeedback();
    }
    void pixelColor(const String &color);
    void text(const String& text, int y = 0, int horiSelectionIdx = 0, int vertSelectionIdx = 0, const String& align = "L");
    void textCentered(const String& text, int y = 0, int horiSelectionIdx = 0, int vertSelectionIdx = 0);
    void textRightAligned(const String& text, int y = 0, int horiSelectionIdx = 0, int vertSelectionIdx = 0);
    void unselectedText(const String& text, int y = 0, int horiSelectionIdx = 0, int vertSelectionIdx = 0, const String& align = "L");
    void unselectedTextCentered(const String& text, int y = 0, int horiSelectionIdx = 0, int vertSelectionIdx = 0);
   void unselectedTextRightAligned(const String& text, int y = 0, int horiSelectionIdx = 0, int vertSelectionIdx = 0);
    void select(int horiSelectionIdx = 0, int vertSelectionIdx = 0, bool deselectTheOthers = true);
    void deselect(int horiSelectionIdx = 0, int vertSelectionIdx = 0, bool selectTheOthers = false);
    void setSelected(bool selected, int horiSelectionIdx = 0, int vertSelectionIdx = 0) {
      if (selected) {
        select(horiSelectionIdx, vertSelectionIdx, false);
      } else {
        deselect(horiSelectionIdx, vertSelectionIdx, false);
      }
    }
    void selectAll();
    void deselectAll();
    void selected(bool selected, int horiSelectionIdx = 0, int vertSelectionIdx = 0, bool reverseTheOthers = false);
    void highlightBorder(bool forSelected, const String& borderColor = "", const String& borderShape = "");
 };
 
class GraphicalDDLayer: public MultiLevelDDLayer {
  public:
    GraphicalDDLayer(int8_t layerId): MultiLevelDDLayer(layerId) {
    }
    void setRotation(int8_t rotationType);
    void setCursor(int x, int y);
    void moveCursorBy(int byX, int byY);
    void setTextColor(const String& color, const String& bgColor = "");
    void setTextSize(int size);
    void setTextFont(const String& fontName);
    void setTextFont();
    inline void setTextFont(const String& fontName, int textSize) {
      setTextFont(fontName);
      if (textSize > 0) {
        setTextSize(textSize);
      }
    }
    void setTextWrap(bool wrapOn);
    void fillScreen(const String& color);
    void print(const String& text);
    void println(const String& text = "");
    void drawChar(int x, int y, char c, const String& color = "", const String& bgColor = "", int size = 0);
    void drawStr(int x, int y, const String& string, const String& color = "", const String& bgColor = "", int size = 0);
    void drawTextLine(const String& text, int y, const String& align = "L", const String& color = "", const String& bgColor = "", int size = 0);
    void drawPixel(int x, int y, const String& color = "");
    void drawLine(int x1, int y1, int x2, int y2, const String& color = "");
    void drawCircle(int x, int y, int r, const String& color = "", bool filled = false);
    // draw filled circle
    inline void fillCircle(int x, int y, int r, const String& color = "") {
      drawCircle(x, y, r, color, true);
    }
    void drawTriangle(int x1, int y1, int x2, int y2, int x3, int y3, const String& color = "", bool filled = false);
    inline void fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3, const String& color = "") {
      drawTriangle(x1, y1, x2, y2, x3, y3, color, true);
    }
    void drawRect(int x, int y, int w, int h, const String& color = "", bool filled = false);
    inline void fillRect(int x, int y, int w, int h, const String& color = "") {
      drawRect(x, y, w, h, color, true);
    }
    void drawRoundRect(int x, int y, int w, int h, int r, const String& color = "", bool filled = false);
    inline void fillRoundRect(int x, int y, int w, int h, int r, const String& color = "") {
      drawRoundRect(x, y, w, h, r, color, true);
    }
    void drawOval(int x, int y, int w, int h, const String& color = "", bool filled = false);
    inline void fillOval(int x, int y, int w, int h, const String& color = "") {
      drawOval(x, y, w, h, color, true);
    }
    void drawArc(int x, int y, int w, int h, int startAngle, int sweepAngle, bool useCenter, const String& color = "", bool filled = false);
    inline void fillArc(int x, int y, int w, int h, int startAngle, int sweepAngle, bool useCenter, const String& color = "") {
      drawArc(x, y, w, h, startAngle, sweepAngle, useCenter, color, true);
    }
    void forward(int distance);
    void leftTurn(int angle);
    void rightTurn(int angle);
    void setHeading(int angle);
    void penSize(int size);
    void penColor(const String& color);
    void fillColor(const String& color);
    void noFillColor();
    void circle(int radius, bool centered = false);
    void oval(int width, int height, bool centered = false);
    void arc(int width, int height, int startAngle, int sweepAngle, bool centered = false);
    void triangle(int side1, int angle, int side2);
    void isoscelesTriangle(int side, int angle);
    void rectangle(int width, int height, bool centered = false);
    void polygon(int side, int vertexCount);
    void centeredPolygon(int radius, int vertexCount, bool inside = false);
    void write(const String& text, bool draw = false);
    void loadImageFile(const String& imageFileName, int w = 0, int h = 0, const String& asImageFileName = "");
    inline void loadImageFileScaled(const String& imageFileName, int w, int h, const String& asImageFileName) {
      loadImageFile(imageFileName, w, h, asImageFileName);
    }
    void loadImageFileCropped(const String& imageFileName, int x, int y, int w, int h, const String& asImageFileName, int scaleW = 0, int scaleH = 0);
    void unloadImageFile(const String& imageFileName);
    void unloadAllImageFiles();
    void drawImageFile(const String& imageFileName, int x = 0, int y = 0, int w = 0, int h = 0, const String& options = "");
    inline void drawImageFile(const String& imageFileName, const String& options) {
      drawImageFile(imageFileName, 0, 0, 0, 0, options);
    }
    inline void drawImageFileScaled(const String& imageFileName, int w, int h, const String& options = "") {
      drawImageFile(imageFileName, 0, 0, w, h, options);
    }
    void drawImageFileFit(const String& imageFileName, int x = 0, int y = 0, int w = 0, int h = 0, const String& options = "");
    inline void drawImageFileFit(const String& imageFileName, const String& options) {
      drawImageFileFit(imageFileName, 0, 0, 0, 0, options);
    }
    void cacheImage(const String& imageName, const uint8_t *bytes, int byteCount, char compressionMethod = 0);
    void cacheImageWithTS(const String& imageName, const uint8_t *bytes, int byteCount, long imageTimestamp, char compressionMethod = 0);
    void cachePixelImage(const String& imageName, const uint8_t *bytes, int width, int height, const String& color = "", char compressionMethod = 0);
    void cachePixelImage16(const String& imageName, const uint16_t *data, int width, int height, const String& options = "", char compressMethod = 0);
    void cachePixelImageGS(const String& imageName, const uint8_t *data, int width, int height, const String& options = "", char compressMethod = 0);
    void saveCachedImageFile(const String& imageName, const String& asImageName = "");
#ifdef ESP32
    void saveCachedImageFileWithTS(const String& imageName, const String& asImageName, int64_t imageTimestamp);
#endif
    void saveCachedImageFileAsync(const String& imageName, const String& asImageName = "");
#ifdef ESP32
    void saveCachedImageFileWithTSAsync(const String& imageName, const String& asImageName, int64_t imageTimestamp);
#endif
    void saveCachedImageFiles(const String& stitchAsImageName = "");
};
 
 
class SevenSegmentRowDDLayer: public DDLayer {
  public:
    SevenSegmentRowDDLayer(int8_t layerId): DDLayer(layerId) {
    }
    void segmentColor(const String& color);
    void resetSegmentOffColor(const String& color);
    void resetSegmentOffNoColor();
    void turnOn(const String& segments, int digitIdx = 0);
    void turnOff(const String& segments, int digitIdx = 0);
    void setOn(const String& segments = "", int digitIdx = 0);
    void showDigit(int digit, int digitIdx = 0);
    void showNumber(float number, const String& padding = " ");
    void showHexNumber(int16_t number);
    void showFormatted(const String& formatted, bool completeReplace = true, int startIdx = 0);
};
 
 
class JoystickDDLayer: public DDLayer {
  public:
    JoystickDDLayer(int8_t layerId): DDLayer(layerId) {
      _enableFeedback();
    }
    void autoRecenter(bool autoRecenter = true);
    void colors(const String& stickColor, const String& stickOutlineColor, const String& socketColor = "", const String& socketOutlineColor = "");
    void moveToPos(int16_t x, int16_t y, bool sendFeedback = false);
    void moveToCenter(bool sendFeedback = false);
    void valueRange(int16_t minValue, int16_t maxValue, int valueStep = 1, bool sendFeedback = false);
    void snappy(bool snappy = true);
    void showValue(bool show = true, const String& color = "");
};
 
class PlotterDDLayer: public DDLayer {
  public:
    PlotterDDLayer(int8_t layerId): DDLayer(layerId) {
    }
    void label(const String& key, const String& lab);
    inline void label(const String& lab) { label("", lab); }
    void set(const String& key, float value);  
    inline void set(float value) { set("", value); }  
    void set(const String& key1, float value1, const String& key2, float value2);  
    void set(const String& key1, float value1, const String& key2, float value2, const String& key3, float value3);  
    void set(const String& key1, float value1, const String& key2, float value2, const String& key3, float value3, const String& key4, float value4);  
};
 
 
class TomTomMapDDLayer: public DDLayer {
  public:
    TomTomMapDDLayer(int8_t layerId): DDLayer(layerId) {
    }
    void goTo(float latitude, float longitude, const String& label = "");
    void zoomTo(float latitude, float longitude, float zoomLevel = 15.0, const String& label = "");
    void zoom(float zoomLevel);
};
 
 
class TerminalDDLayer: public DDLayer {
  public:
    TerminalDDLayer(int8_t layerId): DDLayer(layerId) {
    }
    void print(const String& val);
    void println(const String& val);
    inline void print(int intVal) { 
      String val(intVal);
      print(val);
    }
    inline void println(int intVal) { 
      String val(intVal);
      print(val);
    }
    inline void print(float floatVal) { 
      String val(floatVal);
      print(val);
    }
    inline void println(float floatVal) { 
      String val(floatVal);
      print(val);
    }
    inline void println() {
      println(""); 
    }
};
 
class WebViewDDLayer: public DDLayer {
  public:
    WebViewDDLayer(int8_t layerId): DDLayer(layerId) {
      _enableFeedback();
    }
    void loadUrl(const String& url);
    void loadHtml(const String& html);
    void execJs(const String& js);
};
 
 
class DumbDisplayWindowDDLayer: public DDLayer {
  public:
    DumbDisplayWindowDDLayer(int8_t layerId): DDLayer(layerId) {
    }
    void connect(const String& deviceType, const String& deviceName, const String& deviceAddress);
    void disconnect();
};
 
class RtspClientDDLayer: public DDLayer {
  public:
    RtspClientDDLayer(int8_t layerId): DDLayer(layerId) {}
    void start(const String& url);
    void stop();
};
 
 
 
 
 
class DDTunnelEndpoint {
  public:
    DDTunnelEndpoint(const String& endPoint) {
      this->endPoint = endPoint;
      this->headers = "";
      this->params = "";
    }
    void resetEndpoint(const String& endPoint) {
      this->endPoint = endPoint;
    }
    void resetSoundAttachment(const String& soundName) {
      if (soundName == "") {
        this->attachmentId = "";
      } else {
        this->attachmentId = "sound:" + soundName;
      }
    }
    void resetHeaders() {
      this->headers = "";
    }
    void resetParams() {
      this->params = "";
    }
    void addParam(const String& param) {
      if (true) {
        if (this->params.length() > 0) {
          this->params.concat(',');
        }
        this->params.concat(param);
      } else {
        if (this->params == "") {
          this->params = param;
        } else {
          this->params = this->params + "," + param;
        }
      }
    }
    void addNamedParam(const String& paramName, const String& paramValue) {
      addParam(paramName + "=" + paramValue);
    }
    void addHeader(const String& headerKey, const String& headerValue) {
      if (true) {
        if (this->headers.length() > 0) {
          this->headers.concat('|');
        }
        this->headers.concat(headerKey);
        this->headers.concat(":");
        this->headers.concat(headerValue);
      } else {
        if (this->headers == "") {
          this->headers = String(headerKey) + ":" + headerValue;
        } else {
          this->headers = this->headers + "|" + headerKey + ":" + headerValue;
        }
      }
    }
  public:
    String endPoint;
    String headers;
    String attachmentId;
    String params;
};
 
 
class DDTunnel: public DDObject {
  public:
    DDTunnel(const String& type, int8_t tunnelId, const String& params, const String& endPoint/*, bool connectNow*/);
    void afterConstruct(bool connectNow);
    virtual ~DDTunnel();
  public:
    const String& getEndpoint() { return endPoint; }   
  public:
    virtual void release();
    virtual void reconnect();
    void reconnectTo(const String& endPoint);
    void reconnectToSetParams(const String& endPoint, const String& params) {
      this->endPoint = endPoint;
      this->params = params;
      reconnect();
    }
    void reconnectToEndpoint(const DDTunnelEndpoint endpoint) {
      this->endPoint = endpoint.endPoint;
      this->headers = endpoint.headers;
      this->attachmentId = endpoint.attachmentId;
      this->params = endpoint.params;
      reconnect();
    }
    const String& getTunnelId() const { return tunnelId; }
  protected:
    inline bool _pending() { return doneState == 0; }
    //int _count();
    inline bool _timedOut() { return /*timedOut*/doneState == -1; }
    virtual bool _eof(long timeoutMillis);
    //void _readLine(String &buffer);
    void _writeLine(const String& data);
    void _writeSound(const String& soundName);
  public:
    virtual void handleInput(const String& data, uint8_t* fbBytes, bool final) { doneHandleInput(final); }
  protected:
    void doneHandleInput(bool final);   
  protected:
    String type;
    String tunnelId;
    String endPoint;
    String headers;
    String attachmentId;
    String params;
    unsigned long connectMillis;
    // int arraySize;
    // String* dataArray;
    // int nextArrayIdx;
    // int validArrayIdx;
  private:
    //bool done;
    //bool timedOut;
    int8_t doneState;  // 0 not done; 1 done; -1 timed out
};
 
 
class DDBufferedTunnel: public DDTunnel {
  public:
    DDBufferedTunnel(const String& type, int8_t tunnelId, const String& params, const String& endPoint/*, bool connectNow*/, int8_t bufferSize);
    virtual ~DDBufferedTunnel();
    virtual void release();
    virtual void reconnect();
    //const String& getTunnelId() { return tunnelId; }
  protected:
    int _count();
    virtual bool _eof(long timeoutMillis);
    bool _readLine(String &buffer, uint8_t** pFBBytes = NULL);
    //void _writeLine(const String& data);
  public:
    virtual void handleInput(const String& data, uint8_t* fbBytes, bool final);
  private:
    // String endPoint;
    // String tunnelId;
    int8_t arraySize;
    String* dataArray;
    uint8_t** fbByesArray;
    int8_t nextArrayIdx;
    int8_t validArrayIdx;
    //bool done;
  public:
    bool pending();
    inline int count() { return _count(); }
    inline bool eof(long timeoutMillis = DD_DEF_TUNNEL_TIMEOUT) { return _eof(timeoutMillis); }
    inline bool timedOut() { return _timedOut(); }
    String readLine();
    inline bool readLine(String &buffer) { return _readLine(buffer); }
    inline void writeLine(const String& data) { _writeLine(data); }
    bool read(String& fieldId, String& fieldValue);
};
 
 
typedef DDBufferedTunnel BasicDDTunnel;
 
typedef BasicDDTunnel JsonDDTunnel;
 
class SimpleToolDDTunnel: public BasicDDTunnel {
  public:
    SimpleToolDDTunnel(const String& type, int8_t tunnelId, const String& params, const String& endPoint/*, bool connectNow*/, int bufferSize):
        BasicDDTunnel(type, tunnelId, params, endPoint/*, connectNow*/, bufferSize) {
      this->result = 0;
    }
  public:
    virtual void reconnect();
    int checkResult(); 
  private:
    int result; 
};
 
struct DDLocation {
  float latitude;
  float longitude;
};
class GpsServiceDDTunnel: public BasicDDTunnel {
  public:
    GpsServiceDDTunnel(const String& type, int8_t tunnelId, const String& params, const String& endPoint/*, bool connectNow*/, int8_t bufferSize):
        BasicDDTunnel(type, tunnelId, params, endPoint/*, connectNow*/, bufferSize) {
    }
  public:
    void reconnectForLocation(int repeat = -1);
    bool readLocation(DDLocation& location);  
};
 
 
struct DDObjectDetectDemoResult {
  int left;
  int top;
  int right;
  int bottom;
  String label;
};
class ObjectDetectDemoServiceDDTunnel: public BasicDDTunnel {
  public:
    ObjectDetectDemoServiceDDTunnel(const String& type, int8_t tunnelId, const String& params, const String& endPoint/*, bool connectNow*/, int8_t bufferSize):
        BasicDDTunnel(type, tunnelId, params, endPoint/*, connectNow*/, bufferSize) {
    }
  public:
    void reconnectForObjectDetect(const String& imageName);
    void reconnectForObjectDetectFrom(GraphicalDDLayer* pGraphicalLayer, const String& imageName);
    bool readObjectDetectResult(DDObjectDetectDemoResult& objectDetectResult);  
};
 
struct DDImageData {
  DDImageData(): bytes(NULL) {};
  ~DDImageData();
  bool isValid() { return width > 0 && height > 0; }
  void release();
  int width;
  int height;
  int byteCount;
  uint8_t* bytes;
protected:
  void transferTo(DDImageData& imageData);
};
struct DDPixelImage: public DDImageData {
  void transferDataTo(DDPixelImage& pixelImage) { DDImageData::transferTo(pixelImage); }
};
struct DDPixelImage16 {
  DDPixelImage16(): data(NULL) {};
  ~DDPixelImage16();
  bool isValid() { return width > 0 && height > 0; }
  void transferTo(DDPixelImage16& pixelImage16);
  void release();
  int width;
  int height;
  int byteCount;
  uint16_t* data;
};
struct DDJpegImage: public DDImageData {
  void transferTo(DDJpegImage& jpegImage) { DDImageData::transferTo(jpegImage); }
};
class ImageRetrieverDDTunnel: public BasicDDTunnel {
  public:
    ImageRetrieverDDTunnel(const String& type, int8_t tunnelId, const String& params, const String& endPoint/*, bool connectNow*/, int8_t bufferSize):
        BasicDDTunnel(type, tunnelId, params, endPoint/*, connectNow*/, bufferSize) {
    }
  public:
    void reconnectForPixelImage(const String& imageName, int width, int height, bool fit = false);
    void reconnectForPixelImage16(const String& imageName, int width, int height, bool fit = false, bool grayscale = false);
    void reconnectForPixelImageGS(const String& imageName, int width, int height, bool fit = false);
    void reconnectForJpegImage(const String& imageName, int width, int height, int quality=100, bool fit = false);
    bool readPixelImage(DDPixelImage& pixelImage);  
    bool readPixelImage16(DDPixelImage16& pixelImage16);  
    bool readPixelImageGS(DDPixelImage& pixelImage);
    bool readPixelImageGS16(DDPixelImage16& pixelImage16); 
    bool readJpegImage(DDJpegImage& jpeg);  
  private:  
    bool _readImageData(DDImageData& imageData, short type);  
};
 
 
 
class JsonDDTunnelMultiplexer {
  public:
    JsonDDTunnelMultiplexer(JsonDDTunnel** tunnels, int8_t tunnelCount);
    ~JsonDDTunnelMultiplexer();
    int count();
    bool eof();
    int read(String& fieldId, String& fieldValue);
    void release();
    void reconnect();
  private:
     int8_t tunnelCount;
     JsonDDTunnel** tunnels;
};
 
#ifndef DD_NO_IDLE_CALLBACK
enum DDIdleConnectionState { IDLE_NOT_CONNECTED, IDLE_CONNECTING, IDLE_RECONNECTING };
typedef void (*DDIdleCallback)(long idleForMillis, DDIdleConnectionState connectionState);
#endif
 
#ifndef DD_NO_CONNECT_VERSION_CHANGED_CALLBACK
typedef void (*DDConnectVersionChangedCallback)(int connectVersion);
#endif
 
#ifndef DD_NO_DEBUG_INTERFACE
enum DDDebugConnectionState { DEBUG_NOT_CONNECTED, DEBUG_CONNECTING, DEBUG_CONNECTED, DEBUG_RECONNECTING, DEBUG_RECONNECTED };
class DDDebugInterface {
  public:
    virtual void logConnectionState(DDDebugConnectionState connectionState) {}
    virtual void logSendCommand(int state) {}
    virtual void logError(const String& errMsg) {}
};
#endif
 
 
#ifndef DD_NO_PASSIVE_CONNECT
struct DDConnectPassiveStatus {
  bool connected;
  bool connecting;
  bool reconnecting;
};
#endif
 
 
extern bool _DDDisableParamEncoding;
inline void DDDebugDisableParamEncoding() { _DDDisableParamEncoding = true; }
 
 
class DumbDisplay {
  public:
    DumbDisplay(DDInputOutput* pIO, uint16_t sendBufferSize = DD_DEF_SEND_BUFFER_SIZE, long idleTimeout = DD_DEF_IDLE_TIMEOUT/*, bool enableDoubleClick = true*/) {
#ifdef DD_DISABLE_PARAM_ENCODING
    DDDebugDisableParamEncoding();
#endif      
#ifdef DD_NO_SERIAL      
  #warning ***** DD_NO_SERIAL defined *****
#else
  #ifdef DDIO_USE_DD_SERIAL
      if (pIO->isForSerial() || pIO->isBackupBySerial()) {
        _The_DD_Serial = new DDSerial();
      }
  #endif    
#endif      
      initialize(pIO, sendBufferSize, idleTimeout/*, enableDoubleClick*/);
    }
    void connect();
    bool connected() const;
    int getConnectVersion() const;
    int getCompatibilityVersion() const;  
    void setFeedbackSingleClickOnly(bool singleClickOnly = true);
    void configAutoPin(const String& layoutSpec = DD_AP_VERT, bool autoShowHideLayers = false);
    // /// in addition to DumbDisplay::configAutoPin(), also configure the remaining layout spec for the remaining layers not mentioned in the layoutSpec 
    // /// @see configAutoPin
    // /// @see addRemainingAutoPinConfig
    // void configAutoPinEx(const String& layoutSpec = DD_AP_VERT, const String& remainingLayoutSpec);
    void addRemainingAutoPinConfig(const String& remainingLayoutSpec);
    void configPinFrame(int xUnitCount = 100, int yUnitCount = 100, bool autoShowHideLayers = false);
    void pinLayer(DDLayer *pLayer, int uLeft, int uTop, int uWidth, int uHeight, const String& align = "");
    void pinAutoPinLayers(const String& layoutSpec, int uLeft, int uTop, int uWidth, int uHeight, const String& align = "");
    MbDDLayer* createMicrobitLayer(int width = 5, int height = 5);
    TurtleDDLayer* createTurtleLayer(int width, int height);
    LedGridDDLayer* createLedGridLayer(int colCount = 1, int rowCount = 1, int subColCount = 1, int subRowCount = 1);
    LcdDDLayer* createLcdLayer(int colCount = 16, int rowCount = 2, int charHeight = 0, const String& fontName = "");
    SelectionDDLayer* createSelectionLayer(int colCount = 16, int rowCount = 2,
                                           int horiSelectionCount = 1, int vertSelectionCount = 1,
                                           int charHeight = 0, const String& fontName = "",
                                           bool canDrawDots = true, float selectionBorderSizeCharHeightFactor = 0.3);
    GraphicalDDLayer* createGraphicalLayer(int width, int height);
    SevenSegmentRowDDLayer* create7SegmentRowLayer(int digitCount = 1);
    JoystickDDLayer* createJoystickLayer(int maxStickValue = 1023, const String& directions = "", float stickSizeFactor = 1.0/*, int stickValueDivider = 1*/);
    PlotterDDLayer* createPlotterLayer(int width, int height, int pixelsPerSecond = 10);
    PlotterDDLayer* createFixedRatePlotterLayer(int width, int height, int pixelsPerScale = 5);
    TomTomMapDDLayer* createTomTomMapLayer(const String& mapKey, int width, int height);
    TerminalDDLayer* createTerminalLayer(int width, int height);
    WebViewDDLayer* createWebViewLayer(int width, int height, const String& jsObjectName = "DD");
    DumbDisplayWindowDDLayer* createDumbDisplayWindowLayer(int width, int height);
    RtspClientDDLayer* createRtspClient(int width, int height);
    BasicDDTunnel* createBasicTunnel(const String& endPoint, bool connectNow = true, int8_t bufferSize = DD_TUNNEL_DEF_BUFFER_SIZE);
    JsonDDTunnel* createJsonTunnel(const String& endPoint, bool connectNow = true, int8_t bufferSize = DD_TUNNEL_DEF_BUFFER_SIZE);
    JsonDDTunnel* createFilteredJsonTunnel(const String& endPoint, const String& fileNames, bool connectNow = true, int8_t bufferSize = DD_TUNNEL_DEF_BUFFER_SIZE);
    SimpleToolDDTunnel* createImageDownloadTunnel(const String& endPoint, const String& imageName, bool redownload = true);
    BasicDDTunnel* createDateTimeServiceTunnel();
    BasicDDTunnel* createGeneralServiceTunnel();
    GpsServiceDDTunnel* createGpsServiceTunnel();
    ObjectDetectDemoServiceDDTunnel* createObjectDetectDemoServiceTunnel(int scaleToWidth = 0, int scaleToHeight = 0, int maxNumObjs = 1);
    ImageRetrieverDDTunnel* createImageRetrieverTunnel();
    void deleteTunnel(DDTunnel *pTunnel);
    void backgroundColor(const String& color);
    void recordLayerSetupCommands();
    void playbackLayerSetupCommands(const String& layerSetupPersistId);
    void recordLayerCommands();
    void playbackLayerCommands();
    void stopRecordLayerCommands(const String& saveId = "", bool persistSave = false);
    void saveLayerCommands(const String& id, bool persist = false, bool stopAfterSave = false);
    void loadLayerCommands(const String& id);
    void capture(const String& imageFileName, int width, int height);
    void sendNoOp();
    void writeComment(const String& comment);
    void tone(uint32_t freq, uint32_t duration);
    void notone();
    void playSound(const String& soundName);
    void stopSound();
    void saveSound8(const String& soundName, const int8_t *bytes, int sampleCount, int sampleRate, int numChannels = 1);
    void saveSound16(const String& soundName, const int16_t *data, int sampleCount, int sampleRate, int numChannels = 1);
    void cacheSound8(const String& soundName, const int8_t *bytes, int sampleCount, int sampleRate, int numChannels = 1);
    void cacheSound16(const String& soundName, const int16_t *data, int sampleCount, int sampleRate, int numChannels = 1);
    void saveCachedSound(const String& soundName);
    void saveCachedSoundAsH(const String& soundName);
    int streamSound8(int sampleRate, int numChannels = 1); 
    int streamSound16(int sampleRate, int numChannels = 1); 
    int saveSoundChunked8(const String& soundName/*, const int8_t *bytes, int sampleCount*/, int sampleRate, int numChannels = 1);
    int saveSoundChunked16(const String& soundName/*, const int16_t *data, int sampleCount*/, int sampleRate, int numChannels = 1);
    int cacheSoundChunked8(const String& soundName/*, const int8_t *bytes, int sampleCount*/, int sampleRate, int numChannels = 1);
    int cacheSoundChunked16(const String& soundName/*, const int16_t *data, int sampleCount*/, int sampleRate, int numChannels = 1);
    void sendSoundChunk8(int chunkId, const int8_t *bytes, int sampleCount, bool isFinal = false);
    void sendSoundChunk16(int chunkId, const int16_t *data, int sampleCount, bool isFinal = false);
    void saveImage(const String& imageName, const uint8_t *bytes, int byteCount);
    void savePixelImage(const String& imageName, const uint8_t *bytes, int width, int height, const String& color = "", char compressMethod = 0);
    void savePixelImage16(const String& imageName, const uint16_t *data, int width, int height, const String& options = "", char compressMethod = 0);
    void savePixelImageGS(const String& imageName, const uint8_t *data, int width, int height, const String& options = "", char compressMethod = 0);
    void stitchImages(const String& imageNames, const String& asImageName);
    void alert(const String& message, const String& title = "");
    void reorderLayer(DDLayer *pLayer, const String& how);
    void deleteLayer(DDLayer *pLayer);
    void walkLayers(void (*walker)(DDLayer *));
 #ifndef DD_NO_IDLE_CALLBACK
    void setIdleCallback(DDIdleCallback idleCallback); 
#endif
#ifndef DD_NO_CONNECT_VERSION_CHANGED_CALLBACK
    void setConnectVersionChangedCallback(DDConnectVersionChangedCallback connectVersionChangedCallback);
#endif
    bool canPrintToSerial();
    void logToSerial(const String& logLine, bool force = false);
    void log(const String& logLine, bool isError = false);
 public:
 #ifndef DD_NO_PASSIVE_CONNECT
    bool connectPassive(DDConnectPassiveStatus* pStatus = NULL);
    void masterReset();  
#endif 
  public:
#ifndef DD_NO_DEBUG_INTERFACE
    void debugSetup(DDDebugInterface *debugInterface);
#endif    
    void debugOnly(int i);
  private:
    void initialize(DDInputOutput* pIO, uint16_t sendBufferSize, long idleTimeout/*, bool enableDoubleClick*/);
    //bool canLogToSerial();
};
 
#include "_dd_misc.h"
 
#endif