1315 lines
39 KiB
C
1315 lines
39 KiB
C
// widgetAnsiTerm.c — ANSI BBS terminal emulator widget
|
|
|
|
#include "widgetInternal.h"
|
|
|
|
|
|
// ============================================================
|
|
// Constants
|
|
// ============================================================
|
|
|
|
#define ANSI_BORDER 2
|
|
#define ANSI_MAX_PARAMS 8
|
|
#define ANSI_SB_W 14
|
|
#define ANSI_DEFAULT_SCROLLBACK 500
|
|
|
|
#define PARSE_NORMAL 0
|
|
#define PARSE_ESC 1
|
|
#define PARSE_CSI 2
|
|
|
|
// Default attribute: light gray on black
|
|
#define ANSI_DEFAULT_ATTR 0x07
|
|
|
|
// ============================================================
|
|
// CGA palette (RGB values for 16 standard colors)
|
|
// ============================================================
|
|
|
|
static const uint8_t sCgaPalette[16][3] = {
|
|
{ 0, 0, 0}, // 0: black
|
|
{ 0, 0, 170}, // 1: blue
|
|
{ 0, 170, 0}, // 2: green
|
|
{ 0, 170, 170}, // 3: cyan
|
|
{170, 0, 0}, // 4: red
|
|
{170, 0, 170}, // 5: magenta
|
|
{170, 85, 0}, // 6: brown
|
|
{170, 170, 170}, // 7: light gray
|
|
{ 85, 85, 85}, // 8: dark gray
|
|
{ 85, 85, 255}, // 9: bright blue
|
|
{ 85, 255, 85}, // 10: bright green
|
|
{ 85, 255, 255}, // 11: bright cyan
|
|
{255, 85, 85}, // 12: bright red
|
|
{255, 85, 255}, // 13: bright magenta
|
|
{255, 255, 85}, // 14: bright yellow
|
|
{255, 255, 255}, // 15: bright white
|
|
};
|
|
|
|
// ANSI SGR color index to CGA color index
|
|
static const int32_t sAnsiToCga[8] = { 0, 4, 2, 6, 1, 5, 3, 7 };
|
|
|
|
|
|
// ============================================================
|
|
// Prototypes
|
|
// ============================================================
|
|
|
|
static void ansiTermAddToScrollback(WidgetT *w, int32_t screenRow);
|
|
static void ansiTermDeleteLines(WidgetT *w, int32_t count);
|
|
static void ansiTermDirtyAll(WidgetT *w);
|
|
static void ansiTermDirtyRange(WidgetT *w, int32_t startCell, int32_t count);
|
|
static void ansiTermDirtyRow(WidgetT *w, int32_t row);
|
|
static void ansiTermDispatchCsi(WidgetT *w, uint8_t cmd);
|
|
static void ansiTermEraseDisplay(WidgetT *w, int32_t mode);
|
|
static void ansiTermEraseLine(WidgetT *w, int32_t mode);
|
|
static void ansiTermFillCells(WidgetT *w, int32_t start, int32_t count);
|
|
static const uint8_t *ansiTermGetLine(WidgetT *w, int32_t lineIndex);
|
|
static void ansiTermInsertLines(WidgetT *w, int32_t count);
|
|
static void ansiTermNewline(WidgetT *w);
|
|
static void ansiTermProcessByte(WidgetT *w, uint8_t ch);
|
|
static void ansiTermProcessSgr(WidgetT *w);
|
|
static void ansiTermPutChar(WidgetT *w, uint8_t ch);
|
|
static void ansiTermScrollDown(WidgetT *w);
|
|
static void ansiTermScrollUp(WidgetT *w);
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermAddToScrollback
|
|
// ============================================================
|
|
//
|
|
// Copy a screen row into the scrollback circular buffer.
|
|
|
|
static void ansiTermAddToScrollback(WidgetT *w, int32_t screenRow) {
|
|
if (!w->as.ansiTerm.scrollback || w->as.ansiTerm.scrollbackMax <= 0) {
|
|
return;
|
|
}
|
|
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t bytesPerRow = cols * 2;
|
|
int32_t head = w->as.ansiTerm.scrollbackHead;
|
|
|
|
memcpy(w->as.ansiTerm.scrollback + head * bytesPerRow,
|
|
w->as.ansiTerm.cells + screenRow * bytesPerRow,
|
|
bytesPerRow);
|
|
|
|
w->as.ansiTerm.scrollbackHead = (head + 1) % w->as.ansiTerm.scrollbackMax;
|
|
|
|
if (w->as.ansiTerm.scrollbackCount < w->as.ansiTerm.scrollbackMax) {
|
|
w->as.ansiTerm.scrollbackCount++;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermDirtyAll
|
|
// ============================================================
|
|
|
|
static void ansiTermDirtyAll(WidgetT *w) {
|
|
w->as.ansiTerm.dirtyRows = 0xFFFFFFFF;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermDirtyRange
|
|
// ============================================================
|
|
//
|
|
// Mark rows dirty that are touched by a cell range [startCell, startCell+count).
|
|
|
|
static void ansiTermDirtyRange(WidgetT *w, int32_t startCell, int32_t count) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t startRow = startCell / cols;
|
|
int32_t endRow = (startCell + count - 1) / cols;
|
|
|
|
for (int32_t r = startRow; r <= endRow && r < 32; r++) {
|
|
w->as.ansiTerm.dirtyRows |= (1U << r);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermDirtyRow
|
|
// ============================================================
|
|
|
|
static void ansiTermDirtyRow(WidgetT *w, int32_t row) {
|
|
if (row >= 0 && row < 32) {
|
|
w->as.ansiTerm.dirtyRows |= (1U << row);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermDeleteLines
|
|
// ============================================================
|
|
|
|
static void ansiTermDeleteLines(WidgetT *w, int32_t count) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
int32_t row = w->as.ansiTerm.cursorRow;
|
|
|
|
if (count > rows - row) {
|
|
count = rows - row;
|
|
}
|
|
|
|
if (count <= 0) {
|
|
return;
|
|
}
|
|
|
|
uint8_t *cells = w->as.ansiTerm.cells;
|
|
|
|
// Shift lines up
|
|
int32_t bytesPerRow = cols * 2;
|
|
memmove(cells + row * bytesPerRow,
|
|
cells + (row + count) * bytesPerRow,
|
|
(rows - row - count) * bytesPerRow);
|
|
|
|
// Clear the bottom lines
|
|
for (int32_t r = rows - count; r < rows; r++) {
|
|
ansiTermFillCells(w, r * cols, cols);
|
|
}
|
|
|
|
// All rows from cursorRow down are affected
|
|
for (int32_t r = row; r < rows; r++) {
|
|
ansiTermDirtyRow(w, r);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermDispatchCsi
|
|
// ============================================================
|
|
|
|
static void ansiTermDispatchCsi(WidgetT *w, uint8_t cmd) {
|
|
int32_t *p = w->as.ansiTerm.params;
|
|
int32_t n = w->as.ansiTerm.paramCount;
|
|
|
|
// DEC private modes (ESC[?...)
|
|
if (w->as.ansiTerm.csiPrivate) {
|
|
int32_t mode = (n >= 1) ? p[0] : 0;
|
|
|
|
if (cmd == 'h') {
|
|
if (mode == 7) {
|
|
w->as.ansiTerm.wrapMode = true;
|
|
}
|
|
|
|
if (mode == 25) {
|
|
w->as.ansiTerm.cursorVisible = true;
|
|
}
|
|
} else if (cmd == 'l') {
|
|
if (mode == 7) {
|
|
w->as.ansiTerm.wrapMode = false;
|
|
}
|
|
|
|
if (mode == 25) {
|
|
w->as.ansiTerm.cursorVisible = false;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
switch (cmd) {
|
|
case 'A': // CUU - cursor up
|
|
{
|
|
int32_t count = (n >= 1 && p[0]) ? p[0] : 1;
|
|
w->as.ansiTerm.cursorRow -= count;
|
|
|
|
if (w->as.ansiTerm.cursorRow < 0) {
|
|
w->as.ansiTerm.cursorRow = 0;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 'B': // CUD - cursor down
|
|
{
|
|
int32_t count = (n >= 1 && p[0]) ? p[0] : 1;
|
|
w->as.ansiTerm.cursorRow += count;
|
|
|
|
if (w->as.ansiTerm.cursorRow >= w->as.ansiTerm.rows) {
|
|
w->as.ansiTerm.cursorRow = w->as.ansiTerm.rows - 1;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 'C': // CUF - cursor forward
|
|
{
|
|
int32_t count = (n >= 1 && p[0]) ? p[0] : 1;
|
|
w->as.ansiTerm.cursorCol += count;
|
|
|
|
if (w->as.ansiTerm.cursorCol >= w->as.ansiTerm.cols) {
|
|
w->as.ansiTerm.cursorCol = w->as.ansiTerm.cols - 1;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 'D': // CUB - cursor back
|
|
{
|
|
int32_t count = (n >= 1 && p[0]) ? p[0] : 1;
|
|
w->as.ansiTerm.cursorCol -= count;
|
|
|
|
if (w->as.ansiTerm.cursorCol < 0) {
|
|
w->as.ansiTerm.cursorCol = 0;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 'H': // CUP - cursor position
|
|
case 'f': // HVP - same
|
|
{
|
|
int32_t row = (n >= 1 && p[0]) ? p[0] - 1 : 0;
|
|
int32_t col = (n >= 2 && p[1]) ? p[1] - 1 : 0;
|
|
|
|
if (row < 0) {
|
|
row = 0;
|
|
}
|
|
|
|
if (row >= w->as.ansiTerm.rows) {
|
|
row = w->as.ansiTerm.rows - 1;
|
|
}
|
|
|
|
if (col < 0) {
|
|
col = 0;
|
|
}
|
|
|
|
if (col >= w->as.ansiTerm.cols) {
|
|
col = w->as.ansiTerm.cols - 1;
|
|
}
|
|
|
|
w->as.ansiTerm.cursorRow = row;
|
|
w->as.ansiTerm.cursorCol = col;
|
|
break;
|
|
}
|
|
|
|
case 'J': // ED - erase display
|
|
{
|
|
int32_t mode = (n >= 1) ? p[0] : 0;
|
|
ansiTermEraseDisplay(w, mode);
|
|
break;
|
|
}
|
|
|
|
case 'K': // EL - erase line
|
|
{
|
|
int32_t mode = (n >= 1) ? p[0] : 0;
|
|
ansiTermEraseLine(w, mode);
|
|
break;
|
|
}
|
|
|
|
case 'L': // IL - insert lines
|
|
{
|
|
int32_t count = (n >= 1 && p[0]) ? p[0] : 1;
|
|
ansiTermInsertLines(w, count);
|
|
break;
|
|
}
|
|
|
|
case 'M': // DL - delete lines
|
|
{
|
|
int32_t count = (n >= 1 && p[0]) ? p[0] : 1;
|
|
ansiTermDeleteLines(w, count);
|
|
break;
|
|
}
|
|
|
|
case 'S': // SU - scroll up
|
|
{
|
|
int32_t count = (n >= 1 && p[0]) ? p[0] : 1;
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
ansiTermScrollUp(w);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 'T': // SD - scroll down
|
|
{
|
|
int32_t count = (n >= 1 && p[0]) ? p[0] : 1;
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
ansiTermScrollDown(w);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 'm': // SGR - select graphic rendition
|
|
ansiTermProcessSgr(w);
|
|
break;
|
|
|
|
case 's': // SCP - save cursor position
|
|
w->as.ansiTerm.savedRow = w->as.ansiTerm.cursorRow;
|
|
w->as.ansiTerm.savedCol = w->as.ansiTerm.cursorCol;
|
|
break;
|
|
|
|
case 'u': // RCP - restore cursor position
|
|
w->as.ansiTerm.cursorRow = w->as.ansiTerm.savedRow;
|
|
w->as.ansiTerm.cursorCol = w->as.ansiTerm.savedCol;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermEraseDisplay
|
|
// ============================================================
|
|
|
|
static void ansiTermEraseDisplay(WidgetT *w, int32_t mode) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
int32_t cur = w->as.ansiTerm.cursorRow * cols + w->as.ansiTerm.cursorCol;
|
|
|
|
if (mode == 0) {
|
|
// Erase from cursor to end of screen
|
|
ansiTermFillCells(w, cur, cols * rows - cur);
|
|
} else if (mode == 1) {
|
|
// Erase from start to cursor
|
|
ansiTermFillCells(w, 0, cur + 1);
|
|
} else if (mode == 2) {
|
|
// Erase entire screen — push all lines to scrollback first
|
|
bool wasAtBottom = (w->as.ansiTerm.scrollPos == w->as.ansiTerm.scrollbackCount);
|
|
|
|
for (int32_t r = 0; r < rows; r++) {
|
|
ansiTermAddToScrollback(w, r);
|
|
}
|
|
|
|
if (wasAtBottom) {
|
|
w->as.ansiTerm.scrollPos = w->as.ansiTerm.scrollbackCount;
|
|
}
|
|
|
|
ansiTermFillCells(w, 0, cols * rows);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermEraseLine
|
|
// ============================================================
|
|
|
|
static void ansiTermEraseLine(WidgetT *w, int32_t mode) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t row = w->as.ansiTerm.cursorRow;
|
|
int32_t col = w->as.ansiTerm.cursorCol;
|
|
int32_t base = row * cols;
|
|
|
|
if (mode == 0) {
|
|
// Erase from cursor to end of line
|
|
ansiTermFillCells(w, base + col, cols - col);
|
|
} else if (mode == 1) {
|
|
// Erase from start of line to cursor
|
|
ansiTermFillCells(w, base, col + 1);
|
|
} else if (mode == 2) {
|
|
// Erase entire line
|
|
ansiTermFillCells(w, base, cols);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermFillCells
|
|
// ============================================================
|
|
//
|
|
// Fill a range of cells with space + current attribute.
|
|
|
|
static void ansiTermFillCells(WidgetT *w, int32_t start, int32_t count) {
|
|
uint8_t *cells = w->as.ansiTerm.cells;
|
|
uint8_t attr = w->as.ansiTerm.curAttr;
|
|
int32_t total = w->as.ansiTerm.cols * w->as.ansiTerm.rows;
|
|
|
|
if (start < 0) {
|
|
count += start;
|
|
start = 0;
|
|
}
|
|
|
|
if (start + count > total) {
|
|
count = total - start;
|
|
}
|
|
|
|
for (int32_t i = 0; i < count; i++) {
|
|
cells[(start + i) * 2] = ' ';
|
|
cells[(start + i) * 2 + 1] = attr;
|
|
}
|
|
|
|
ansiTermDirtyRange(w, start, count);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermGetLine
|
|
// ============================================================
|
|
//
|
|
// Get a pointer to the cell data for a given line index in the
|
|
// combined scrollback+screen view.
|
|
// lineIndex < scrollbackCount → scrollback line
|
|
// lineIndex >= scrollbackCount → screen line
|
|
|
|
static const uint8_t *ansiTermGetLine(WidgetT *w, int32_t lineIndex) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t bytesPerRow = cols * 2;
|
|
int32_t sbCount = w->as.ansiTerm.scrollbackCount;
|
|
|
|
if (lineIndex < sbCount) {
|
|
// Scrollback line (circular buffer)
|
|
int32_t sbMax = w->as.ansiTerm.scrollbackMax;
|
|
int32_t actual = (w->as.ansiTerm.scrollbackHead - sbCount + lineIndex + sbMax) % sbMax;
|
|
return w->as.ansiTerm.scrollback + actual * bytesPerRow;
|
|
}
|
|
|
|
// Screen line
|
|
int32_t screenRow = lineIndex - sbCount;
|
|
return w->as.ansiTerm.cells + screenRow * bytesPerRow;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermInsertLines
|
|
// ============================================================
|
|
|
|
static void ansiTermInsertLines(WidgetT *w, int32_t count) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
int32_t row = w->as.ansiTerm.cursorRow;
|
|
|
|
if (count > rows - row) {
|
|
count = rows - row;
|
|
}
|
|
|
|
if (count <= 0) {
|
|
return;
|
|
}
|
|
|
|
uint8_t *cells = w->as.ansiTerm.cells;
|
|
|
|
// Shift lines down
|
|
int32_t bytesPerRow = cols * 2;
|
|
memmove(cells + (row + count) * bytesPerRow,
|
|
cells + row * bytesPerRow,
|
|
(rows - row - count) * bytesPerRow);
|
|
|
|
// Clear the inserted lines
|
|
for (int32_t r = row; r < row + count; r++) {
|
|
ansiTermFillCells(w, r * cols, cols);
|
|
}
|
|
|
|
// All rows from cursorRow down are affected
|
|
for (int32_t r = row; r < rows; r++) {
|
|
ansiTermDirtyRow(w, r);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermNewline
|
|
// ============================================================
|
|
//
|
|
// Move cursor to next line, scrolling if at the bottom.
|
|
|
|
static void ansiTermNewline(WidgetT *w) {
|
|
w->as.ansiTerm.cursorRow++;
|
|
|
|
if (w->as.ansiTerm.cursorRow >= w->as.ansiTerm.rows) {
|
|
w->as.ansiTerm.cursorRow = w->as.ansiTerm.rows - 1;
|
|
ansiTermScrollUp(w);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermProcessByte
|
|
// ============================================================
|
|
//
|
|
// Feed one byte through the ANSI parser state machine.
|
|
|
|
static void ansiTermProcessByte(WidgetT *w, uint8_t ch) {
|
|
switch (w->as.ansiTerm.parseState) {
|
|
case PARSE_NORMAL:
|
|
if (ch == 0x1B) {
|
|
w->as.ansiTerm.parseState = PARSE_ESC;
|
|
} else if (ch == '\r') {
|
|
w->as.ansiTerm.cursorCol = 0;
|
|
} else if (ch == '\n') {
|
|
ansiTermNewline(w);
|
|
} else if (ch == '\b') {
|
|
if (w->as.ansiTerm.cursorCol > 0) {
|
|
w->as.ansiTerm.cursorCol--;
|
|
}
|
|
} else if (ch == '\t') {
|
|
w->as.ansiTerm.cursorCol = (w->as.ansiTerm.cursorCol + 8) & ~7;
|
|
|
|
if (w->as.ansiTerm.cursorCol >= w->as.ansiTerm.cols) {
|
|
w->as.ansiTerm.cursorCol = w->as.ansiTerm.cols - 1;
|
|
}
|
|
} else if (ch == '\a') {
|
|
// Bell — ignored
|
|
} else if (ch >= 32 || ch >= 128) {
|
|
ansiTermPutChar(w, ch);
|
|
}
|
|
break;
|
|
|
|
case PARSE_ESC:
|
|
if (ch == '[') {
|
|
w->as.ansiTerm.parseState = PARSE_CSI;
|
|
w->as.ansiTerm.paramCount = 0;
|
|
w->as.ansiTerm.csiPrivate = false;
|
|
memset(w->as.ansiTerm.params, 0, sizeof(w->as.ansiTerm.params));
|
|
} else {
|
|
// Unknown escape — return to normal
|
|
w->as.ansiTerm.parseState = PARSE_NORMAL;
|
|
}
|
|
break;
|
|
|
|
case PARSE_CSI:
|
|
if (ch == '?') {
|
|
w->as.ansiTerm.csiPrivate = true;
|
|
} else if (ch >= '0' && ch <= '9') {
|
|
if (w->as.ansiTerm.paramCount == 0) {
|
|
w->as.ansiTerm.paramCount = 1;
|
|
}
|
|
|
|
int32_t idx = w->as.ansiTerm.paramCount - 1;
|
|
|
|
if (idx < ANSI_MAX_PARAMS) {
|
|
w->as.ansiTerm.params[idx] = w->as.ansiTerm.params[idx] * 10 + (ch - '0');
|
|
}
|
|
} else if (ch == ';') {
|
|
if (w->as.ansiTerm.paramCount < ANSI_MAX_PARAMS) {
|
|
w->as.ansiTerm.paramCount++;
|
|
}
|
|
} else if (ch >= 0x40 && ch <= 0x7E) {
|
|
// Final byte — dispatch the CSI sequence
|
|
ansiTermDispatchCsi(w, ch);
|
|
w->as.ansiTerm.parseState = PARSE_NORMAL;
|
|
} else {
|
|
// Unexpected byte — abort sequence
|
|
w->as.ansiTerm.parseState = PARSE_NORMAL;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermProcessSgr
|
|
// ============================================================
|
|
//
|
|
// Handle SGR (Select Graphic Rendition) escape sequence.
|
|
|
|
static void ansiTermProcessSgr(WidgetT *w) {
|
|
if (w->as.ansiTerm.paramCount == 0) {
|
|
// ESC[m with no params = reset
|
|
w->as.ansiTerm.curAttr = ANSI_DEFAULT_ATTR;
|
|
w->as.ansiTerm.bold = false;
|
|
return;
|
|
}
|
|
|
|
for (int32_t i = 0; i < w->as.ansiTerm.paramCount; i++) {
|
|
int32_t code = w->as.ansiTerm.params[i];
|
|
uint8_t fg = w->as.ansiTerm.curAttr & 0x0F;
|
|
uint8_t bg = (w->as.ansiTerm.curAttr >> 4) & 0x0F;
|
|
|
|
if (code == 0) {
|
|
fg = 7;
|
|
bg = 0;
|
|
w->as.ansiTerm.bold = false;
|
|
} else if (code == 1) {
|
|
w->as.ansiTerm.bold = true;
|
|
fg |= 8;
|
|
} else if (code == 5) {
|
|
// Blink — use bright background
|
|
bg |= 8;
|
|
} else if (code == 7) {
|
|
// Reverse video
|
|
uint8_t tmp = fg;
|
|
fg = bg;
|
|
bg = tmp;
|
|
} else if (code == 22) {
|
|
// Normal intensity
|
|
w->as.ansiTerm.bold = false;
|
|
fg &= 7;
|
|
} else if (code >= 30 && code <= 37) {
|
|
fg = (uint8_t)sAnsiToCga[code - 30];
|
|
|
|
if (w->as.ansiTerm.bold) {
|
|
fg |= 8;
|
|
}
|
|
} else if (code >= 40 && code <= 47) {
|
|
bg = (uint8_t)sAnsiToCga[code - 40];
|
|
} else if (code >= 90 && code <= 97) {
|
|
// Bright foreground
|
|
fg = (uint8_t)(sAnsiToCga[code - 90] | 8);
|
|
} else if (code >= 100 && code <= 107) {
|
|
// Bright background
|
|
bg = (uint8_t)(sAnsiToCga[code - 100] | 8);
|
|
}
|
|
|
|
w->as.ansiTerm.curAttr = (uint8_t)((bg << 4) | fg);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermPutChar
|
|
// ============================================================
|
|
//
|
|
// Place a character at the cursor and advance.
|
|
|
|
static void ansiTermPutChar(WidgetT *w, uint8_t ch) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
int32_t row = w->as.ansiTerm.cursorRow;
|
|
int32_t col = w->as.ansiTerm.cursorCol;
|
|
|
|
if (row >= 0 && row < rows && col >= 0 && col < cols) {
|
|
int32_t idx = (row * cols + col) * 2;
|
|
w->as.ansiTerm.cells[idx] = ch;
|
|
w->as.ansiTerm.cells[idx + 1] = w->as.ansiTerm.curAttr;
|
|
ansiTermDirtyRow(w, row);
|
|
}
|
|
|
|
w->as.ansiTerm.cursorCol++;
|
|
|
|
if (w->as.ansiTerm.cursorCol >= cols) {
|
|
if (w->as.ansiTerm.wrapMode) {
|
|
w->as.ansiTerm.cursorCol = 0;
|
|
ansiTermNewline(w);
|
|
} else {
|
|
w->as.ansiTerm.cursorCol = cols - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermScrollDown
|
|
// ============================================================
|
|
|
|
static void ansiTermScrollDown(WidgetT *w) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
uint8_t *cells = w->as.ansiTerm.cells;
|
|
int32_t bytesPerRow = cols * 2;
|
|
|
|
// Shift all lines down by one
|
|
memmove(cells + bytesPerRow, cells, (rows - 1) * bytesPerRow);
|
|
|
|
// Clear the top line
|
|
ansiTermFillCells(w, 0, cols);
|
|
|
|
ansiTermDirtyAll(w);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// ansiTermScrollUp
|
|
// ============================================================
|
|
//
|
|
// Scroll the screen up by one line. The top line is pushed into
|
|
// the scrollback buffer before being discarded.
|
|
|
|
static void ansiTermScrollUp(WidgetT *w) {
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
uint8_t *cells = w->as.ansiTerm.cells;
|
|
int32_t bytesPerRow = cols * 2;
|
|
|
|
// Track whether the view was following live output
|
|
bool wasAtBottom = (w->as.ansiTerm.scrollPos == w->as.ansiTerm.scrollbackCount);
|
|
|
|
// Push top line to scrollback
|
|
ansiTermAddToScrollback(w, 0);
|
|
|
|
// Shift all lines up by one
|
|
memmove(cells, cells + bytesPerRow, (rows - 1) * bytesPerRow);
|
|
|
|
// Clear the bottom line
|
|
ansiTermFillCells(w, (rows - 1) * cols, cols);
|
|
|
|
// Keep view at bottom if it was following live output
|
|
if (wasAtBottom) {
|
|
w->as.ansiTerm.scrollPos = w->as.ansiTerm.scrollbackCount;
|
|
}
|
|
|
|
ansiTermDirtyAll(w);
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// wgtAnsiTerm
|
|
// ============================================================
|
|
|
|
WidgetT *wgtAnsiTerm(WidgetT *parent, int32_t cols, int32_t rows) {
|
|
if (!parent) {
|
|
return NULL;
|
|
}
|
|
|
|
if (cols <= 0) {
|
|
cols = 80;
|
|
}
|
|
|
|
if (rows <= 0) {
|
|
rows = 25;
|
|
}
|
|
|
|
WidgetT *w = widgetAlloc(parent, WidgetAnsiTermE);
|
|
|
|
if (!w) {
|
|
return NULL;
|
|
}
|
|
|
|
int32_t cellCount = cols * rows;
|
|
w->as.ansiTerm.cells = (uint8_t *)malloc(cellCount * 2);
|
|
|
|
if (!w->as.ansiTerm.cells) {
|
|
free(w);
|
|
return NULL;
|
|
}
|
|
|
|
// Allocate scrollback buffer
|
|
int32_t sbMax = ANSI_DEFAULT_SCROLLBACK;
|
|
w->as.ansiTerm.scrollback = (uint8_t *)malloc(sbMax * cols * 2);
|
|
|
|
if (!w->as.ansiTerm.scrollback) {
|
|
free(w->as.ansiTerm.cells);
|
|
free(w);
|
|
return NULL;
|
|
}
|
|
|
|
w->as.ansiTerm.cols = cols;
|
|
w->as.ansiTerm.rows = rows;
|
|
w->as.ansiTerm.cursorRow = 0;
|
|
w->as.ansiTerm.cursorCol = 0;
|
|
w->as.ansiTerm.cursorVisible = true;
|
|
w->as.ansiTerm.wrapMode = true;
|
|
w->as.ansiTerm.bold = false;
|
|
w->as.ansiTerm.csiPrivate = false;
|
|
w->as.ansiTerm.curAttr = ANSI_DEFAULT_ATTR;
|
|
w->as.ansiTerm.parseState = PARSE_NORMAL;
|
|
w->as.ansiTerm.paramCount = 0;
|
|
w->as.ansiTerm.savedRow = 0;
|
|
w->as.ansiTerm.savedCol = 0;
|
|
w->as.ansiTerm.scrollbackMax = sbMax;
|
|
w->as.ansiTerm.scrollbackCount = 0;
|
|
w->as.ansiTerm.scrollbackHead = 0;
|
|
w->as.ansiTerm.scrollPos = 0;
|
|
w->as.ansiTerm.commCtx = NULL;
|
|
w->as.ansiTerm.commRead = NULL;
|
|
w->as.ansiTerm.commWrite = NULL;
|
|
|
|
memset(w->as.ansiTerm.params, 0, sizeof(w->as.ansiTerm.params));
|
|
|
|
// Initialize all cells to space with default attribute
|
|
for (int32_t i = 0; i < cellCount; i++) {
|
|
w->as.ansiTerm.cells[i * 2] = ' ';
|
|
w->as.ansiTerm.cells[i * 2 + 1] = ANSI_DEFAULT_ATTR;
|
|
}
|
|
|
|
return w;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// wgtAnsiTermClear
|
|
// ============================================================
|
|
|
|
void wgtAnsiTermClear(WidgetT *w) {
|
|
if (!w || w->type != WidgetAnsiTermE) {
|
|
return;
|
|
}
|
|
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
|
|
// Push all visible lines to scrollback
|
|
bool wasAtBottom = (w->as.ansiTerm.scrollPos == w->as.ansiTerm.scrollbackCount);
|
|
|
|
for (int32_t r = 0; r < rows; r++) {
|
|
ansiTermAddToScrollback(w, r);
|
|
}
|
|
|
|
if (wasAtBottom) {
|
|
w->as.ansiTerm.scrollPos = w->as.ansiTerm.scrollbackCount;
|
|
}
|
|
|
|
// Clear the screen
|
|
int32_t cellCount = cols * rows;
|
|
|
|
for (int32_t i = 0; i < cellCount; i++) {
|
|
w->as.ansiTerm.cells[i * 2] = ' ';
|
|
w->as.ansiTerm.cells[i * 2 + 1] = ANSI_DEFAULT_ATTR;
|
|
}
|
|
|
|
w->as.ansiTerm.cursorRow = 0;
|
|
w->as.ansiTerm.cursorCol = 0;
|
|
w->as.ansiTerm.curAttr = ANSI_DEFAULT_ATTR;
|
|
w->as.ansiTerm.bold = false;
|
|
w->as.ansiTerm.parseState = PARSE_NORMAL;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// wgtAnsiTermSetScrollback
|
|
// ============================================================
|
|
|
|
void wgtAnsiTermSetScrollback(WidgetT *w, int32_t maxLines) {
|
|
if (!w || w->type != WidgetAnsiTermE || maxLines <= 0) {
|
|
return;
|
|
}
|
|
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
uint8_t *newBuf = (uint8_t *)malloc(maxLines * cols * 2);
|
|
|
|
if (!newBuf) {
|
|
return;
|
|
}
|
|
|
|
free(w->as.ansiTerm.scrollback);
|
|
w->as.ansiTerm.scrollback = newBuf;
|
|
w->as.ansiTerm.scrollbackMax = maxLines;
|
|
w->as.ansiTerm.scrollbackCount = 0;
|
|
w->as.ansiTerm.scrollbackHead = 0;
|
|
w->as.ansiTerm.scrollPos = 0;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// wgtAnsiTermPoll
|
|
// ============================================================
|
|
|
|
int32_t wgtAnsiTermPoll(WidgetT *w) {
|
|
if (!w || w->type != WidgetAnsiTermE || !w->as.ansiTerm.commRead) {
|
|
return 0;
|
|
}
|
|
|
|
uint8_t buf[256];
|
|
int32_t n = w->as.ansiTerm.commRead(w->as.ansiTerm.commCtx, buf, (int32_t)sizeof(buf));
|
|
|
|
if (n > 0) {
|
|
wgtAnsiTermWrite(w, buf, n);
|
|
}
|
|
|
|
return n > 0 ? n : 0;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// wgtAnsiTermRepaint
|
|
// ============================================================
|
|
//
|
|
// Fast repaint: renders only dirty rows directly into the window's
|
|
// content buffer, bypassing the full widget paint pipeline (no clear,
|
|
// no relayout, no other widgets). This keeps ACK turnaround fast
|
|
// for the serial link.
|
|
|
|
int32_t wgtAnsiTermRepaint(WidgetT *w) {
|
|
if (!w || w->type != WidgetAnsiTermE || !w->window) {
|
|
return 0;
|
|
}
|
|
|
|
// Always repaint the row the cursor was on last time (to erase it)
|
|
// and the row it's on now (to draw it)
|
|
int32_t prevRow = w->as.ansiTerm.lastCursorRow;
|
|
int32_t curRow = w->as.ansiTerm.cursorRow;
|
|
int32_t prevCol = w->as.ansiTerm.lastCursorCol;
|
|
int32_t curCol = w->as.ansiTerm.cursorCol;
|
|
|
|
if (prevRow != curRow || prevCol != curCol) {
|
|
if (prevRow >= 0 && prevRow < w->as.ansiTerm.rows) {
|
|
w->as.ansiTerm.dirtyRows |= (1U << prevRow);
|
|
}
|
|
if (curRow >= 0 && curRow < w->as.ansiTerm.rows) {
|
|
w->as.ansiTerm.dirtyRows |= (1U << curRow);
|
|
}
|
|
}
|
|
|
|
uint32_t dirty = w->as.ansiTerm.dirtyRows;
|
|
if (dirty == 0) {
|
|
return 0;
|
|
}
|
|
|
|
WindowT *win = w->window;
|
|
if (!win->contentBuf || !win->widgetRoot) {
|
|
return 0;
|
|
}
|
|
|
|
AppContextT *ctx = (AppContextT *)win->widgetRoot->userData;
|
|
if (!ctx) {
|
|
return 0;
|
|
}
|
|
|
|
// Set up display context pointing at the content buffer
|
|
DisplayT cd = ctx->display;
|
|
cd.backBuf = win->contentBuf;
|
|
cd.width = win->contentW;
|
|
cd.height = win->contentH;
|
|
cd.pitch = win->contentPitch;
|
|
cd.clipX = 0;
|
|
cd.clipY = 0;
|
|
cd.clipW = win->contentW;
|
|
cd.clipH = win->contentH;
|
|
|
|
const BlitOpsT *ops = &ctx->blitOps;
|
|
const BitmapFontT *font = &ctx->font;
|
|
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
int32_t cellW = font->charWidth;
|
|
int32_t cellH = font->charHeight;
|
|
int32_t baseX = w->x + ANSI_BORDER;
|
|
int32_t baseY = w->y + ANSI_BORDER;
|
|
|
|
// Build palette
|
|
uint32_t palette[16];
|
|
for (int32_t i = 0; i < 16; i++) {
|
|
palette[i] = packColor(&cd, sCgaPalette[i][0], sCgaPalette[i][1], sCgaPalette[i][2]);
|
|
}
|
|
|
|
bool viewingLive = (w->as.ansiTerm.scrollPos == w->as.ansiTerm.scrollbackCount);
|
|
int32_t repainted = 0;
|
|
|
|
for (int32_t row = 0; row < rows; row++) {
|
|
if (!(dirty & (1U << row))) {
|
|
continue;
|
|
}
|
|
|
|
int32_t lineIndex = w->as.ansiTerm.scrollPos + row;
|
|
const uint8_t *lineData = ansiTermGetLine(w, lineIndex);
|
|
|
|
for (int32_t col = 0; col < cols; col++) {
|
|
uint8_t ch = lineData[col * 2];
|
|
uint8_t attr = lineData[col * 2 + 1];
|
|
|
|
uint32_t fg = palette[attr & 0x0F];
|
|
uint32_t bg = palette[(attr >> 4) & 0x0F];
|
|
|
|
if (viewingLive && w->as.ansiTerm.cursorVisible && w->focused &&
|
|
row == w->as.ansiTerm.cursorRow && col == w->as.ansiTerm.cursorCol) {
|
|
uint32_t tmp = fg;
|
|
fg = bg;
|
|
bg = tmp;
|
|
}
|
|
|
|
int32_t cx = baseX + col * cellW;
|
|
int32_t cy = baseY + row * cellH;
|
|
|
|
drawChar(&cd, ops, font, cx, cy, (char)ch, fg, bg, true);
|
|
}
|
|
|
|
repainted++;
|
|
}
|
|
|
|
w->as.ansiTerm.dirtyRows = 0;
|
|
w->as.ansiTerm.lastCursorRow = w->as.ansiTerm.cursorRow;
|
|
w->as.ansiTerm.lastCursorCol = w->as.ansiTerm.cursorCol;
|
|
return repainted;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// wgtAnsiTermSetComm
|
|
// ============================================================
|
|
|
|
void wgtAnsiTermSetComm(WidgetT *w, void *ctx, int32_t (*readFn)(void *, uint8_t *, int32_t), int32_t (*writeFn)(void *, const uint8_t *, int32_t)) {
|
|
if (!w || w->type != WidgetAnsiTermE) {
|
|
return;
|
|
}
|
|
|
|
w->as.ansiTerm.commCtx = ctx;
|
|
w->as.ansiTerm.commRead = readFn;
|
|
w->as.ansiTerm.commWrite = writeFn;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// wgtAnsiTermWrite
|
|
// ============================================================
|
|
|
|
void wgtAnsiTermWrite(WidgetT *w, const uint8_t *data, int32_t len) {
|
|
if (!w || w->type != WidgetAnsiTermE || !data || len <= 0) {
|
|
return;
|
|
}
|
|
|
|
for (int32_t i = 0; i < len; i++) {
|
|
ansiTermProcessByte(w, data[i]);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetAnsiTermCalcMinSize
|
|
// ============================================================
|
|
|
|
void widgetAnsiTermCalcMinSize(WidgetT *w, const BitmapFontT *font) {
|
|
w->calcMinW = w->as.ansiTerm.cols * font->charWidth + ANSI_BORDER * 2 + ANSI_SB_W;
|
|
w->calcMinH = w->as.ansiTerm.rows * font->charHeight + ANSI_BORDER * 2;
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetAnsiTermOnKey
|
|
// ============================================================
|
|
//
|
|
// Translate keyboard input to ANSI escape sequences and send
|
|
// via the comm interface. Does nothing if commWrite is NULL.
|
|
|
|
void widgetAnsiTermOnKey(WidgetT *w, int32_t key) {
|
|
if (!w->as.ansiTerm.commWrite) {
|
|
return;
|
|
}
|
|
|
|
uint8_t buf[8];
|
|
int32_t len = 0;
|
|
|
|
if (key >= 32 && key < 127) {
|
|
// Printable ASCII
|
|
buf[0] = (uint8_t)key;
|
|
len = 1;
|
|
} else if (key == 13 || key == 10) {
|
|
// Enter
|
|
buf[0] = '\r';
|
|
len = 1;
|
|
} else if (key == 8) {
|
|
// Backspace
|
|
buf[0] = 0x08;
|
|
len = 1;
|
|
} else if (key == (0x48 | 0x100)) {
|
|
// Up arrow → ESC[A
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = 'A';
|
|
len = 3;
|
|
} else if (key == (0x50 | 0x100)) {
|
|
// Down arrow → ESC[B
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = 'B';
|
|
len = 3;
|
|
} else if (key == (0x4D | 0x100)) {
|
|
// Right arrow → ESC[C
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = 'C';
|
|
len = 3;
|
|
} else if (key == (0x4B | 0x100)) {
|
|
// Left arrow → ESC[D
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = 'D';
|
|
len = 3;
|
|
} else if (key == (0x47 | 0x100)) {
|
|
// Home → ESC[H
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = 'H';
|
|
len = 3;
|
|
} else if (key == (0x4F | 0x100)) {
|
|
// End → ESC[F
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = 'F';
|
|
len = 3;
|
|
} else if (key == (0x49 | 0x100)) {
|
|
// PgUp → ESC[5~
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = '5'; buf[3] = '~';
|
|
len = 4;
|
|
} else if (key == (0x51 | 0x100)) {
|
|
// PgDn → ESC[6~
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = '6'; buf[3] = '~';
|
|
len = 4;
|
|
} else if (key == (0x53 | 0x100)) {
|
|
// Delete → ESC[3~
|
|
buf[0] = 0x1B; buf[1] = '['; buf[2] = '3'; buf[3] = '~';
|
|
len = 4;
|
|
}
|
|
|
|
if (len > 0) {
|
|
w->as.ansiTerm.commWrite(w->as.ansiTerm.commCtx, buf, len);
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetAnsiTermOnMouse
|
|
// ============================================================
|
|
//
|
|
// Handle mouse clicks: scrollbar interaction and focus.
|
|
|
|
void widgetAnsiTermOnMouse(WidgetT *hit, int32_t vx, int32_t vy, const BitmapFontT *font) {
|
|
hit->focused = true;
|
|
|
|
int32_t sbCount = hit->as.ansiTerm.scrollbackCount;
|
|
|
|
if (sbCount == 0) {
|
|
return;
|
|
}
|
|
|
|
// Scrollbar geometry
|
|
int32_t cols = hit->as.ansiTerm.cols;
|
|
int32_t rows = hit->as.ansiTerm.rows;
|
|
int32_t sbX = hit->x + ANSI_BORDER + cols * font->charWidth;
|
|
int32_t sbY = hit->y + ANSI_BORDER;
|
|
int32_t sbH = rows * font->charHeight;
|
|
int32_t arrowH = ANSI_SB_W;
|
|
|
|
if (vx < sbX || vx >= sbX + ANSI_SB_W) {
|
|
return;
|
|
}
|
|
|
|
int32_t maxScroll = sbCount;
|
|
|
|
if (vy >= sbY && vy < sbY + arrowH) {
|
|
// Up arrow
|
|
hit->as.ansiTerm.scrollPos--;
|
|
} else if (vy >= sbY + sbH - arrowH && vy < sbY + sbH) {
|
|
// Down arrow
|
|
hit->as.ansiTerm.scrollPos++;
|
|
} else if (vy >= sbY + arrowH && vy < sbY + sbH - arrowH) {
|
|
// Track area — compute thumb position to determine page direction
|
|
int32_t trackY = sbY + arrowH;
|
|
int32_t trackH = sbH - arrowH * 2;
|
|
|
|
if (trackH <= 0) {
|
|
return;
|
|
}
|
|
|
|
int32_t totalLines = sbCount + rows;
|
|
int32_t thumbH = (rows * trackH) / totalLines;
|
|
|
|
if (thumbH < 8) {
|
|
thumbH = 8;
|
|
}
|
|
|
|
int32_t thumbRange = trackH - thumbH;
|
|
int32_t thumbY = trackY;
|
|
|
|
if (maxScroll > 0 && thumbRange > 0) {
|
|
thumbY = trackY + (hit->as.ansiTerm.scrollPos * thumbRange) / maxScroll;
|
|
}
|
|
|
|
if (vy < thumbY) {
|
|
// Page up
|
|
hit->as.ansiTerm.scrollPos -= rows;
|
|
} else if (vy >= thumbY + thumbH) {
|
|
// Page down
|
|
hit->as.ansiTerm.scrollPos += rows;
|
|
}
|
|
}
|
|
|
|
// Clamp
|
|
if (hit->as.ansiTerm.scrollPos < 0) {
|
|
hit->as.ansiTerm.scrollPos = 0;
|
|
}
|
|
|
|
if (hit->as.ansiTerm.scrollPos > maxScroll) {
|
|
hit->as.ansiTerm.scrollPos = maxScroll;
|
|
}
|
|
}
|
|
|
|
|
|
// ============================================================
|
|
// widgetAnsiTermPaint
|
|
// ============================================================
|
|
|
|
void widgetAnsiTermPaint(WidgetT *w, DisplayT *d, const BlitOpsT *ops, const BitmapFontT *font, const ColorSchemeT *colors) {
|
|
// Draw sunken bevel border
|
|
BevelStyleT bevel;
|
|
bevel.highlight = colors->windowShadow;
|
|
bevel.shadow = colors->windowHighlight;
|
|
bevel.face = 0;
|
|
bevel.width = ANSI_BORDER;
|
|
drawBevel(d, ops, w->x, w->y, w->w, w->h, &bevel);
|
|
|
|
// Build the 16-color packed palette for this display format
|
|
uint32_t palette[16];
|
|
|
|
for (int32_t i = 0; i < 16; i++) {
|
|
palette[i] = packColor(d, sCgaPalette[i][0], sCgaPalette[i][1], sCgaPalette[i][2]);
|
|
}
|
|
|
|
int32_t cols = w->as.ansiTerm.cols;
|
|
int32_t rows = w->as.ansiTerm.rows;
|
|
int32_t cellW = font->charWidth;
|
|
int32_t cellH = font->charHeight;
|
|
int32_t baseX = w->x + ANSI_BORDER;
|
|
int32_t baseY = w->y + ANSI_BORDER;
|
|
int32_t sbCount = w->as.ansiTerm.scrollbackCount;
|
|
|
|
// Determine if viewing live terminal or scrollback
|
|
bool viewingLive = (w->as.ansiTerm.scrollPos == sbCount);
|
|
|
|
// Render character cells
|
|
for (int32_t row = 0; row < rows; row++) {
|
|
int32_t lineIndex = w->as.ansiTerm.scrollPos + row;
|
|
const uint8_t *lineData = ansiTermGetLine(w, lineIndex);
|
|
|
|
for (int32_t col = 0; col < cols; col++) {
|
|
uint8_t ch = lineData[col * 2];
|
|
uint8_t attr = lineData[col * 2 + 1];
|
|
|
|
uint32_t fg = palette[attr & 0x0F];
|
|
uint32_t bg = palette[(attr >> 4) & 0x0F];
|
|
|
|
// Draw cursor as inverse block (only when viewing live terminal)
|
|
if (viewingLive && w->as.ansiTerm.cursorVisible && w->focused &&
|
|
row == w->as.ansiTerm.cursorRow && col == w->as.ansiTerm.cursorCol) {
|
|
uint32_t tmp = fg;
|
|
fg = bg;
|
|
bg = tmp;
|
|
}
|
|
|
|
int32_t cx = baseX + col * cellW;
|
|
int32_t cy = baseY + row * cellH;
|
|
|
|
drawChar(d, ops, font, cx, cy, (char)ch, fg, bg, true);
|
|
}
|
|
}
|
|
|
|
// Draw scrollbar
|
|
int32_t sbX = baseX + cols * cellW;
|
|
int32_t sbY = baseY;
|
|
int32_t sbW = ANSI_SB_W;
|
|
int32_t sbH = rows * cellH;
|
|
int32_t arrowH = ANSI_SB_W;
|
|
|
|
if (sbCount == 0) {
|
|
// No scrollback — fill scrollbar area with trough color
|
|
rectFill(d, ops, sbX, sbY, sbW, sbH, colors->scrollbarTrough);
|
|
return;
|
|
}
|
|
|
|
// Track background
|
|
int32_t trackY = sbY + arrowH;
|
|
int32_t trackH = sbH - arrowH * 2;
|
|
rectFill(d, ops, sbX, trackY, sbW, trackH, colors->scrollbarTrough);
|
|
|
|
// Up arrow button
|
|
BevelStyleT btnBevel;
|
|
btnBevel.highlight = colors->windowHighlight;
|
|
btnBevel.shadow = colors->windowShadow;
|
|
btnBevel.face = colors->scrollbarBg;
|
|
btnBevel.width = 1;
|
|
drawBevel(d, ops, sbX, sbY, sbW, arrowH, &btnBevel);
|
|
|
|
// Up arrow glyph (small triangle)
|
|
int32_t arrowMidX = sbX + sbW / 2;
|
|
int32_t arrowMidY = sbY + arrowH / 2;
|
|
|
|
for (int32_t i = 0; i < 4; i++) {
|
|
drawHLine(d, ops, arrowMidX - i, arrowMidY - 1 + i, i * 2 + 1, colors->scrollbarFg);
|
|
}
|
|
|
|
// Down arrow button
|
|
drawBevel(d, ops, sbX, sbY + sbH - arrowH, sbW, arrowH, &btnBevel);
|
|
|
|
arrowMidY = sbY + sbH - arrowH + arrowH / 2;
|
|
|
|
for (int32_t i = 0; i < 4; i++) {
|
|
drawHLine(d, ops, arrowMidX - i, arrowMidY + 1 - i, i * 2 + 1, colors->scrollbarFg);
|
|
}
|
|
|
|
// Thumb
|
|
if (trackH > 0) {
|
|
int32_t totalLines = sbCount + rows;
|
|
int32_t thumbH = (rows * trackH) / totalLines;
|
|
|
|
if (thumbH < 8) {
|
|
thumbH = 8;
|
|
}
|
|
|
|
int32_t thumbRange = trackH - thumbH;
|
|
int32_t maxScroll = sbCount;
|
|
int32_t thumbY = trackY;
|
|
|
|
if (maxScroll > 0 && thumbRange > 0) {
|
|
thumbY = trackY + (w->as.ansiTerm.scrollPos * thumbRange) / maxScroll;
|
|
}
|
|
|
|
drawBevel(d, ops, sbX, thumbY, sbW, thumbH, &btnBevel);
|
|
}
|
|
}
|