mirror of
https://github.com/tuxbox-fork-migrations/recycled-ni-neutrino.git
synced 2025-09-01 01:41:12 +02:00
46bbcebef9
Origin commit data
------------------
Commit: 0de439f466
Author: Stefan Seyfried <seife@tuxbox-git.slipkontur.de>
Date: 2018-01-28 (Sun, 28 Jan 2018)
412 lines
8.7 KiB
C++
412 lines
8.7 KiB
C++
/*
|
|
* yaft framebuffer terminal as C++ class for embedding in neutrino-MP
|
|
* (C) 2018 Stefan Seyfried
|
|
* License: GPL-2.0
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
* derived from yaft/ctrlseq/csi.h
|
|
* original code
|
|
* Copyright (c) 2012 haru <uobikiemukot at gmail dot com>
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
* persons to whom the Software is furnished to do so, subject to the
|
|
* following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*/
|
|
#include "yaft_priv.h"
|
|
#include <cstring>
|
|
|
|
/* function for csi sequence */
|
|
void YaFT_p::insert_blank(struct parm_t *parm)
|
|
{
|
|
int i, num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
for (i = cols - 1; cursor.x <= i; i--) {
|
|
if (cursor.x <= (i - num))
|
|
copy_cell(cursor.y, i, cursor.y, i - num);
|
|
else
|
|
erase_cell(cursor.y, i);
|
|
}
|
|
}
|
|
|
|
void YaFT_p::curs_up(struct parm_t *parm)
|
|
{
|
|
int num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
move_cursor(-num, 0);
|
|
}
|
|
|
|
void YaFT_p::curs_down(struct parm_t *parm)
|
|
{
|
|
int num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
move_cursor(num, 0);
|
|
}
|
|
|
|
void YaFT_p::curs_forward(struct parm_t *parm)
|
|
{
|
|
int num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
move_cursor(0, num);
|
|
}
|
|
|
|
void YaFT_p::curs_back(struct parm_t *parm)
|
|
{
|
|
int num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
move_cursor(0, -num);
|
|
}
|
|
|
|
void YaFT_p::curs_nl(struct parm_t *parm)
|
|
{
|
|
int num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
move_cursor(num, 0);
|
|
cr();
|
|
}
|
|
|
|
void YaFT_p::curs_pl(struct parm_t *parm)
|
|
{
|
|
int num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
move_cursor(-num, 0);
|
|
cr();
|
|
}
|
|
|
|
void YaFT_p::curs_col(struct parm_t *parm)
|
|
{
|
|
int num;
|
|
|
|
num = (parm->argc <= 0) ? 0 : dec2num(parm->argv[parm->argc - 1]) - 1;
|
|
set_cursor(cursor.y, num);
|
|
}
|
|
|
|
void YaFT_p::curs_pos(struct parm_t *parm)
|
|
{
|
|
int line, col;
|
|
|
|
if (parm->argc <= 0) {
|
|
line = col = 0;
|
|
} else if (parm->argc == 2) {
|
|
line = dec2num(parm->argv[0]) - 1;
|
|
col = dec2num(parm->argv[1]) - 1;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
if (line < 0)
|
|
line = 0;
|
|
if (col < 0)
|
|
col = 0;
|
|
|
|
set_cursor(line, col);
|
|
}
|
|
|
|
void YaFT_p::curs_line(struct parm_t *parm)
|
|
{
|
|
int num;
|
|
|
|
num = (parm->argc <= 0) ? 0 : dec2num(parm->argv[parm->argc - 1]) - 1;
|
|
set_cursor(num, cursor.x);
|
|
}
|
|
|
|
void YaFT_p::erase_display(struct parm_t *parm)
|
|
{
|
|
int i, j, pmode;
|
|
|
|
pmode = (parm->argc <= 0) ? 0 : dec2num(parm->argv[parm->argc - 1]);
|
|
|
|
if (pmode < 0 || 2 < pmode)
|
|
return;
|
|
|
|
if (pmode == 0) {
|
|
for (i = cursor.y; i < lines; i++)
|
|
for (j = 0; j < cols; j++)
|
|
if (i > cursor.y || (i == cursor.y && j >= cursor.x))
|
|
erase_cell(i, j);
|
|
} else if (pmode == 1) {
|
|
for (i = 0; i <= cursor.y; i++)
|
|
for (j = 0; j < cols; j++)
|
|
if (i < cursor.y || (i == cursor.y && j <= cursor.x))
|
|
erase_cell(i, j);
|
|
} else if (pmode == 2) {
|
|
for (i = 0; i < lines; i++)
|
|
for (j = 0; j < cols; j++)
|
|
erase_cell(i, j);
|
|
}
|
|
}
|
|
|
|
void YaFT_p::erase_line(struct parm_t *parm)
|
|
{
|
|
int i, pmode;
|
|
|
|
pmode = (parm->argc <= 0) ? 0 : dec2num(parm->argv[parm->argc - 1]);
|
|
|
|
if (pmode < 0 || 2 < pmode)
|
|
return;
|
|
|
|
if (pmode == 0) {
|
|
for (i = cursor.x; i < cols; i++)
|
|
erase_cell(cursor.y, i);
|
|
} else if (pmode == 1) {
|
|
for (i = 0; i <= cursor.x; i++)
|
|
erase_cell(cursor.y, i);
|
|
} else if (pmode == 2) {
|
|
for (i = 0; i < cols; i++)
|
|
erase_cell(cursor.y, i);
|
|
}
|
|
}
|
|
|
|
void YaFT_p::insert_line(struct parm_t *parm)
|
|
{
|
|
int num = sum(parm);
|
|
|
|
if (mode & MODE_ORIGIN) {
|
|
if (cursor.y < scrollm.top
|
|
|| cursor.y > scrollm.bottom)
|
|
return;
|
|
}
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
scroll(cursor.y, scrollm.bottom, -num);
|
|
}
|
|
|
|
void YaFT_p::delete_line(struct parm_t *parm)
|
|
{
|
|
int num = sum(parm);
|
|
|
|
if (mode & MODE_ORIGIN) {
|
|
if (cursor.y < scrollm.top
|
|
|| cursor.y > scrollm.bottom)
|
|
return;
|
|
}
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
scroll(cursor.y, scrollm.bottom, num);
|
|
}
|
|
|
|
void YaFT_p::delete_char(struct parm_t *parm)
|
|
{
|
|
int i, num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
|
|
for (i = cursor.x; i < cols; i++) {
|
|
if ((i + num) < cols)
|
|
copy_cell(cursor.y, i, cursor.y, i + num);
|
|
else
|
|
erase_cell(cursor.y, i);
|
|
}
|
|
}
|
|
|
|
void YaFT_p::erase_char(struct parm_t *parm)
|
|
{
|
|
int i, num = sum(parm);
|
|
|
|
if (num <= 0)
|
|
num = 1;
|
|
else if (num + cursor.x > cols)
|
|
num = cols - cursor.x;
|
|
|
|
for (i = cursor.x; i < cursor.x + num; i++)
|
|
erase_cell(cursor.y, i);
|
|
}
|
|
|
|
void YaFT_p::set_attr(struct parm_t *parm)
|
|
{
|
|
int i, num;
|
|
|
|
if (parm->argc <= 0) {
|
|
attribute = ATTR_RESET;
|
|
color_pair.fg = DEFAULT_FG;
|
|
color_pair.bg = DEFAULT_BG;
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < parm->argc; i++) {
|
|
num = dec2num(parm->argv[i]);
|
|
|
|
if (num == 0) { /* reset all attribute and color */
|
|
attribute = ATTR_RESET;
|
|
color_pair.fg = DEFAULT_FG;
|
|
color_pair.bg = DEFAULT_BG;
|
|
} else if (1 <= num && num <= 7) { /* set attribute */
|
|
attribute |= attr_mask[num];
|
|
} else if (21 <= num && num <= 27) { /* reset attribute */
|
|
attribute &= ~attr_mask[num - 20];
|
|
} else if (30 <= num && num <= 37) { /* set foreground */
|
|
color_pair.fg = (num - 30);
|
|
} else if (num == 38) { /* set 256 color to foreground */
|
|
if ((i + 2) < parm->argc && dec2num(parm->argv[i + 1]) == 5) {
|
|
color_pair.fg = dec2num(parm->argv[i + 2]);
|
|
i += 2;
|
|
}
|
|
} else if (num == 39) { /* reset foreground */
|
|
color_pair.fg = DEFAULT_FG;
|
|
} else if (40 <= num && num <= 47) { /* set background */
|
|
color_pair.bg = (num - 40);
|
|
} else if (num == 48) { /* set 256 color to background */
|
|
if ((i + 2) < parm->argc && dec2num(parm->argv[i + 1]) == 5) {
|
|
color_pair.bg = dec2num(parm->argv[i + 2]);
|
|
i += 2;
|
|
}
|
|
} else if (num == 49) { /* reset background */
|
|
color_pair.bg = DEFAULT_BG;
|
|
} else if (90 <= num && num <= 97) { /* set bright foreground */
|
|
color_pair.fg = (num - 90) + BRIGHT_INC;
|
|
} else if (100 <= num && num <= 107) { /* set bright background */
|
|
color_pair.bg = (num - 100) + BRIGHT_INC;
|
|
}
|
|
}
|
|
}
|
|
|
|
void YaFT_p::status_report(struct parm_t *parm)
|
|
{
|
|
int i, num;
|
|
char buf[BUFSIZE];
|
|
|
|
for (i = 0; i < parm->argc; i++) {
|
|
num = dec2num(parm->argv[i]);
|
|
if (num == 5) { /* terminal response: ready */
|
|
write(fd, "\033[0n", 4);
|
|
} else if (num == 6) { /* cursor position report */
|
|
snprintf(buf, BUFSIZE, "\033[%d;%dR", cursor.y + 1, cursor.x + 1);
|
|
write(fd, buf, strlen(buf));
|
|
} else if (num == 15) { /* terminal response: printer not connected */
|
|
write(fd, "\033[?13n", 6);
|
|
}
|
|
}
|
|
}
|
|
|
|
void YaFT_p::device_attribute(struct parm_t *parm)
|
|
{
|
|
if (parm->argc > 0 && dec2num(parm->argv[0]))
|
|
return; /* compatibility with linux console */
|
|
write(fd, "\033[?6c", 5); /* "I am a VT102" */
|
|
}
|
|
|
|
void YaFT_p::set_mode(struct parm_t *parm)
|
|
{
|
|
int i, pmode;
|
|
|
|
for (i = 0; i < parm->argc; i++) {
|
|
pmode = dec2num(parm->argv[i]);
|
|
if (esc.buf[1] != '?')
|
|
continue; /* not supported */
|
|
|
|
if (pmode == 6) { /* private mode */
|
|
mode |= MODE_ORIGIN;
|
|
set_cursor(0, 0);
|
|
} else if (pmode == 7) {
|
|
mode |= MODE_AMRIGHT;
|
|
} else if (pmode == 25) {
|
|
mode |= MODE_CURSOR;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void YaFT_p::reset_mode(struct parm_t *parm)
|
|
{
|
|
int i, pmode;
|
|
|
|
for (i = 0; i < parm->argc; i++) {
|
|
pmode = dec2num(parm->argv[i]);
|
|
if (esc.buf[1] != '?')
|
|
continue; /* not supported */
|
|
|
|
if (pmode == 6) { /* private mode */
|
|
mode &= ~MODE_ORIGIN;
|
|
set_cursor(0, 0);
|
|
} else if (pmode == 7) {
|
|
mode &= ~MODE_AMRIGHT;
|
|
wrap_occured = false;
|
|
} else if (pmode == 25) {
|
|
mode &= ~MODE_CURSOR;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void YaFT_p::set_margin(struct parm_t *parm)
|
|
{
|
|
int top, bottom;
|
|
|
|
if (parm->argc <= 0) { /* CSI r */
|
|
top = 0;
|
|
bottom = lines - 1;
|
|
} else if (parm->argc == 2) { /* CSI ; r -> use default value */
|
|
top = parm->argv[0].empty() ? 0 : dec2num(parm->argv[0]) - 1;
|
|
bottom = parm->argv[1].empty() ? lines - 1 : dec2num(parm->argv[1]) - 1;
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
if (top < 0 || top >= lines)
|
|
top = 0;
|
|
if (bottom < 0 || bottom >= lines)
|
|
bottom = lines - 1;
|
|
|
|
if (top >= bottom)
|
|
return;
|
|
|
|
scrollm.top = top;
|
|
scrollm.bottom = bottom;
|
|
|
|
set_cursor(0, 0); /* move cursor to home */
|
|
}
|
|
|
|
void YaFT_p::clear_tabstop(struct parm_t *parm)
|
|
{
|
|
int i, j, num;
|
|
|
|
if (parm->argc <= 0) {
|
|
tabstop[cursor.x] = false;
|
|
} else {
|
|
for (i = 0; i < parm->argc; i++) {
|
|
num = dec2num(parm->argv[i]);
|
|
if (num == 0) {
|
|
tabstop[cursor.x] = false;
|
|
} else if (num == 3) {
|
|
for (j = 0; j < cols; j++)
|
|
tabstop[j] = false;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|