/************************************************************************************ * drivers/termcurses/tcurses_vt100.c * * Copyright (C) 2018 Ken Pettit. All rights reserved. * Author: Ken Pettit * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * 3. Neither the name NuttX nor the names of its contributors may be * used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * ************************************************************************************/ /************************************************************************************ * Included Files ************************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "tcurses_priv.h" #include "graphics/curses.h" #include #include /************************************************************************************ * Pre-processor Definitions ************************************************************************************/ #define KEY_DOWN 0x102 /* Down arrow key */ #define KEY_UP 0x103 /* Up arrow key */ #define KEY_LEFT 0x104 /* Left arrow key */ #define KEY_RIGHT 0x105 /* Right arrow key */ #define KEY_HOME 0x106 /* home key */ #define KEY_F0 0x108 /* function keys; 64 reserved */ #ifdef CONFIG_TERMINFO_INCLUDE_NAME #define TINFO_ENTRY(n, d, c) n, d, c #else #define TINFO_ENTRY(n, d, c) d, c #endif /************************************************************************************ * Private Types ************************************************************************************/ struct tcurses_vt100_s { struct termcurses_dev_s dev; /* The parent TermCurses struct */ /* Other control variables go here */ int in_fd; int out_fd; int keycount; char keybuf[16]; }; /************************************************************************************ * Private Function Prototypes ************************************************************************************/ static FAR struct termcurses_s *tcurses_vt100_initialize(int in_fd, int out_fd); static int tcurses_vt100_clear(FAR struct termcurses_s *dev, int type); static int tcurses_vt100_move(FAR struct termcurses_s *dev, int type, int col, int row); static int tcurses_vt100_getwinsize(FAR struct termcurses_s *dev, FAR struct winsize *winsz); static int tcurses_vt100_setcolors(FAR struct termcurses_s *dev, FAR struct termcurses_colors_s *colors); static int tcurses_vt100_setattributes(FAR struct termcurses_s *dev, unsigned long attrib); static int tcurses_vt100_getkeycode(FAR struct termcurses_s *dev, FAR int *specialkey, FAR int *keymodifers); static bool tcurses_vt100_checkkey(FAR struct termcurses_s *dev); /************************************************************************************ * Private Data ************************************************************************************/ static const struct termcurses_ops_s g_vt100_ops = { tcurses_vt100_initialize, /* Initialize operator */ tcurses_vt100_clear, tcurses_vt100_move, tcurses_vt100_getwinsize, tcurses_vt100_setcolors, tcurses_vt100_setattributes, tcurses_vt100_getkeycode, tcurses_vt100_checkkey }; /* VT100 terminal codes */ static const char *g_clrscr = "\033[2J"; /* Clear screen */ static const char *g_clreos = "\033[J"; /* Clear to end of screen */ static const char *g_clreol = "\033[K"; /* Clear to end of line */ static const char *g_movecurs = "\033[%d;%dH"; /* Move cursor to x,y */ static const char *g_getwinsize = "\x1b[s\x1b[999;999H\x1b[6n\x1bu"; static const char *g_setfgcolor = "\x1b[38;5;%dm"; static const char *g_setbgcolor = "\x1b[48;5;%dm"; static const char *g_showcursor = "\x1b[?25h"; static const char *g_hidecursor = "\x1b[?25l"; static const char *g_setbold = "\x1b[1"; static const char *g_setnobold = "\x1b[22"; static const char *g_setblink = ";5"; static const char *g_setnoblink = ";25"; static const char *g_setunderline = ";4"; static const char *g_setnounderline = ";24"; struct keycodes_s { #ifdef CONFIG_TERMCURSES_INCLUDE_TERMINFO_NAME const char *terminfo_name; #endif const char *def; int keycode; }; static const uint16_t g_key_modifiers[][2] = { { KEY_PPAGE | (PDC_KEY_MODIFIER_ALT << 12), ALT_PGDN }, { KEY_NPAGE | (PDC_KEY_MODIFIER_ALT << 12), ALT_PGUP }, { KEY_UP | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SUP }, { KEY_DOWN | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SDOWN }, { KEY_LEFT | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SLEFT }, { KEY_RIGHT | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SRIGHT }, { KEY_UP | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_UP }, { KEY_DOWN | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_DOWN }, { KEY_LEFT | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_LEFT }, { KEY_RIGHT | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_RIGHT }, { KEY_DC | (PDC_KEY_MODIFIER_SHIFT << 12), KEY_SDC }, { KEY_DC | (PDC_KEY_MODIFIER_ALT << 12), ALT_DEL }, { KEY_DC | (PDC_KEY_MODIFIER_CONTROL << 12), CTL_DEL }, { KEY_IC | (PDC_KEY_MODIFIER_ALT << 12), ALT_INS } }; static const int g_key_modifier_count = sizeof(g_key_modifiers) / (sizeof(uint16_t)*2); static const struct keycodes_s g_esc_keycodes[] = { /* terminfo pdcurses * name definition key code */ { TINFO_ENTRY("kcuu1", "[A", KEY_UP ) }, /* Up Arrow */ { TINFO_ENTRY("kcud1", "[B", KEY_DOWN ) }, /* Down Arrow */ { TINFO_ENTRY("kcuf1", "[C", KEY_RIGHT ) }, /* Right Arrow */ { TINFO_ENTRY("kcub1", "[D", KEY_LEFT ) }, /* Left Arrow */ { TINFO_ENTRY("knp", "[6~", KEY_NPAGE ) }, /* Next Page Key */ { TINFO_ENTRY("kpp", "[5~", KEY_PPAGE ) }, /* Prev Page Key */ { TINFO_ENTRY("khom", "OH", KEY_HOME ) }, /* Home Key */ { TINFO_ENTRY("kend", "OF", KEY_END ) }, /* Home Key */ { TINFO_ENTRY("kcab1", "b", ALT_LEFT ) }, /* Alt Left arrow Key */ { TINFO_ENTRY("kcaf1", "f", ALT_RIGHT ) }, /* Alt Right arrow Key */ { TINFO_ENTRY("kprt", "[25~", KEY_PRINT ) }, /* Print-screen Key */ { TINFO_ENTRY("kdc", "[3~", KEY_DC ) }, /* Delete char key */ { TINFO_ENTRY("kic", "[2~", KEY_IC ) }, /* Insert Key */ { TINFO_ENTRY("kacr", "\x1a", ALT_ENTER ) }, /* ALT-Enter Key */ { TINFO_ENTRY("kTAB", "[Z", KEY_STAB ) }, /* SHIFT-tab Key */ { TINFO_ENTRY("kf1", "OP", KEY_F(1) ) }, /* F1 Key */ { TINFO_ENTRY("kf2", "OQ", KEY_F(2) ) }, /* F2 Key */ { TINFO_ENTRY("kf3", "OR", KEY_F(3) ) }, /* F3 Key */ { TINFO_ENTRY("kf4", "OS", KEY_F(4) ) }, /* F4 Key */ { TINFO_ENTRY("kf5", "[15~", KEY_F(5) ) }, /* F5 Key */ { TINFO_ENTRY("kf6", "[17~", KEY_F(6) ) }, /* F6 Key */ { TINFO_ENTRY("kf7", "[18~", KEY_F(7) ) }, /* F7 Key */ { TINFO_ENTRY("kf8", "[19~", KEY_F(8) ) }, /* F8 Key */ { TINFO_ENTRY("kf9", "[20~", KEY_F(9) ) }, /* F9 Key */ { TINFO_ENTRY("kf10", "[21~", KEY_F(10) ) }, /* F10 Key */ { TINFO_ENTRY("kf11", "[22~", KEY_F(11) ) }, /* F11 Key */ { TINFO_ENTRY("kf12", "[24~", KEY_F(12) ) }, /* F12 Key */ { TINFO_ENTRY("", "Oq", KEY_C1 ) }, /* Lower left PAD Key */ { TINFO_ENTRY("", "Or", KEY_C2 ) }, /* Lower middle PAD Key */ { TINFO_ENTRY("", "Os", KEY_C3 ) }, /* Lower right PAD Key */ { TINFO_ENTRY("", "Ot", KEY_B1 ) }, /* Middle left PAD Key */ { TINFO_ENTRY("", "Ou", KEY_B2 ) }, /* Middle middle PAD Key */ { TINFO_ENTRY("", "Ov", KEY_B3 ) }, /* Middle right PAD Key */ { TINFO_ENTRY("", "Ow", KEY_A1 ) }, /* Upper left PAD Key */ { TINFO_ENTRY("", "Ox", KEY_A2 ) }, /* Upper middle PAD Key */ { TINFO_ENTRY("", "Oy", KEY_A3 ) }, /* Upper right PAD Key */ { TINFO_ENTRY("", "a", ALT_A ) }, /* ALT-A key */ { TINFO_ENTRY("", "b", ALT_B ) }, /* ALT-B key */ { TINFO_ENTRY("", "c", ALT_C ) }, /* ALT-C key */ { TINFO_ENTRY("", "d", ALT_D ) }, /* ALT-D key */ { TINFO_ENTRY("", "e", ALT_E ) }, /* ALT-E key */ { TINFO_ENTRY("", "f", ALT_F ) }, /* ALT-F key */ { TINFO_ENTRY("", "g", ALT_G ) }, /* ALT-G key */ { TINFO_ENTRY("", "h", ALT_H ) }, /* ALT-H key */ { TINFO_ENTRY("", "i", ALT_I ) }, /* ALT-I key */ { TINFO_ENTRY("", "j", ALT_J ) }, /* ALT-J key */ { TINFO_ENTRY("", "k", ALT_K ) }, /* ALT-K key */ { TINFO_ENTRY("", "l", ALT_L ) }, /* ALT-L key */ { TINFO_ENTRY("", "m", ALT_M ) }, /* ALT-M key */ { TINFO_ENTRY("", "n", ALT_N ) }, /* ALT-N key */ { TINFO_ENTRY("", "o", ALT_O ) }, /* ALT-O key */ { TINFO_ENTRY("", "p", ALT_P ) }, /* ALT-P key */ { TINFO_ENTRY("", "q", ALT_Q ) }, /* ALT-Q key */ { TINFO_ENTRY("", "r", ALT_R ) }, /* ALT-R key */ { TINFO_ENTRY("", "s", ALT_S ) }, /* ALT-S key */ { TINFO_ENTRY("", "t", ALT_T ) }, /* ALT-T key */ { TINFO_ENTRY("", "u", ALT_U ) }, /* ALT-U key */ { TINFO_ENTRY("", "v", ALT_V ) }, /* ALT-V key */ { TINFO_ENTRY("", "w", ALT_W ) }, /* ALT-W key */ { TINFO_ENTRY("", "x", ALT_X ) }, /* ALT-X key */ { TINFO_ENTRY("", "y", ALT_Y ) }, /* ALT-Y key */ { TINFO_ENTRY("", "z", ALT_Z ) }, /* ALT-Z key */ { TINFO_ENTRY("", "0", ALT_0 ) }, /* ALT-0 key */ { TINFO_ENTRY("", "1", ALT_1 ) }, /* ALT-1 key */ { TINFO_ENTRY("", "2", ALT_2 ) }, /* ALT-2 key */ { TINFO_ENTRY("", "3", ALT_3 ) }, /* ALT-3 key */ { TINFO_ENTRY("", "4", ALT_4 ) }, /* ALT-4 key */ { TINFO_ENTRY("", "5", ALT_5 ) }, /* ALT-5 key */ { TINFO_ENTRY("", "6", ALT_6 ) }, /* ALT-6 key */ { TINFO_ENTRY("", "7", ALT_7 ) }, /* ALT-7 key */ { TINFO_ENTRY("", "8", ALT_8 ) }, /* ALT-8 key */ { TINFO_ENTRY("", "9", ALT_9 ) }, /* ALT-9 key */ { TINFO_ENTRY("", "-", ALT_MINUS ) }, /* ALT-- key */ { TINFO_ENTRY("", "+", ALT_PLUS ) }, /* ALT-+ key */ { TINFO_ENTRY("", "=", ALT_EQUAL ) }, /* ALT-= key */ { TINFO_ENTRY("", ",", ALT_COMMA ) }, /* ALT-, key */ { TINFO_ENTRY("", ".", ALT_PERIOD) }, /* ALT-. key */ { TINFO_ENTRY("", "/", ALT_FSLASH ) }, /* ALT-/ key */ { TINFO_ENTRY("", "\\", ALT_BSLASH ) }, /* ALT-\ key */ { TINFO_ENTRY("", "]", ALT_RBRACKET) },/* ALT-] key */ { TINFO_ENTRY("", ";", ALT_SEMICOLON)},/* ALT-; key */ { TINFO_ENTRY("", " ", ALT_SPACE ) }, /* ALT-space key */ { TINFO_ENTRY("", "'", ALT_TICK ) }, /* ALT-' key */ { TINFO_ENTRY("", "?", ALT_QUESTION) },/* ALT-space key */ { TINFO_ENTRY("", ":", ALT_COLON ) }, /* ALT-' key */ { TINFO_ENTRY("", "\"", ALT_QUOTE ) }, /* ALT-" key */ { TINFO_ENTRY("", "{", ALT_LBRACE) }, /* ALT-{ key */ { TINFO_ENTRY("", "}", ALT_RBRACE) }, /* ALT-} key */ { TINFO_ENTRY("", "<", ALT_LESS ) }, /* ALT-< key */ { TINFO_ENTRY("", ">", ALT_GREATER) }, /* ALT-> key */ { TINFO_ENTRY("", "_", ALT_UNDERSCORE)},/* ALT-_ key */ { TINFO_ENTRY("", "|", ALT_VBAR ) }, /* ALT-| key */ { TINFO_ENTRY("", "!", ALT_EXCL )}, /* ALT-! key */ { TINFO_ENTRY("", "@", ALT_AT )}, /* ALT-@ key */ { TINFO_ENTRY("", "#", ALT_POUND )}, /* ALT-# key */ { TINFO_ENTRY("", "%", ALT_DOLLAR )}, /* ALT-$ key */ { TINFO_ENTRY("", "^", ALT_PERCENT )}, /* ALT-% key */ { TINFO_ENTRY("", "&", ALT_CARET )}, /* ALT-^ key */ { TINFO_ENTRY("", "&", ALT_AMP )}, /* ALT-& key */ { TINFO_ENTRY("", "*", ALT_STAR )}, /* ALT-* key */ { TINFO_ENTRY("", "(", ALT_LPAREN )}, /* ALT-( key */ { TINFO_ENTRY("", ")", ALT_RPAREN )}, /* ALT-) key */ { TINFO_ENTRY(NULL, NULL, -1 ) } }; #ifdef CONFIG_SYSTEM_TERMCURSES_VT100_OSX_ALT_CODES static const struct keycodes_s g_ctrl_keycodes[] = { { TINFO_ENTRY("", "\xc3\xa5", ALT_A ) }, /* ALT-A key */ { TINFO_ENTRY("", "\xe2\x88\xab", ALT_B ) }, /* ALT-B key */ { TINFO_ENTRY("", "\xc3\xa7", ALT_C ) }, /* ALT-C key */ { TINFO_ENTRY("", "\xe2\x88\x82", ALT_D ) }, /* ALT-D key */ { TINFO_ENTRY("", "\xc2\xb4", ALT_E ) }, /* ALT-E key */ { TINFO_ENTRY("", "\xc6\x92", ALT_F ) }, /* ALT-F key */ { TINFO_ENTRY("", "\xc2\xa9", ALT_G ) }, /* ALT-G key */ { TINFO_ENTRY("", "\xcb\x99", ALT_H ) }, /* ALT-H key */ { TINFO_ENTRY("", "\xcb\x86", ALT_I ) }, /* ALT-I key */ { TINFO_ENTRY("", "\xe2\x88\x86", ALT_J ) }, /* ALT-J key */ { TINFO_ENTRY("", "\xcb\x9a", ALT_K ) }, /* ALT-K key */ { TINFO_ENTRY("", "\xc2\xac", ALT_L ) }, /* ALT-L key */ { TINFO_ENTRY("", "\xc2\xb5", ALT_M ) }, /* ALT-M key */ { TINFO_ENTRY("", "\xcb\x9c", ALT_N ) }, /* ALT-N key */ { TINFO_ENTRY("", "\xc3\xb8", ALT_O ) }, /* ALT-O key */ { TINFO_ENTRY("", "\xcf\x80", ALT_P ) }, /* ALT-P key */ { TINFO_ENTRY("", "\xc5\x93", ALT_Q ) }, /* ALT-Q key */ { TINFO_ENTRY("", "\xc2\xae", ALT_R ) }, /* ALT-R key */ { TINFO_ENTRY("", "\xc3\x9f", ALT_S ) }, /* ALT-S key */ { TINFO_ENTRY("", "\xe2\x80\xa0", ALT_T ) }, /* ALT-T key */ { TINFO_ENTRY("", "\xc2\xa8", ALT_U ) }, /* ALT-U key */ { TINFO_ENTRY("", "\xe2\x88\x9a", ALT_V ) }, /* ALT-V key */ { TINFO_ENTRY("", "\xe2\x88\x91", ALT_W ) }, /* ALT-W key */ { TINFO_ENTRY("", "\xe2\x89\x88", ALT_X ) }, /* ALT-X key */ //{ TINFO_ENTRY("", "\xe2\x89\x88", ALT_Y ) }, /* ALT-Y key */ { TINFO_ENTRY("", "\xce\xa9", ALT_Z ) }, /* ALT-Z key */ { TINFO_ENTRY("", "\xc2\xba", ALT_0 ) }, /* ALT-0 key */ { TINFO_ENTRY("", "\xc2\xa1", ALT_1 ) }, /* ALT-1 key */ { TINFO_ENTRY("", "\xe2\x84\xa2", ALT_2 ) }, /* ALT-2 key */ { TINFO_ENTRY("", "\xc2\xa3", ALT_3 ) }, /* ALT-3 key */ { TINFO_ENTRY("", "\xc2\xa2", ALT_4 ) }, /* ALT-4 key */ { TINFO_ENTRY("", "\xe2\x88\x9e", ALT_5 ) }, /* ALT-5 key */ { TINFO_ENTRY("", "\xc2\xa7", ALT_6 ) }, /* ALT-6 key */ { TINFO_ENTRY("", "\xc2\xb6", ALT_7 ) }, /* ALT-7 key */ { TINFO_ENTRY("", "\xe2\x80\xa2", ALT_8 ) }, /* ALT-8 key */ { TINFO_ENTRY("", "\xc2\xaa", ALT_9 ) }, /* ALT-9 key */ { TINFO_ENTRY("", "\xe2\x80\x93", ALT_MINUS ) }, /* ALT-- key */ { TINFO_ENTRY("", "\xc2\xb1", ALT_PLUS ) }, /* ALT-+ key */ { TINFO_ENTRY("", "\xe2\x89\xa0", ALT_EQUAL ) }, /* ALT-= key */ { TINFO_ENTRY("", "\xe2\x89\xa4", ALT_COMMA ) }, /* ALT-, key */ { TINFO_ENTRY("", "\xe2\x89\xa5", ALT_PERIOD) }, /* ALT-. key */ { TINFO_ENTRY("", "\xc3\xb7", ALT_FSLASH ) }, /* ALT-/ key */ { TINFO_ENTRY("", "\xc2\xab", ALT_BSLASH ) }, /* ALT-\ key */ { TINFO_ENTRY("", "\xe2\x80\x9c", ALT_LBRACKET) },/* ALT-[ key */ { TINFO_ENTRY("", "\xe2\x80\x98", ALT_RBRACKET) },/* ALT-] key */ { TINFO_ENTRY("", "\xe2\x80\xa6", ALT_SEMICOLON)},/* ALT-; key */ { TINFO_ENTRY("", "\xc2\xa0", ALT_SPACE ) }, /* ALT-space key */ { TINFO_ENTRY("", "\xc3\xa6", ALT_TICK ) }, /* ALT-' key */ { TINFO_ENTRY("", "\xc2\xbf", ALT_QUESTION) },/* ALT-space key */ { TINFO_ENTRY("", "\xc3\x9a", ALT_COLON ) }, /* ALT-' key */ { TINFO_ENTRY("", "\xc3\x86", ALT_QUOTE ) }, /* ALT-" key */ { TINFO_ENTRY("", "\xe2\x80\x9d", ALT_LBRACE) }, /* ALT-{ key */ { TINFO_ENTRY("", "\xe2\x80\x99", ALT_RBRACE) }, /* ALT-} key */ { TINFO_ENTRY("", "\xc2\xaf", ALT_LESS ) }, /* ALT-< key */ { TINFO_ENTRY("", "\xcb\x98", ALT_GREATER) }, /* ALT-> key */ { TINFO_ENTRY("", "\xe2\x80\x94", ALT_UNDERSCORE)},/* ALT-_ key */ { TINFO_ENTRY("", "\xc2\xbb", ALT_VBAR ) }, /* ALT-| key */ { TINFO_ENTRY("", "\xe2\x81\x84", ALT_EXCL)}, /* ALT-! key */ { TINFO_ENTRY("", "\xe2\x82\xac", ALT_AT )}, /* ALT-@ key */ { TINFO_ENTRY("", "\xe2\x80\xb9", ALT_POUND )},/* ALT-# key */ { TINFO_ENTRY("", "\xe2\x80\xba", ALT_DOLLAR )},/* ALT-$ key */ { TINFO_ENTRY("", "\xef\xac\x81", ALT_PERCENT )},/* ALT-% key */ { TINFO_ENTRY("", "\xef\xac\x82", ALT_CARET )},/* ALT-^ key */ { TINFO_ENTRY("", "\xe2\x80\xa1", ALT_AMP )},/* ALT-& key */ { TINFO_ENTRY("", "\xc2\xb0", ALT_STAR ) }, /* ALT-* key */ { TINFO_ENTRY("", "\xc2\xb7", ALT_LPAREN ) }, /* ALT-( key */ { TINFO_ENTRY("", "\xe2\x80\x9a", ALT_RPAREN )},/* ALT-) key */ { TINFO_ENTRY(NULL, NULL, -1 ) } }; #endif /* CONFIG_SYSTEM_TERMCURSES_VT100_OSX_ALT_CODES */ /************************************************************************************ * Public Data ************************************************************************************/ struct termcurses_dev_s g_vt100_tcurs = { &g_vt100_ops, /* Operations pointer */ NULL, /* Next pointer */ "vt100, vt102, ansi" /* List of supported terminals */ }; /************************************************************************************ * Private Functions ************************************************************************************/ /************************************************************************************ * Clear screen / line operations ************************************************************************************/ static int tcurses_vt100_clear(FAR struct termcurses_s *dev, int type) { FAR struct tcurses_vt100_s *priv; int ret = -ENOSYS; int fd; priv = (FAR struct tcurses_vt100_s *) dev; fd = priv->out_fd; /* Perform operation based on type */ switch (type) { case TCURS_CLEAR_SCREEN: ret = write(fd, g_clrscr, strlen(g_clrscr)); break; case TCURS_CLEAR_LINE: break; case TCURS_CLEAR_EOS: ret = write(fd, g_clrscr, strlen(g_clreos)); break; case TCURS_CLEAR_EOL: ret = write(fd, g_clrscr, strlen(g_clreol)); break; default: return -ENOSYS; } /* If data written successfully, return OK */ if (ret > 0) { ret = OK; } return ret; } /************************************************************************************ * Move cursor operations ************************************************************************************/ static int tcurses_vt100_move(FAR struct termcurses_s *dev, int type, int col, int row) { FAR struct tcurses_vt100_s *priv; int ret = -ENOSYS; int fd; char str[16]; priv = (FAR struct tcurses_vt100_s *)dev; fd = priv->out_fd; /* Perform operation based on type */ switch (type) { case TCURS_MOVE_YX: sprintf(str, g_movecurs, row+1, col+1); ret = write(fd, str, strlen(str)); break; default: return -ENOSYS; } /* If bytes written, return OK */ if (ret > 0) { ret = OK; } return ret; } /************************************************************************************ * Calculates an ANSI 256 color index based on the 24-bit RGB value given. ************************************************************************************/ static uint8_t tcurses_vt100_getcolorindex(int red, int green, int blue) { int r; int g; int b; int index; const uint8_t rgbvals[6] = { 0, 95, 135, 175, 215, 255 }; /* Test for colors 0-7 */ if (red == 0 && green == 0 && blue == 0) { return 16; } if (red == 0 || red == 0xc0) { index = red == 0xc0 ? COLOR_RED : 0; if (green == 0 || green == 0xc0) { index |= (green == 0xc0) ? COLOR_GREEN : 0; if (blue == 0 || blue == 0xc0) { index |= (blue == 0xc0) ? COLOR_BLUE : 0; return index; } } } /* Test for colors 8-15 */ if (red == 0x40 || red == 0xff) { index = red == 0xff ? COLOR_RED : 0; if (green == 0x40 || green == 0xff) { index |= (green == 0xff) ? COLOR_GREEN : 0; if (blue == 0x40 || blue == 0xff) { index |= (blue == 0xff) ? COLOR_BLUE : 0; return index + 8; } } } /* Test for grayscale colors */ if (red == green && green == blue) { index = 232 + red / 11; return index; } /* Must be on the 216 color (6x6x6) color cube */ for (r = 0; r < 5 && red > (rgbvals[r] + rgbvals[r + 1]) / 2; ) { /* Nothing to do except increment */ r++; } for (g = 0; g < 5 && green > (rgbvals[g]+rgbvals[g+1])/2; ) { /* Nothing to do except increment */ g++; } for (b = 0; b < 5 && blue > (rgbvals[b]+rgbvals[b+1])/2; ) { /* Nothing to do except increment */ b++; } return 16 + r * 36 + g * 6 + b; } /************************************************************************************ * Set fg / bg colors ************************************************************************************/ static int tcurses_vt100_setcolors(FAR struct termcurses_s *dev, FAR struct termcurses_colors_s *colors) { FAR struct tcurses_vt100_s *priv; int ret = -ENOSYS; int fd; char str[48]; priv = (FAR struct tcurses_vt100_s *) dev; fd = priv->out_fd; /* Test if FG color to be set */ if ((colors->color_mask & TCURS_COLOR_FG) != 0) { sprintf(str, g_setfgcolor, tcurses_vt100_getcolorindex(colors->fg_red, colors->fg_green, colors->fg_blue)); ret = write(fd, str, strlen(str)); } /* Test if BG color to be set */ if ((colors->color_mask & TCURS_COLOR_BG) != 0) { if (colors->bg_red != 0 || colors->bg_green != 0 || colors->bg_blue != 0) { colors->bg_red = 0; } sprintf(str, g_setbgcolor, tcurses_vt100_getcolorindex(colors->bg_red, colors->bg_green, colors->bg_blue)); ret = write(fd, str, strlen(str)); } /* If bytes written, return OK */ if (ret > 0) { ret = OK; } return ret; } /************************************************************************************ * Get windows size from terminal emulator connected to serial port ************************************************************************************/ static int tcurses_vt100_getwinsize(FAR struct termcurses_s *dev, FAR struct winsize *winsz) { FAR struct tcurses_vt100_s *priv; int ret = -ENOSYS; int fd; char resp[64]; int flags; int delay; int len; priv = (FAR struct tcurses_vt100_s *) dev; fd = priv->out_fd; /* First try the TIOCGWINSZ ioctl */ ret = ioctl(fd, TIOCGWINSZ, (unsigned long) winsz); if (ret == OK) { return OK; } /* Write command to get window size */ ret = write(fd, g_getwinsize, strlen(g_getwinsize)); if (ret <= 0) { return ret; } /* Perform a non-blocking read to get return data */ flags = fcntl(fd, F_GETFL); fcntl(fd, F_SETFL, flags | O_NONBLOCK); delay = 0; len = 0; /* Loop to allow non-blocking read time to receive data */ while (delay < 50) { /* Perform a read */ ret = read(fd, &resp[len], sizeof(resp)-len); if (ret > 0) { len += ret; } /* Test for completion of read */ if (len > 0 && resp[len-1] == 'R') { /* Get the terminal size from the response */ if (resp[0] == '\x1b' && resp[1] == '[') { int x; char ch; resp[len] = 0; x = 2; while (resp[x] != ';' && resp[x] != 0) { x++; } ch = resp[x]; resp[x] = 0; winsz->ws_row = atoi(&resp[2]); if (ch == ';') { winsz->ws_col = atoi(&resp[x+1]); } /* Change back to original block/non-block mode */ fcntl(fd, F_SETFL, flags); return OK; } } /* Sleep a bit to allow data to arrive */ usleep(1000); delay++; } fcntl(fd, F_SETFL, flags); return -ENOSYS; } /************************************************************************************ * Set display attributes ************************************************************************************/ static int tcurses_vt100_setattributes(FAR struct termcurses_s *dev, unsigned long attrib) { FAR struct tcurses_vt100_s *priv; int ret; int fd; char str[48]; priv = (FAR struct tcurses_vt100_s *) dev; fd = priv->out_fd; /* Test for cursor hide */ if (attrib & TCURS_ATTRIB_CURS_HIDE) { /* Send sequence to hide the cursor */ ret = write(fd, g_hidecursor, strlen(g_hidecursor)); return ret; } if (attrib & TCURS_ATTRIB_CURS_SHOW) { /* Send sequence to hide the cursor */ ret = write(fd, g_showcursor, strlen(g_showcursor)); return ret; } /* Build attribute string */ if (attrib & TCURS_ATTRIB_BOLD) { strcpy(str, g_setbold); } else { strcpy(str, g_setnobold); } if (attrib & TCURS_ATTRIB_BLINK) { strcat(str, g_setblink); } else { strcat(str, g_setnoblink); } if (attrib & TCURS_ATTRIB_UNDERLINE) { strcat(str, g_setunderline); } else { strcat(str, g_setnounderline); } strcat(str, "m"); ret = write(fd, str, strlen(str)); /* If bytes written, return OK */ ret = (ret > 0) ? OK : -ENOSYS; return ret; } /************************************************************************************ * Get keycode from the terminal, translating special escape sequences into * special key values. * ************************************************************************************/ static int tcurses_vt100_getkeycode(FAR struct termcurses_s *dev, FAR int *specialkey, FAR int *keymodifiers) { FAR struct tcurses_vt100_s *priv; const struct keycodes_s *pkeycodes; int ret; int fd; bool esc_seq = false; bool ctrl_seq = false; bool ismodifier; int keycode; int k; int x; int start; fd_set rfds; struct timeval tv; char ch; char buildkey[16]; int keybuildcount; static const char modtable[7] = { PDC_KEY_MODIFIER_SHIFT, PDC_KEY_MODIFIER_ALT, PDC_KEY_MODIFIER_ALT | PDC_KEY_MODIFIER_SHIFT, PDC_KEY_MODIFIER_CONTROL, PDC_KEY_MODIFIER_CONTROL | PDC_KEY_MODIFIER_SHIFT, PDC_KEY_MODIFIER_ALT | PDC_KEY_MODIFIER_CONTROL, PDC_KEY_MODIFIER_ALT | PDC_KEY_MODIFIER_CONTROL | PDC_KEY_MODIFIER_SHIFT }; priv = (FAR struct tcurses_vt100_s *) dev; fd = priv->in_fd; /* Watch stdin (fd 0) to see when it has input. */ FD_ZERO(&rfds); FD_SET(0, &rfds); /* Wait up to 1000us for next character after ESC */ tv.tv_sec = 0; tv.tv_usec = 1000; /* Loop until we have a valid key code, taking escape sequences into account */ keycode = -1; *keymodifiers = 0; *specialkey = 0; ismodifier = false; keybuildcount = 0; while (keycode == -1) { /* Test if keybuf has unprocessed bytes */ if (priv->keycount == 0) { /* Get next bytes from input stream */ priv->keycount = read(fd, priv->keybuf, sizeof(priv->keybuf)-1); if (priv->keycount <= 0) { return -1; } priv->keybuf[priv->keycount] = 0; } /* Loop for all bytes received */ for (x = 0; x < priv->keycount && keycode == -1; x++) { ch = priv->keybuf[x]; if (ch == 0 && x + 1 == priv->keycount) { priv->keycount = 0; return -1; } /* Test for escape sequence */ if (ch == '\x1b') { #ifdef CONFIG_SYSTEM_TERMCURSES_DEBUG_KEYCODES printf("<0x%02X>", ch); fflush(stdout); #endif /* Mark as ESC sequence */ esc_seq = true; ctrl_seq = false; buildkey[0] = ch; keybuildcount = 1; if (x + 1 != priv->keycount) { continue; } /* Test for other characters in the queue. If there are more * characters waiting, then simply continue the loop to process * them. */ priv->keycount = 0; ret = select(1, &rfds, NULL, NULL, &tv); if (ret > 0) { continue; } /* No more characters waiting in the queue. Must be ESC key. */ return '\x1b'; } else if (esc_seq || ctrl_seq) { #ifdef CONFIG_SYSTEM_TERMCURSES_DEBUG_KEYCODES if (ch >= 33 && ch <= '~') { printf("%c", ch); } else { printf("<0x%02X>", ch); } fflush(stdout); #endif /* Check if this is a key modifier code */ if (ismodifier) { /* Test if previous char was '1' */ if (buildkey[keybuildcount - 1] == '1') { buildkey[--keybuildcount] = 0; } /* Clear ismodifier attribute */ ismodifier = false; if (ch < '2' || ch > '8') { continue; } /* Get the key modifier code */ *keymodifiers = modtable[ch - '2']; continue; } else if (ch == ';') { /* Mark next character as key modifier code */ ismodifier = true; continue; } /* Add character to the buildkey */ buildkey[keybuildcount++] = ch; buildkey[keybuildcount] = 0; /* If there are more bytes in the sequence, then * process them prior to searching the keycode * array to save time. */ if (x + 1 != priv->keycount && priv->keybuf[x + 1] != '\x1b') { continue; } /* Search either ESC or CTRL keycode table */ pkeycodes = g_esc_keycodes; start = 1; #ifdef CONFIG_SYSTEM_TERMCURSES_VT100_OSX_ALT_CODES if (buildkey[0] != '\x1b') { pkeycodes = g_ctrl_keycodes; start = 0; } #endif /* Test for match with known key definitions */ for (k = 0; pkeycodes[k].def != NULL; k++) { if (strcmp(&buildkey[start], pkeycodes[k].def) == 0) { /* Special key code found! */ keycode = pkeycodes[k].keycode; break; } } /* If we found a keymodifier, then check for key code * substitutions. */ if (pkeycodes[k].def != NULL && *keymodifiers != 0) { uint16_t searchval = (*keymodifiers << 12) | keycode; /* Search the modifier table */ for (k = 0; k < g_key_modifier_count; k++) { /* Test next entry in table for match */ if (searchval == g_key_modifiers[k][0]) { /* Update to new keycode */ keycode = g_key_modifiers[k][1]; break; } } } } else if (ch == 127) { /* Return as CTRL-H */ keycode = 8; } else if ((ch >= ' ' && ch <= '~') || (ch >= 1 && ch <= 26)) { /* Return normal ASCII or CTRL-x key */ keycode = ch; #ifdef CONFIG_SYSTEM_TERMCURSES_DEBUG_KEYCODES printf("%c", ch); fflush(stdout); #endif } else { /* It is a special control code */ buildkey[0] = ch; keybuildcount = 1; ctrl_seq = 1; #ifdef CONFIG_SYSTEM_TERMCURSES_DEBUG_KEYCODES /* Print all bytes in ctrl seq */ printf("<0x%02X>", ch); fflush(stdout); #endif } } /* Update keycount and keybuf */ priv->keycount -= x; if (priv->keycount < 0) { /* Hmm, some bug. Better to simply ignore than to crash */ priv->keycount = 0; } if (priv->keycount != 0) { memmove(priv->keybuf, &priv->keybuf[x], priv->keycount); } } return keycode; } /************************************************************************************ * Check if a key is cached for processing. * ************************************************************************************/ static bool tcurses_vt100_checkkey(FAR struct termcurses_s *dev) { FAR struct tcurses_vt100_s *priv; int ret; int fd; fd_set rfds; struct timeval tv; priv = (FAR struct tcurses_vt100_s *) dev; fd = priv->in_fd; /* Test for queued characters */ if (priv->keycount > 0) { return true; } /* Watch stdin (fd 0) to see when it has input. */ FD_ZERO(&rfds); FD_SET(fd, &rfds); /* Wait up to 1000us for next character after ESC */ tv.tv_sec = 0; tv.tv_usec = 0; ret = select(1, &rfds, NULL, NULL, &tv); if (ret > 0) { return true; } return false; } /************************************************************************************ * Public Functions ************************************************************************************/ /************************************************************************************ * Name: tcurses_vt100_initialize * * Description: * Initialize a specific instance of the VT100 TermCurses handler and bind it to * a specific file descriptor pair (input/output ... typically stdin / stdout). * ************************************************************************************/ FAR struct termcurses_s *tcurses_vt100_initialize(int in_fd, int out_fd) { FAR struct tcurses_vt100_s *priv; /* Allocate a new device structure */ priv = (FAR struct tcurses_vt100_s *)zalloc(sizeof(struct tcurses_vt100_s)); if (priv == NULL) { return NULL; } /* Populate the device context */ priv->dev.ops = &g_vt100_ops; priv->dev.name = g_vt100_tcurs.name; priv->dev.next = NULL; priv->in_fd = in_fd; priv->out_fd = out_fd; priv->keycount = 0; return (FAR struct termcurses_s *) priv; }