You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1556 lines
33 KiB
1556 lines
33 KiB
#include <esp8266.h>
|
|
#include <httpd.h>
|
|
#include "screen.h"
|
|
#include "persist.h"
|
|
#include "sgr.h"
|
|
#include "ascii.h"
|
|
#include "apars_logging.h"
|
|
#include "jstring.h"
|
|
#include "character_sets.h"
|
|
|
|
TerminalConfigBundle * const termconf = &persist.current.termconf;
|
|
TerminalConfigBundle termconf_scratch;
|
|
|
|
MouseTrackingConfig mouse_tracking;
|
|
|
|
// forward declare
|
|
static void utf8_remap(char* out, char g, char charset);
|
|
|
|
#define W termconf_scratch.width
|
|
#define H termconf_scratch.height
|
|
|
|
/**
|
|
* Highest permissible value of the color attribute
|
|
*/
|
|
#define COLOR_MAX 15
|
|
|
|
/**
|
|
* Screen cell data type (16 bits)
|
|
*/
|
|
typedef struct __attribute__((packed)){
|
|
char c[4]; // space for a full unicode character
|
|
Color fg : 4;
|
|
Color bg : 4;
|
|
u8 attrs;
|
|
} Cell;
|
|
|
|
/**
|
|
* The screen data array
|
|
*/
|
|
static Cell screen[MAX_SCREEN_SIZE];
|
|
|
|
|
|
|
|
#define TABSTOP_WORDS 5
|
|
/**
|
|
* Screen state structure
|
|
*/
|
|
static struct {
|
|
bool numpad_alt_mode; //!< DECNKM - Numpad Application Mode
|
|
bool cursors_alt_mode; //!< DECCKM - Cursors Application mode
|
|
|
|
bool newline_mode; //!< LNM - CR automatically sends LF
|
|
bool reverse; //!< DECSCNM - Reverse video
|
|
|
|
bool insert_mode; //!< IRM - Insert mode (move rest of the line to the right)
|
|
bool cursor_visible; //!< DECTCEM - Cursor visible
|
|
enum CursorShape cursor_shape;
|
|
|
|
// Vertical margin bounds (inclusive start/end of scrolling region)
|
|
int vm0;
|
|
int vm1;
|
|
|
|
u32 tab_stops[TABSTOP_WORDS]; // tab stops bitmap
|
|
} scr;
|
|
|
|
#define R0 scr.vm0
|
|
#define R1 scr.vm1
|
|
#define RH (scr.vm1 - scr.vm0 + 1)
|
|
// horizontal edges - will be useful if horizontal margin is implemented
|
|
#define C0 0
|
|
#define C1 (W-1)
|
|
|
|
typedef struct {
|
|
/* Cursor position */
|
|
int x; //!< X coordinate
|
|
int y; //!< Y coordinate
|
|
bool hanging; //!< xenl state - cursor half-wrapped
|
|
|
|
/* SGR */
|
|
bool inverse; //!< not in attrs bc it's applied server-side (not sent to browser)
|
|
u8 attrs;
|
|
Color fg; //!< Foreground color for writing
|
|
Color bg; //!< Background color for writing
|
|
|
|
// Other attribs
|
|
|
|
/* Character set */
|
|
int charsetN;
|
|
char charset0;
|
|
char charset1;
|
|
|
|
/** Options saved with cursor */
|
|
bool auto_wrap; //!< DECAWM - Wrapping when EOL
|
|
bool reverse_wraparound; //!< Reverse-wraparound Mode. DECSET 45
|
|
bool origin_mode; //!< DECOM - absolute positioning is relative to vertical margins
|
|
} CursorTypeDef;
|
|
|
|
/**
|
|
* Cursor position and attributes
|
|
*/
|
|
static CursorTypeDef cursor;
|
|
|
|
/**
|
|
* Saved cursor position, used with the SCP RCP commands
|
|
*/
|
|
static CursorTypeDef cursor_sav;
|
|
bool cursor_saved = false;
|
|
|
|
/** This structure holds old state when switching to an alternate buffer */
|
|
static struct {
|
|
bool alternate_active;
|
|
char title[TERM_TITLE_LEN];
|
|
char btn[TERM_BTN_COUNT][TERM_BTN_LEN];
|
|
char btn_msg[TERM_BTN_COUNT][TERM_BTN_MSG_LEN];
|
|
u32 width;
|
|
u32 height;
|
|
int vm0;
|
|
int vm1;
|
|
u32 tab_stops[TABSTOP_WORDS];
|
|
} state_backup;
|
|
|
|
/**
|
|
* This is used to prevent premature change notifications
|
|
* (from nested calls)
|
|
*/
|
|
static volatile int notifyLock = 0;
|
|
|
|
#define NOTIFY_LOCK() do { \
|
|
notifyLock++; \
|
|
} while(0)
|
|
|
|
#define NOTIFY_DONE() do { \
|
|
if (notifyLock > 0) notifyLock--; \
|
|
if (notifyLock == 0) screen_notifyChange(CHANGE_CONTENT); \
|
|
} while(0)
|
|
|
|
/** Clear the hanging attribute if the cursor is no longer >= W */
|
|
#define clear_invalid_hanging() do { \
|
|
if (cursor.hanging && cursor.x != W-1) cursor.hanging = false; \
|
|
} while(false)
|
|
|
|
#define cursor_inside_region() (cursor.y >= R0 && cursor.y <= R1)
|
|
|
|
//region --- Settings ---
|
|
|
|
/**
|
|
* Restore hard defaults
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
terminal_restore_defaults(void)
|
|
{
|
|
termconf->width = SCR_DEF_WIDTH;
|
|
termconf->height = SCR_DEF_HEIGHT;
|
|
termconf->default_bg = 0;
|
|
termconf->default_fg = 7;
|
|
sprintf(termconf->title, SCR_DEF_TITLE);
|
|
for(int i=1; i <= TERM_BTN_COUNT; i++) {
|
|
sprintf(termconf->btn[i-1], "%d", i);
|
|
sprintf(termconf->btn_msg[i-1], "%c", i);
|
|
}
|
|
termconf->theme = 0;
|
|
termconf->parser_tout_ms = SCR_DEF_PARSER_TOUT_MS;
|
|
termconf->display_tout_ms = SCR_DEF_DISPLAY_TOUT_MS;
|
|
termconf->fn_alt_mode = SCR_DEF_FN_ALT_MODE;
|
|
termconf->config_version = TERMCONF_VERSION;
|
|
termconf->display_cooldown_ms = SCR_DEF_DISPLAY_COOLDOWN_MS;
|
|
termconf->loopback = 0;
|
|
termconf->show_buttons = 1;
|
|
termconf->show_config_links = 1;
|
|
termconf->def_cursor_shape = CURSOR_BLOCK_BL;
|
|
}
|
|
|
|
/**
|
|
* Apply settings after eg. restore from defaults
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
terminal_apply_settings(void)
|
|
{
|
|
terminal_apply_settings_noclear();
|
|
screen_init();
|
|
}
|
|
|
|
/** this is used when changing terminal settings that do not affect the screen size */
|
|
void ICACHE_FLASH_ATTR
|
|
terminal_apply_settings_noclear(void)
|
|
{
|
|
bool changed = false;
|
|
|
|
// Migrate to v1
|
|
if (termconf->config_version < 1) {
|
|
dbg("termconf: Updating to version 1");
|
|
termconf->display_cooldown_ms = SCR_DEF_DISPLAY_COOLDOWN_MS;
|
|
changed = 1;
|
|
}
|
|
|
|
// Migrate to v2
|
|
if (termconf->config_version < 2) {
|
|
dbg("termconf: Updating to version 2");
|
|
termconf->loopback = 0;
|
|
termconf->show_config_links = 1;
|
|
termconf->show_buttons = 1;
|
|
changed = 1;
|
|
}
|
|
|
|
// Migrate to v3
|
|
if (termconf->config_version < 3) {
|
|
dbg("termconf: Updating to version 3");
|
|
for(int i=1; i <= TERM_BTN_COUNT; i++) {
|
|
sprintf(termconf->btn_msg[i-1], "%c", i);
|
|
}
|
|
changed = 1;
|
|
}
|
|
|
|
// Migrate to v3
|
|
if (termconf->config_version < 4) {
|
|
dbg("termconf: Updating to version 4");
|
|
termconf->def_cursor_shape = CURSOR_BLOCK_BL;
|
|
changed = 1;
|
|
}
|
|
|
|
termconf->config_version = TERMCONF_VERSION;
|
|
|
|
// Validation...
|
|
if (termconf->display_tout_ms == 0) {
|
|
termconf->display_tout_ms = SCR_DEF_DISPLAY_TOUT_MS;
|
|
changed = 1;
|
|
}
|
|
if (termconf->display_cooldown_ms == 0) {
|
|
termconf->display_cooldown_ms = SCR_DEF_DISPLAY_COOLDOWN_MS;
|
|
changed = 1;
|
|
}
|
|
|
|
memcpy(&termconf_scratch, termconf, sizeof(TerminalConfigBundle));
|
|
if (W*H > MAX_SCREEN_SIZE) {
|
|
error("BAD SCREEN SIZE: %d rows x %d cols", H, W);
|
|
error("reverting terminal settings to default");
|
|
terminal_restore_defaults();
|
|
changed = true;
|
|
memcpy(&termconf_scratch, termconf, sizeof(TerminalConfigBundle));
|
|
screen_init();
|
|
}
|
|
|
|
if (changed) {
|
|
persist_store();
|
|
}
|
|
}
|
|
//endregion
|
|
|
|
//region --- Reset / Init ---
|
|
|
|
/**
|
|
* Init the screen (entire mappable area - for consistency)
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_init(void)
|
|
{
|
|
dbg("Screen buffer size = %d bytes", sizeof(screen));
|
|
|
|
NOTIFY_LOCK();
|
|
screen_reset();
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Reset the cursor position & colors
|
|
*/
|
|
static void ICACHE_FLASH_ATTR
|
|
cursor_reset(void)
|
|
{
|
|
cursor.x = 0;
|
|
cursor.y = 0;
|
|
cursor.hanging = false;
|
|
|
|
cursor.charsetN = 0;
|
|
cursor.charset0 = CS_B_USASCII;
|
|
cursor.charset1 = CS_0_DEC_SUPPLEMENTAL;
|
|
|
|
screen_reset_sgr();
|
|
}
|
|
|
|
/**
|
|
* Reset the screen - called by ESC c
|
|
*/
|
|
static void ICACHE_FLASH_ATTR
|
|
screen_reset_on_resize(void)
|
|
{
|
|
dbg("Screen partial reset due to resize");
|
|
NOTIFY_LOCK();
|
|
|
|
cursor.x = 0;
|
|
cursor.y = 0;
|
|
cursor.hanging = false;
|
|
|
|
scr.vm0 = 0;
|
|
scr.vm1 = H-1;
|
|
|
|
// size is left unchanged
|
|
screen_clear(CLEAR_ALL);
|
|
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Reset the cursor (\e[0m)
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_reset_sgr(void)
|
|
{
|
|
cursor.fg = termconf_scratch.default_fg;
|
|
cursor.bg = termconf_scratch.default_bg;
|
|
cursor.attrs = 0;
|
|
cursor.inverse = false;
|
|
}
|
|
|
|
/**
|
|
* Reset the screen - called by ESC c
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_reset(void)
|
|
{
|
|
dbg("Screen reset.");
|
|
NOTIFY_LOCK();
|
|
|
|
cursor_reset();
|
|
|
|
// DECopts
|
|
scr.cursor_visible = true;
|
|
scr.insert_mode = false;
|
|
cursor.origin_mode = false;
|
|
cursor.auto_wrap = true;
|
|
cursor.reverse_wraparound = false;
|
|
scr.cursor_shape = termconf->def_cursor_shape;
|
|
|
|
scr.numpad_alt_mode = false;
|
|
scr.cursors_alt_mode = false;
|
|
scr.newline_mode = false;
|
|
scr.reverse = false;
|
|
|
|
scr.vm0 = 0;
|
|
scr.vm1 = H-1;
|
|
|
|
state_backup.alternate_active = false;
|
|
|
|
mouse_tracking.encoding = MTE_SIMPLE;
|
|
mouse_tracking.focus_tracking = false;
|
|
mouse_tracking.mode = MTM_NONE;
|
|
|
|
// size is left unchanged
|
|
screen_clear(CLEAR_ALL);
|
|
|
|
screen_clear_all_tabs();
|
|
|
|
// Set initial tabstops
|
|
for (int i = 0; i < TABSTOP_WORDS; i++) {
|
|
scr.tab_stops[i] = 0x80808080;
|
|
}
|
|
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Swap screen buffer / state
|
|
* this is CSI ? 47/1047/1049 h/l
|
|
* @param alternate - true if we're swapping, false if unswapping
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_swap_state(bool alternate)
|
|
{
|
|
if (alternate == state_backup.alternate_active) {
|
|
warn("No swap, already alternate = %d", alternate);
|
|
return; // nothing to do
|
|
}
|
|
|
|
if (alternate) {
|
|
dbg("Swap to alternate");
|
|
// store old state
|
|
memcpy(state_backup.title, termconf_scratch.title, TERM_TITLE_LEN);
|
|
memcpy(state_backup.btn, termconf_scratch.btn, sizeof(termconf_scratch.btn));
|
|
memcpy(state_backup.btn_msg, termconf_scratch.btn_msg, sizeof(termconf_scratch.btn_msg));
|
|
memcpy(state_backup.tab_stops, scr.tab_stops, sizeof(scr.tab_stops));
|
|
state_backup.vm0 = scr.vm0;
|
|
state_backup.vm1 = scr.vm1;
|
|
// remember old size. may have to resize when returning
|
|
state_backup.width = W;
|
|
state_backup.height = H;
|
|
// TODO backup screen content (if this is ever possible)
|
|
}
|
|
else {
|
|
dbg("Unswap from alternate");
|
|
NOTIFY_LOCK();
|
|
memcpy(termconf_scratch.title, state_backup.title, TERM_TITLE_LEN);
|
|
memcpy(termconf_scratch.btn, state_backup.btn, sizeof(termconf_scratch.btn));
|
|
memcpy(termconf_scratch.btn_msg, state_backup.btn_msg, sizeof(termconf_scratch.btn_msg));
|
|
memcpy(scr.tab_stops, state_backup.tab_stops, sizeof(scr.tab_stops));
|
|
scr.vm0 = state_backup.vm0;
|
|
scr.vm1 = state_backup.vm1;
|
|
// this may clear the screen as a side effect if size changed
|
|
screen_resize(state_backup.height, state_backup.width);
|
|
// TODO restore screen content (if this is ever possible)
|
|
NOTIFY_DONE();
|
|
screen_notifyChange(CHANGE_LABELS);
|
|
}
|
|
|
|
state_backup.alternate_active = alternate;
|
|
}
|
|
|
|
//endregion
|
|
|
|
//region --- Tab stops ---
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_clear_all_tabs(void)
|
|
{
|
|
memset(scr.tab_stops, 0, sizeof(scr.tab_stops));
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_tab(void)
|
|
{
|
|
scr.tab_stops[cursor.x/32] |= (1<<(cursor.x%32));
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_clear_tab(void)
|
|
{
|
|
scr.tab_stops[cursor.x/32] &= ~(1<<(cursor.x%32));
|
|
}
|
|
|
|
/**
|
|
* Find tab stop closest to cursor to the right
|
|
* @return X pos or -1
|
|
*/
|
|
static int ICACHE_FLASH_ATTR
|
|
next_tab_stop(void)
|
|
{
|
|
// cursor must never go past EOL
|
|
if (cursor.x >= W-1) return -1;
|
|
|
|
// find first word to inspect
|
|
int idx = (cursor.x+1)/32;
|
|
int offs = (cursor.x+1)%32;
|
|
int cp = cursor.x;
|
|
while (idx < TABSTOP_WORDS) {
|
|
u32 w = scr.tab_stops[idx];
|
|
w >>= offs;
|
|
for(;offs<32;offs++) {
|
|
cp++;
|
|
if (cp >= W) return -1;
|
|
if (w & 1) return cp;
|
|
w >>= 1;
|
|
}
|
|
offs = 0;
|
|
idx++;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Find tab stop closest to cursor to the left
|
|
* @return X pos or -1
|
|
*/
|
|
static int ICACHE_FLASH_ATTR
|
|
prev_tab_stop(void)
|
|
{
|
|
// nowhere to go
|
|
if (cursor.x == 0) return -1;
|
|
|
|
// find first word to inspect
|
|
int idx = (cursor.x-1)/32;
|
|
int offs = (cursor.x-1)%32;
|
|
int cp = cursor.x;
|
|
while (idx >= 0) {
|
|
u32 w = scr.tab_stops[idx];
|
|
w <<= 31-offs;
|
|
if (w == 0) {
|
|
cp -= cp%32;
|
|
if (cp < 0) return -1;
|
|
goto next;
|
|
}
|
|
for(;offs>=0;offs--) {
|
|
cp--;
|
|
if (cp < 0) return -1;
|
|
if (w & (1<<31)) return cp;
|
|
w <<= 1;
|
|
}
|
|
next:
|
|
offs = 31;
|
|
idx--;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_tab_forward(int count)
|
|
{
|
|
NOTIFY_LOCK();
|
|
for (; count > 0; count--) {
|
|
int tab = next_tab_stop();
|
|
if (tab != -1) {
|
|
cursor.x = tab;
|
|
}
|
|
else {
|
|
cursor.x = W - 1;
|
|
}
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_tab_reverse(int count)
|
|
{
|
|
NOTIFY_LOCK();
|
|
for (; count > 0; count--) {
|
|
int tab = prev_tab_stop();
|
|
if (tab != -1) {
|
|
cursor.x = tab;
|
|
} else {
|
|
cursor.x = 0;
|
|
}
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
//endregion
|
|
|
|
//region --- Clearing & inserting ---
|
|
|
|
/**
|
|
* Clear range, inclusive
|
|
*/
|
|
static void ICACHE_FLASH_ATTR
|
|
clear_range(unsigned int from, unsigned int to)
|
|
{
|
|
if (to >= W*H) to = W*H-1;
|
|
Color fg = (cursor.inverse) ? cursor.bg : cursor.fg;
|
|
Color bg = (cursor.inverse) ? cursor.fg : cursor.bg;
|
|
|
|
Cell sample;
|
|
sample.c[0] = ' ';
|
|
sample.c[1] = 0;
|
|
sample.c[2] = 0;
|
|
sample.c[3] = 0;
|
|
sample.fg = fg;
|
|
sample.bg = bg;
|
|
sample.attrs = 0;
|
|
|
|
for (unsigned int i = from; i <= to; i++) {
|
|
memcpy(&screen[i], &sample, sizeof(Cell));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Clear screen area
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_clear(ClearMode mode)
|
|
{
|
|
// Those ignore margins and DECOM
|
|
NOTIFY_LOCK();
|
|
switch (mode) {
|
|
case CLEAR_ALL:
|
|
clear_range(0, W * H - 1);
|
|
break;
|
|
|
|
case CLEAR_FROM_CURSOR:
|
|
clear_range((cursor.y * W) + cursor.x, W * H - 1);
|
|
break;
|
|
|
|
case CLEAR_TO_CURSOR:
|
|
clear_range(0, (cursor.y * W) + cursor.x);
|
|
break;
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Line reset to gray-on-white, empty
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_clear_line(ClearMode mode)
|
|
{
|
|
NOTIFY_LOCK();
|
|
switch (mode) {
|
|
case CLEAR_ALL:
|
|
clear_range(cursor.y * W, (cursor.y + 1) * W - 1);
|
|
break;
|
|
|
|
case CLEAR_FROM_CURSOR:
|
|
clear_range(cursor.y * W + cursor.x, (cursor.y + 1) * W - 1);
|
|
break;
|
|
|
|
case CLEAR_TO_CURSOR:
|
|
clear_range(cursor.y * W, cursor.y * W + cursor.x);
|
|
break;
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_clear_in_line(unsigned int count)
|
|
{
|
|
if (cursor.x + count >= W) {
|
|
screen_clear_line(CLEAR_FROM_CURSOR);
|
|
}
|
|
else {
|
|
NOTIFY_LOCK();
|
|
clear_range(cursor.y * W + cursor.x, cursor.y * W + cursor.x + count - 1);
|
|
NOTIFY_DONE();
|
|
}
|
|
}
|
|
|
|
void screen_insert_lines(unsigned int lines)
|
|
{
|
|
if (!cursor_inside_region()) return; // can't insert if not inside region
|
|
NOTIFY_LOCK();
|
|
// shift the following lines
|
|
int targetStart = cursor.y + lines;
|
|
if (targetStart > R1) {
|
|
targetStart = R1-1;
|
|
} else {
|
|
// do the moving
|
|
for (int i = R1; i >= targetStart; i--) {
|
|
memcpy(screen+i*W, screen+(i-lines)*W, sizeof(Cell)*W);
|
|
}
|
|
}
|
|
|
|
// clear the first line
|
|
screen_clear_line(CLEAR_ALL);
|
|
// copy it to the rest of the cleared region
|
|
for (int i = cursor.y+1; i < targetStart; i++) {
|
|
memcpy(screen+i*W, screen+cursor.y*W, sizeof(Cell)*W);
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void screen_delete_lines(unsigned int lines)
|
|
{
|
|
if (!cursor_inside_region()) return; // can't delete if not inside region
|
|
NOTIFY_LOCK();
|
|
|
|
// shift lines up
|
|
int targetEnd = R1 - lines - 1;
|
|
if (targetEnd <= cursor.y) {
|
|
targetEnd = cursor.y;
|
|
} else {
|
|
// do the moving
|
|
for (int i = cursor.y; i <= targetEnd; i++) {
|
|
memcpy(screen+i*W, screen+(i+lines)*W, sizeof(Cell)*W);
|
|
}
|
|
}
|
|
|
|
// clear the rest
|
|
clear_range(targetEnd*W, W*R1);
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void screen_insert_characters(unsigned int count)
|
|
{
|
|
NOTIFY_LOCK();
|
|
int targetStart = cursor.x + count;
|
|
if (targetStart >= W) {
|
|
targetStart = W-1;
|
|
} else {
|
|
// do the moving
|
|
for (int i = W-1; i >= targetStart; i--) {
|
|
memcpy(screen+cursor.y*W+i, screen+cursor.y*W+(i-count), sizeof(Cell));
|
|
}
|
|
}
|
|
|
|
clear_range(cursor.y*W+cursor.x, cursor.y*W+targetStart-1);
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void screen_delete_characters(unsigned int count)
|
|
{
|
|
NOTIFY_LOCK();
|
|
int targetEnd = W - count;
|
|
if (targetEnd > cursor.x) {
|
|
// do the moving
|
|
for (int i = cursor.x; i <= targetEnd; i++) {
|
|
memcpy(screen+cursor.y*W+i, screen+cursor.y*W+(i+count), sizeof(Cell));
|
|
}
|
|
}
|
|
|
|
if (targetEnd <= cursor.x) {
|
|
screen_clear_line(CLEAR_FROM_CURSOR);
|
|
}
|
|
else {
|
|
clear_range(cursor.y * W + (W - count), (cursor.y + 1) * W - 1);
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
//endregion
|
|
|
|
//region --- Entire screen manipulation ---
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_fill_with_E(void)
|
|
{
|
|
NOTIFY_LOCK();
|
|
screen_reset(); // based on observation from xterm
|
|
|
|
Cell sample;
|
|
sample.c[0] = 'E';
|
|
sample.c[1] = 0;
|
|
sample.c[2] = 0;
|
|
sample.c[3] = 0;
|
|
sample.fg = termconf_scratch.default_fg;
|
|
sample.bg = termconf_scratch.default_bg;
|
|
sample.attrs = 0;
|
|
|
|
for (unsigned int i = 0; i <= W*H-1; i++) {
|
|
memcpy(&screen[i], &sample, sizeof(Cell));
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Change the screen size
|
|
*
|
|
* @param cols - new width
|
|
* @param rows - new height
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_resize(int rows, int cols)
|
|
{
|
|
// sanitize
|
|
if (cols < 1 || rows < 1) {
|
|
error("Screen size must be positive, ignoring command: %d x %d", cols, rows);
|
|
return;
|
|
}
|
|
|
|
if (cols * rows > MAX_SCREEN_SIZE) {
|
|
error("Max screen size exceeded, ignoring command: %d x %d", cols, rows);
|
|
return;
|
|
}
|
|
|
|
if (W == cols && H == rows) return; // Do nothing
|
|
|
|
NOTIFY_LOCK();
|
|
W = cols;
|
|
H = rows;
|
|
screen_reset_on_resize();
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_title(const char *title)
|
|
{
|
|
strncpy(termconf_scratch.title, title, TERM_TITLE_LEN);
|
|
screen_notifyChange(CHANGE_LABELS);
|
|
}
|
|
|
|
/**
|
|
* Helper function to set terminal button label
|
|
* @param num - button number 1-5
|
|
* @param str - button text
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_button_text(int num, const char *text)
|
|
{
|
|
strncpy(termconf_scratch.btn[num-1], text, TERM_BTN_LEN);
|
|
screen_notifyChange(CHANGE_LABELS);
|
|
}
|
|
|
|
/**
|
|
* Shift screen upwards
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_scroll_up(unsigned int lines)
|
|
{
|
|
NOTIFY_LOCK();
|
|
if (lines >= RH) {
|
|
clear_range(R0*W, (R1+1)*W-1);
|
|
goto done;
|
|
}
|
|
|
|
// bad cmd
|
|
if (lines == 0) {
|
|
goto done;
|
|
}
|
|
|
|
int y;
|
|
for (y = R0; y <= R1 - lines; y++) {
|
|
memcpy(screen + y * W, screen + (y + lines) * W, W * sizeof(Cell));
|
|
}
|
|
|
|
clear_range(y * W, (R1+1)*W-1);
|
|
|
|
done:
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Shift screen downwards
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_scroll_down(unsigned int lines)
|
|
{
|
|
NOTIFY_LOCK();
|
|
if (lines >= RH) {
|
|
clear_range(R0*W, (R1+1)*W-1);
|
|
goto done;
|
|
}
|
|
|
|
// bad cmd
|
|
if (lines == 0) {
|
|
goto done;
|
|
}
|
|
|
|
int y;
|
|
for (y = R1; y >= R0+lines; y--) {
|
|
memcpy(screen + y * W, screen + (y - lines) * W, W * sizeof(Cell));
|
|
}
|
|
|
|
clear_range(R0*W, R0*W+ lines * W-1);
|
|
done:
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/** Set scrolling region */
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_scrolling_region(int from, int to)
|
|
{
|
|
if (from <= 0 && to <= 0) {
|
|
scr.vm0 = 0;
|
|
scr.vm1 = H-1;
|
|
} else if (from >= 0 && from < H-1 && to > from) {
|
|
scr.vm0 = from;
|
|
scr.vm1 = to;
|
|
} else {
|
|
// Bad range, do nothing
|
|
ansi_warn("Bad SR bounds %d, %d", from, to);
|
|
}
|
|
|
|
// Always move cursor home (may be translated due to DECOM)
|
|
screen_cursor_set(0, 0);
|
|
}
|
|
|
|
//endregion
|
|
|
|
//region --- Cursor manipulation ---
|
|
|
|
/** set cursor type */
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_shape(enum CursorShape shape)
|
|
{
|
|
NOTIFY_LOCK();
|
|
if (shape == CURSOR_DEFAULT) shape = termconf->def_cursor_shape;
|
|
scr.cursor_shape = shape;
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/** set cursor blink option */
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_blink(bool blink)
|
|
{
|
|
NOTIFY_LOCK();
|
|
if (blink) {
|
|
if (scr.cursor_shape == CURSOR_BLOCK) scr.cursor_shape = CURSOR_BLOCK_BL;
|
|
if (scr.cursor_shape == CURSOR_BAR) scr.cursor_shape = CURSOR_BAR_BL;
|
|
if (scr.cursor_shape == CURSOR_UNDERLINE) scr.cursor_shape = CURSOR_UNDERLINE_BL;
|
|
} else {
|
|
if (scr.cursor_shape == CURSOR_BLOCK_BL) scr.cursor_shape = CURSOR_BLOCK;
|
|
if (scr.cursor_shape == CURSOR_BAR_BL) scr.cursor_shape = CURSOR_BAR;
|
|
if (scr.cursor_shape == CURSOR_UNDERLINE_BL) scr.cursor_shape = CURSOR_UNDERLINE;
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Set cursor position
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_set(int y, int x)
|
|
{
|
|
NOTIFY_LOCK();
|
|
screen_cursor_set_x(x);
|
|
screen_cursor_set_y(y);
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Set cursor position
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_get(int *y, int *x)
|
|
{
|
|
*x = cursor.x;
|
|
*y = cursor.y;
|
|
|
|
if (cursor.origin_mode) {
|
|
*y -= R0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set cursor X position
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_set_x(int x)
|
|
{
|
|
NOTIFY_LOCK();
|
|
if (x >= W) x = W - 1;
|
|
if (x < 0) x = 0;
|
|
cursor.x = x;
|
|
// Always clear hanging on cursor set
|
|
// hanging happens when the cursor is virtually at col=81, which
|
|
// cannot be set using the cursor-set commands.
|
|
cursor.hanging = false;
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Set cursor Y position
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_set_y(int y)
|
|
{
|
|
NOTIFY_LOCK();
|
|
if (cursor.origin_mode) {
|
|
y += R0;
|
|
if (y > R1) y = R1;
|
|
if (y < R0) y = R0;
|
|
} else {
|
|
if (y > H-1) y = H-1;
|
|
if (y < 0) y = 0;
|
|
}
|
|
cursor.y = y;
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Relative cursor move
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_move(int dy, int dx, bool scroll)
|
|
{
|
|
NOTIFY_LOCK();
|
|
int move;
|
|
|
|
clear_invalid_hanging();
|
|
|
|
if (cursor.hanging && dx < 0) {
|
|
dx += 1; // consume one step on the removal of "xenl"
|
|
cursor.hanging = false;
|
|
}
|
|
|
|
bool was_inside = cursor_inside_region();
|
|
|
|
cursor.x += dx;
|
|
cursor.y += dy;
|
|
if (cursor.x >= (int)W) cursor.x = W - 1;
|
|
if (cursor.x < (int)0) {
|
|
if (cursor.auto_wrap && cursor.reverse_wraparound) {
|
|
// this is mimicking a behavior from xterm that allows any number of steps backwards with reverse wraparound enabled
|
|
int steps = -cursor.x;
|
|
if(steps > 1000) steps = 1; // avoid something stupid causing infinite loop here
|
|
for(;steps>0;steps--) {
|
|
if (cursor.x > 0) {
|
|
// backspace should go to col 79 if "hanging" after 80 (as if it never actually left the 80th col)
|
|
cursor.hanging = false;
|
|
cursor.x--;
|
|
}
|
|
else {
|
|
if (cursor.y > 0) {
|
|
// end of previous line
|
|
cursor.y--;
|
|
cursor.x = W - 1;
|
|
}
|
|
else {
|
|
// end of screen, end of line (wrap around)
|
|
cursor.y = R1;
|
|
cursor.x = W - 1;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
cursor.x = 0;
|
|
}
|
|
}
|
|
|
|
if (cursor.y < R0) {
|
|
if (was_inside) {
|
|
move = -(cursor.y - R0);
|
|
cursor.y = R0;
|
|
if (scroll) screen_scroll_down((unsigned int) move);
|
|
}
|
|
else {
|
|
// outside the region, just validate that we're not going offscreen
|
|
// scrolling is not possible in this case
|
|
if (cursor.y < 0) {
|
|
cursor.y = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (cursor.y > R1) {
|
|
if (was_inside) {
|
|
move = cursor.y - R1;
|
|
cursor.y = R1;
|
|
if (scroll) screen_scroll_up((unsigned int) move);
|
|
}
|
|
else {
|
|
// outside the region, just validate that we're not going offscreen
|
|
// scrolling is not possible in this case
|
|
if (cursor.y >= H) {
|
|
cursor.y = H-1;
|
|
}
|
|
}
|
|
}
|
|
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Save the cursor pos
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_save(bool withAttrs)
|
|
{
|
|
// always save with attribs
|
|
memcpy(&cursor_sav, &cursor, sizeof(CursorTypeDef));
|
|
cursor_saved = true;
|
|
}
|
|
|
|
/**
|
|
* Restore the cursor pos
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_cursor_restore(bool withAttrs)
|
|
{
|
|
NOTIFY_LOCK();
|
|
|
|
if (!cursor_saved) {
|
|
cursor_reset();
|
|
}
|
|
else {
|
|
if (withAttrs) {
|
|
memcpy(&cursor, &cursor_sav, sizeof(CursorTypeDef));
|
|
}
|
|
else {
|
|
cursor.x = cursor_sav.x;
|
|
cursor.y = cursor_sav.y;
|
|
cursor.hanging = cursor_sav.hanging;
|
|
}
|
|
}
|
|
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_back_index(int count)
|
|
{
|
|
NOTIFY_LOCK();
|
|
int new_x = cursor.x - count;
|
|
if (new_x >= 0) {
|
|
cursor.x = new_x;
|
|
} else {
|
|
cursor.x = 0;
|
|
screen_insert_characters(-new_x);
|
|
}
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
//endregion
|
|
|
|
//region --- Attribute setting ---
|
|
|
|
/**
|
|
* Enable cursor display
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_cursor_visible(bool visible)
|
|
{
|
|
NOTIFY_LOCK();
|
|
scr.cursor_visible = visible;
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* Enable autowrap
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_wrap_enable(bool enable)
|
|
{
|
|
cursor.auto_wrap = enable;
|
|
}
|
|
|
|
/**
|
|
* Enable reverse wraparound
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_reverse_wrap_enable(bool enable)
|
|
{
|
|
cursor.reverse_wraparound = enable;
|
|
}
|
|
|
|
/**
|
|
* Set cursor foreground color
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_fg(Color color)
|
|
{
|
|
if (color > COLOR_MAX) color = COLOR_MAX;
|
|
cursor.fg = color;
|
|
}
|
|
|
|
/**
|
|
* Set cursor background coloor
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_bg(Color color)
|
|
{
|
|
if (color > COLOR_MAX) color = COLOR_MAX;
|
|
cursor.bg = color;
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_sgr(u8 attrs, bool ena)
|
|
{
|
|
if (ena) {
|
|
cursor.attrs |= attrs;
|
|
}
|
|
else {
|
|
cursor.attrs &= ~attrs;
|
|
}
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_sgr_inverse(bool ena)
|
|
{
|
|
cursor.inverse = ena;
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_charset_n(int Gx)
|
|
{
|
|
if (Gx < 0 || Gx > 1) return; // bad n
|
|
cursor.charsetN = Gx;
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_charset(int Gx, char charset)
|
|
{
|
|
if (Gx == 0) cursor.charset0 = charset;
|
|
else if (Gx == 1) cursor.charset1 = charset;
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_insert_mode(bool insert)
|
|
{
|
|
scr.insert_mode = insert;
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_numpad_alt_mode(bool alt_mode)
|
|
{
|
|
NOTIFY_LOCK();
|
|
scr.numpad_alt_mode = alt_mode;
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_cursors_alt_mode(bool alt_mode)
|
|
{
|
|
NOTIFY_LOCK();
|
|
scr.cursors_alt_mode = alt_mode;
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_reverse_video(bool reverse)
|
|
{
|
|
NOTIFY_LOCK();
|
|
scr.reverse = reverse;
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_newline_mode(bool nlm)
|
|
{
|
|
scr.newline_mode = nlm;
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_set_origin_mode(bool region_origin)
|
|
{
|
|
cursor.origin_mode = region_origin;
|
|
screen_cursor_set(0, 0);
|
|
}
|
|
|
|
void ICACHE_FLASH_ATTR
|
|
screen_report_sgr(char *buffer)
|
|
{
|
|
buffer += sprintf(buffer, "0");
|
|
if (cursor.attrs & ATTR_BOLD) buffer += sprintf(buffer, ";%d", SGR_BOLD);
|
|
if (cursor.attrs & ATTR_FAINT) buffer += sprintf(buffer, ";%d", SGR_FAINT);
|
|
if (cursor.attrs & ATTR_ITALIC) buffer += sprintf(buffer, ";%d", SGR_ITALIC);
|
|
if (cursor.attrs & ATTR_UNDERLINE) buffer += sprintf(buffer, ";%d", SGR_UNDERLINE);
|
|
if (cursor.attrs & ATTR_BLINK) buffer += sprintf(buffer, ";%d", SGR_BLINK);
|
|
if (cursor.attrs & ATTR_FRAKTUR) buffer += sprintf(buffer, ";%d", SGR_FRAKTUR);
|
|
if (cursor.attrs & ATTR_STRIKE) buffer += sprintf(buffer, ";%d", SGR_STRIKE);
|
|
if (cursor.inverse) buffer += sprintf(buffer, ";%d", SGR_INVERSE);
|
|
if (cursor.fg != termconf->default_fg) buffer += sprintf(buffer, ";%d", ((cursor.fg > 7) ? SGR_FG_BRT_START : SGR_FG_START) + (cursor.fg&7));
|
|
if (cursor.bg != termconf->default_bg) buffer += sprintf(buffer, ";%d", ((cursor.bg > 7) ? SGR_BG_BRT_START : SGR_BG_START) + (cursor.bg&7));
|
|
}
|
|
|
|
//endregion
|
|
|
|
//region --- Printing ---
|
|
|
|
/**
|
|
* Set a character in the cursor color, move to right with wrap.
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screen_putchar(const char *ch)
|
|
{
|
|
NOTIFY_LOCK();
|
|
|
|
// clear "hanging" flag if not possible
|
|
clear_invalid_hanging();
|
|
|
|
// Special treatment for CRLF
|
|
switch (ch[0]) {
|
|
case CR:
|
|
screen_cursor_set_x(0);
|
|
goto done;
|
|
|
|
case LF:
|
|
screen_cursor_move(1, 0, true); // can scroll
|
|
if (scr.newline_mode) {
|
|
// like CR
|
|
screen_cursor_set_x(0);
|
|
}
|
|
goto done;
|
|
|
|
case BS:
|
|
screen_cursor_move(0, -1, false);
|
|
// we should not wrap around, and backspace should not even clear the cell (verified in xterm)
|
|
goto done;
|
|
|
|
default:
|
|
if (ch[0] < SP) {
|
|
// Discard
|
|
warn("Ignoring control char %d", (int)ch[0]);
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
if (cursor.hanging) {
|
|
// perform the scheduled wrap if hanging
|
|
// if auto-wrap = off, it overwrites the last char
|
|
if (cursor.auto_wrap) {
|
|
cursor.x = 0;
|
|
cursor.y++;
|
|
// Y wrap
|
|
if (cursor.y > R1) {
|
|
// Scroll up, so we have space for writing
|
|
screen_scroll_up(1);
|
|
cursor.y = R1;
|
|
}
|
|
|
|
cursor.hanging = false;
|
|
}
|
|
}
|
|
|
|
Cell *c = &screen[cursor.x + cursor.y * W];
|
|
|
|
// move the rest of the line if we're in Insert Mode
|
|
if (cursor.x < W-1 && scr.insert_mode) screen_insert_characters(1);
|
|
|
|
if (ch[1] == 0 && ch[0] <= 0x7f) {
|
|
// we have len=1 and ASCII
|
|
utf8_remap(c->c, ch[0], (cursor.charsetN == 0) ? cursor.charset0 : cursor.charset1);
|
|
}
|
|
else {
|
|
// copy unicode char
|
|
strncpy(c->c, ch, 4);
|
|
}
|
|
|
|
if (cursor.inverse) {
|
|
c->fg = cursor.bg;
|
|
c->bg = cursor.fg;
|
|
} else {
|
|
c->fg = cursor.fg;
|
|
c->bg = cursor.bg;
|
|
}
|
|
c->attrs = cursor.attrs;
|
|
|
|
cursor.x++;
|
|
// X wrap
|
|
if (cursor.x >= W) {
|
|
cursor.hanging = true; // hanging - next typed char wraps around, but backspace and arrows still stay on the same line.
|
|
cursor.x = W - 1;
|
|
}
|
|
|
|
done:
|
|
NOTIFY_DONE();
|
|
}
|
|
|
|
/**
|
|
* UTF remap
|
|
* @param out - output char[4]
|
|
* @param g - ASCII char
|
|
* @param charset - table name (0, A, B)
|
|
*/
|
|
static void ICACHE_FLASH_ATTR
|
|
utf8_remap(char *out, char g, char charset)
|
|
{
|
|
u16 n;
|
|
u16 utf = (unsigned char)g;
|
|
|
|
switch (charset) {
|
|
case CS_0_DEC_SUPPLEMENTAL: /* DEC Special Character & Line Drawing Set */
|
|
if ((g >= CODEPAGE_0_BEGIN) && (g <= CODEPAGE_0_END)) {
|
|
n = codepage_0[g - CODEPAGE_0_BEGIN];
|
|
if (n) utf = n;
|
|
}
|
|
break;
|
|
|
|
case CS_1_DOS_437: /* ESPTerm Character Rom 1 */
|
|
if ((g >= CODEPAGE_1_BEGIN) && (g <= CODEPAGE_1_END)) {
|
|
n = codepage_1[g - CODEPAGE_1_BEGIN];
|
|
if (n) utf = n;
|
|
}
|
|
break;
|
|
|
|
case CS_A_UKASCII: /* UK, replaces # with GBP */
|
|
if ((g >= CODEPAGE_A_BEGIN) && (g <= CODEPAGE_A_END)) {
|
|
n = codepage_A[g - CODEPAGE_A_BEGIN];
|
|
if (n) utf = n;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
case CS_B_USASCII:
|
|
// No change
|
|
break;
|
|
}
|
|
|
|
// Encode to UTF-8
|
|
if (utf > 0x7F) {
|
|
// formulas taken from: https://gist.github.com/yamamushi/5823402
|
|
if ((utf >= 0x80) && (utf <= 0x07FF)) {
|
|
// 2-byte unicode
|
|
out[0] = (char) ((utf >> 0x06) ^ 0xC0);
|
|
out[1] = (char) (((utf ^ 0xFFC0) | 0x80) & ~0x40);
|
|
out[2]=0;
|
|
}
|
|
else {
|
|
// 3-byte unicode
|
|
out[0] = (char) (((utf ^ 0xFC0FFF) >> 0x0C) | 0xE0);
|
|
out[1] = (char) ((((utf ^ 0xFFF03F) >> 0x06) | 0x80) & ~0x40);
|
|
out[2] = (char) (((utf ^ 0xFFFC0) | 0x80) & ~0x40);
|
|
out[3]=0;
|
|
}
|
|
// Missing 4-byte formulas :(
|
|
} else {
|
|
// low ASCII
|
|
out[0] = (char) utf;
|
|
out[1] = 0;
|
|
}
|
|
}
|
|
//endregion
|
|
|
|
//region --- Serialization ---
|
|
|
|
struct ScreenSerializeState {
|
|
Color lastFg;
|
|
Color lastBg;
|
|
bool lastAttrs;
|
|
char lastChar[4];
|
|
int index;
|
|
};
|
|
|
|
/**
|
|
* buffer should be at least 64+5*10+6 long (title + buttons + 6), ie. 120
|
|
* @param buffer
|
|
* @param buf_len
|
|
*/
|
|
void ICACHE_FLASH_ATTR
|
|
screenSerializeLabelsToBuffer(char *buffer, size_t buf_len)
|
|
{
|
|
// let's just assume it's long enough - called with the huge websocket buffer
|
|
sprintf(buffer, "T%s\x01%s\x01%s\x01%s\x01%s\x01%s", // use 0x01 as separator
|
|
termconf_scratch.title,
|
|
termconf_scratch.btn[0],
|
|
termconf_scratch.btn[1],
|
|
termconf_scratch.btn[2],
|
|
termconf_scratch.btn[3],
|
|
termconf_scratch.btn[4]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Serialize the screen to a data buffer. May need multiple calls if the buffer is insufficient in size.
|
|
*
|
|
* @warning MAKE SURE *DATA IS NULL BEFORE FIRST CALL!
|
|
* Call with NULL 'buffer' at the end to free the data struct.
|
|
*
|
|
* @param buffer - buffer array of limited size. If NULL, indicates this is the last call.
|
|
* @param buf_len - buffer array size
|
|
* @param data - opaque pointer to internal data structure for storing state between repeated calls
|
|
* if NULL, indicates this is the first call.
|
|
* @return HTTPD_CGI_DONE or HTTPD_CGI_MORE. If more, repeat with the same DATA.
|
|
*/
|
|
httpd_cgi_state ICACHE_FLASH_ATTR
|
|
screenSerializeToBuffer(char *buffer, size_t buf_len, void **data)
|
|
{
|
|
struct ScreenSerializeState *ss = *data;
|
|
|
|
if (buffer == NULL) {
|
|
if (ss != NULL) free(ss);
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
|
|
Cell *cell, *cell0;
|
|
WordB2 w1;
|
|
WordB3 lw1;
|
|
|
|
size_t remain = buf_len;
|
|
char *bb = buffer;
|
|
|
|
#define bufput_c(c) do { \
|
|
*bb = (char)c; bb++; \
|
|
remain--; \
|
|
} while(0)
|
|
|
|
#define bufput_2B(n) do { \
|
|
encode2B((u16) n, &w1); \
|
|
bufput_c(w1.lsb); \
|
|
bufput_c(w1.msb); \
|
|
} while(0)
|
|
|
|
#define bufput_3B(n) do { \
|
|
encode3B((u16) n, &lw1); \
|
|
bufput_c(lw1.lsb); \
|
|
bufput_c(lw1.msb); \
|
|
bufput_c(lw1.xsb); \
|
|
} while(0)
|
|
|
|
#define bufput_t2B(t, n) do { \
|
|
bufput_c(t); \
|
|
bufput_2B(n); \
|
|
} while(0)
|
|
|
|
#define bufput_t3B(t, n) do { \
|
|
bufput_c(t); \
|
|
bufput_3B(n); \
|
|
} while(0)
|
|
|
|
if (ss == NULL) {
|
|
*data = ss = malloc(sizeof(struct ScreenSerializeState));
|
|
ss->index = 0;
|
|
ss->lastBg = 0;
|
|
ss->lastFg = 0;
|
|
ss->lastAttrs = 0;
|
|
memset(ss->lastChar, 0, 4); // this ensures the first char is never "repeat"
|
|
|
|
bufput_c('S');
|
|
// H W X Y Attribs
|
|
bufput_2B(H);
|
|
bufput_2B(W);
|
|
bufput_2B(cursor.y);
|
|
bufput_2B(cursor.x);
|
|
bufput_2B(
|
|
(scr.cursor_visible ? 1<<0 : 0) |
|
|
(cursor.hanging ? 1<<1 : 0) |
|
|
(scr.cursors_alt_mode ? 1<<2 : 0) |
|
|
(scr.numpad_alt_mode ? 1<<3 : 0) |
|
|
(termconf->fn_alt_mode ? 1<<4 : 0) |
|
|
((mouse_tracking.mode>MTM_NONE) ? 1<<5 : 0) | // disables context menu
|
|
((mouse_tracking.mode>=MTM_NORMAL) ? 1<<6 : 0) | // disables selecting
|
|
(termconf_scratch.show_buttons ? 1<<7 : 0) |
|
|
(termconf_scratch.show_config_links ? 1<<8 : 0) |
|
|
((scr.cursor_shape&0x03)<<9) // 9,10,11 - cursor shape based on DECSCUSR
|
|
);
|
|
}
|
|
|
|
int i = ss->index;
|
|
while(i < W*H && remain > 12) {
|
|
cell = cell0 = &screen[i];
|
|
|
|
// Count how many times same as previous
|
|
int repCnt = 0;
|
|
while (i < W*H
|
|
&& cell->fg == ss->lastFg
|
|
&& cell->bg == ss->lastBg
|
|
&& cell->attrs == ss->lastAttrs
|
|
&& strneq(cell->c, ss->lastChar, 4)) {
|
|
// Repeat
|
|
repCnt++;
|
|
cell = &screen[++i];
|
|
}
|
|
|
|
if (repCnt == 0) {
|
|
// No repeat
|
|
bool changeAttrs = cell0->attrs != ss->lastAttrs;
|
|
bool changeColors = (cell0->fg != ss->lastFg || cell0->bg != ss->lastBg);
|
|
Color fg, bg;
|
|
|
|
// Reverse fg and bg if we're in global reverse mode
|
|
if (! scr.reverse) {
|
|
fg = cell0->fg;
|
|
bg = cell0->bg;
|
|
}
|
|
else {
|
|
fg = cell0->bg;
|
|
bg = cell0->fg;
|
|
}
|
|
|
|
if (!changeAttrs && changeColors) {
|
|
bufput_t2B('\x03', fg | (bg<<4));
|
|
}
|
|
else if (changeAttrs && !changeColors) {
|
|
// attrs only
|
|
bufput_t2B('\x04', cell0->attrs);
|
|
}
|
|
else if (changeAttrs && changeColors) {
|
|
// colors and attrs
|
|
bufput_t3B('\x01', (u32) (fg | (bg<<4) | (cell0->attrs<<8)));
|
|
}
|
|
|
|
// copy the symbol, until first 0 or reached 4 bytes
|
|
char c;
|
|
for(int j=0; j<4; j++) {
|
|
c = cell->c[j];
|
|
if(!c) break;
|
|
bufput_c(c);
|
|
}
|
|
|
|
ss->lastFg = cell0->fg;
|
|
ss->lastBg = cell0->bg;
|
|
ss->lastAttrs = cell0->attrs;
|
|
memcpy(ss->lastChar, cell0->c, 4);
|
|
|
|
i++;
|
|
} else {
|
|
// Repeat count
|
|
bufput_t2B('\x02', repCnt);
|
|
}
|
|
}
|
|
|
|
ss->index = i;
|
|
bufput_c('\0'); // terminate the string
|
|
|
|
if (i < W*H-1) {
|
|
return HTTPD_CGI_MORE;
|
|
}
|
|
|
|
return HTTPD_CGI_DONE;
|
|
}
|
|
//endregion
|
|
|