//////////////////////////////////////////////////////////////////////////
// pfterm environment settings
//////////////////////////////////////////////////////////////////////////
#ifdef _PFTERM_TEST_MAIN
#define USE_PFTERM
#define EXP_PFTERM
#define DBCSAWARE
#define FT_DBCS_NOINTRESC 1
#define DBG_TEXT_FD
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#else
#define HAVE_GRAYOUT
#include "bbs.h"
#ifdef DBCS_NOINTRESC
// # ifdef CONVERT
// extern int bbs_convert_type;
// # define FT_DBCS_NOINTRESC (
// (cuser.uflag & DBCS_NOINTRESC) ||
// (bbs_convert_type == CONV_UTF8))
// # else
# define FT_DBCS_NOINTRESC (cuser.uflag & DBCS_NOINTRESC)
// # endif
#else
# define FT_DBCS_NOINTRESC 0
#endif
#endif
//////////////////////////////////////////////////////////////////////////
// pfterm debug settings
//////////////////////////////////////////////////////////////////////////
// #define DBG_SHOWDIRTY
// #define DBG_DISABLE_OPTMOVE
//////////////////////////////////////////////////////////////////////////
// pmore style ansi
// #include "ansi.h"
//////////////////////////////////////////////////////////////////////////
#ifndef PMORE_STYLE_ANSI
#define ESC_CHR '\x1b'
#define ESC_STR "\x1b"
#define ANSI_COLOR(x) ESC_STR "[" #x "m"
#define ANSI_RESET ESC_STR "[m"
#endif // PMORE_STYLE_ANSI
#ifndef ANSI_IS_PARAM
#define ANSI_IS_PARAM(c) (c == ';' || (c >= '0' && c <= '9'))
#endif // ANSI_IS_PARAM
//////////////////////////////////////////////////////////////////////////
// grayout advanced control
// #include "grayout.h"
//////////////////////////////////////////////////////////////////////////
#ifndef GRAYOUT_DARK
#define GRAYOUT_BOLD (-1)
#define GRAYOUT_DARK (0)
#define GRAYOUT_NORM (1)
#endif // GRAYOUT_DARK
//////////////////////////////////////////////////////////////////////////
// pfterm: piaip's flat terminal system, a new replacement for 'screen'.
// pfterm can also be read as "Perfect Term"
//
// piaip's new implementation of terminal system (term/screen) with dirty
// map, designed and optimized for ANSI based output.
//
// "pfterm" is "piaip's flat terminal" or "perfect term", not "PTT's term"!!!
// pfterm is designed for general maple-family BBS systems, not
// specific to any branch.
//
// Author: Hung-Te Lin (piaip), Dec. 2007.
// <piaip@csie.ntu.edu.tw>
// All Rights Reserved.
// You are free to use, modify, redistribute this program
// in any BBS style systems, or any other non-commercial usage.
// You must keep these copyright information.
//
// MAJOR IMPROVEMENTS:
// - Interpret ANSI code and maintain a virtual terminal
// - Dual buffer for dirty map and optimized output
//
// TODO AND DONE:
// - DBCS aware and prevent interrupting DBCS [done]
// - optimization with relative movement [done]
// - optimization with ENTER/clrtoeol [done]
// - ncurses-like API [done]
// - inansistr to output escaped string [done]
// - handle incomplete DBCS characters [done]
//
// DEPRECATED:
// - standout() [rework getdata() and namecomplete()]
// - talk.c (big_picture) [rework talk.c]
//
//////////////////////////////////////////////////////////////////////////
// Reference:
// http://en.wikipedia.org/wiki/ANSI_escape_code
// http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-048.pdf
//////////////////////////////////////////////////////////////////////////
// Experimental now
#if defined(EXP_PFTERM) || defined(USE_PFTERM)
//////////////////////////////////////////////////////////////////////////
// Flat Terminal Definition
//////////////////////////////////////////////////////////////////////////
#define FTSZ_DEFAULT_ROW (24)
#define FTSZ_DEFAULT_COL (80)
#define FTSZ_MIN_ROW (24)
#define FTSZ_MAX_ROW (100)
#define FTSZ_MIN_COL (80)
#define FTSZ_MAX_COL (320)
#define FTCHAR_ERASE (' ')
#define FTATTR_ERASE (0x07)
#define FTCHAR_BLANK (' ')
#define FTATTR_DEFAULT (FTATTR_ERASE)
#define FTCHAR_INVALID_DBCS ('?')
// #define FTATTR_TRANSPARENT (0x80)
#define FTDIRTY_CHAR (0x1)
#define FTDIRTY_ATTR (0x2)
#define FTDIRTY_DBCS (0x4)
#define FTDIRTY_INVALID_DBCS (0x8)
#define FTCMD_MAXLEN (63) // max escape command sequence length
#define FTATTR_MINCMD (16)
#define FTMV_COST (5) // ESC[ABCD and ESC[m;nH costs avg 5+ bytes
//////////////////////////////////////////////////////////////////////////
// Flat Terminal Data Type
//////////////////////////////////////////////////////////////////////////
typedef unsigned char ftchar; // primitive character type
typedef unsigned char ftattr; // primitive attribute type
//////////////////////////////////////////////////////////////////////////
// Flat Terminal Structure
//////////////////////////////////////////////////////////////////////////
typedef struct
{
ftchar **cmap[2];
ftattr **amap[2];
ftchar *dmap;
ftattr attr;
int rows, cols;
int y, x;
int sy,sx; // stored cursor
int mi; // map index, mi = current map and (1-mi) = old map
int dirty;
int scroll;
// raw terminal status
int ry, rx;
ftattr rattr;
// escape command
ftchar cmd[FTCMD_MAXLEN+1];
int szcmd;
} FlatTerm;
static FlatTerm ft;
//////////////////////////////////////////////////////////////////////////
// Flat Terminal Utility Macro
//////////////////////////////////////////////////////////////////////////
// ftattr: 0| FG(3) | BOLD(1) | BG(3) | BLINK(1) |8
#define FTATTR_FGSHIFT (0)
#define FTATTR_BGSHIFT (4)
#define FTATTR_GETFG(x) ((x >> FTATTR_FGSHIFT) & 0x7)
#define FTATTR_GETBG(x) ((x >> FTATTR_BGSHIFT) & 0x7)
#define FTATTR_FGMASK ((ftattr)(0x7 << FTATTR_FGSHIFT))
#define FTATTR_BGMASK ((ftattr)(0x7 << FTATTR_BGSHIFT))
#define FTATTR_BOLD (0x08)
#define FTATTR_BLINK (0x80)
#define FTATTR_DEFAULT_FG (FTATTR_GETFG(FTATTR_DEFAULT))
#define FTATTR_DEFAULT_BG (FTATTR_GETBG(FTATTR_DEFAULT))
#define FTATTR_MAKE(f,b) (((f)<<FTATTR_FGSHIFT)|((b)<<FTATTR_BGSHIFT))
#define FTCHAR_ISBLANK(x) ((x) == (FTCHAR_BLANK))
#define FTCMAP ft.cmap[ft.mi]
#define FTAMAP ft.amap[ft.mi]
#define FTCROW FTCMAP[ft.y]
#define FTAROW FTAMAP[ft.y]
#define FTC FTCROW[ft.x]
#define FTA FTAROW[ft.x]
#define FTD ft.dmap
#define FTPC (FTCROW+ft.x)
#define FTPA (FTAROW+ft.x)
#define FTOCMAP ft.cmap[1-ft.mi]
#define FTOAMAP ft.amap[1-ft.mi]
// for fast checking, we use reduced range here.
// Big5: LEAD = 0x81-0xFE, TAIL = 0x40-0x7E/0xA1-0xFE
#define FTDBCS_ISLEAD(x) (((unsigned char)(x))>=(0x80))
#define FTDBCS_ISTAIL(x) (((unsigned char)(x))>=(0x40))
// - 0xFF is used as telnet IAC, don't use it!
// - 0x80 is invalid for Big5.
#define FTDBCS_ISBADLEAD(x) ((((unsigned char)(x)) == 0x80) || (((unsigned char)(x)) == 0xFF))
// even faster:
// #define FTDBCS_ISLEAD(x) (((unsigned char)(x)) & 0x80)
// #define FTDBCS_ISTAIL(x) (((unsigned char)(x)) & ((unsigned char)~0x3F))
#define FTDBCS_ISSBCSPRINT(x) \
(((unsigned char)(x))>=' ' && ((unsigned char)(x))<0x80)
#ifndef min
#define min(x,y) (((x)<(y))?(x):(y))
#endif
#ifndef max
#define max(x,y) (((x)>(y))?(x):(y))
#endif
#ifndef abs
#define abs(x) (((x)>0)?(x):-(x))
#endif
#define ranged(x,vmin,vmax) (max(min(x,vmax),vmin))
//////////////////////////////////////////////////////////////////////////
// Special Configurations
//////////////////////////////////////////////////////////////////////////
// Prevent invalid DBCS characters
#define FTCONF_PREVENT_INVALID_DBCS
// Some terminals use current attribute to erase background
#define FTCONF_CLEAR_SETATTR
// Some terminals prefer VT100 style scrolling, including Win/DOS telnet
#undef FTCONF_USE_ANSI_SCROLL
// Few poor terminals do not have relative move (ABCD).
#undef FTCONF_USE_ANSI_RELMOVE
#ifndef FTCONF_USE_ANSI_RELMOVE
#undef FTMV_COST
#define FTMV_COST (8) // always ESC[m;nH will costs avg 8 bytes
#endif
//////////////////////////////////////////////////////////////////////////
// Flat Terminal API
//////////////////////////////////////////////////////////////////////////
//// common ncurse-like library interface
// initialization
void initscr (void);
int resizeterm (int rows, int cols);
// attributes
ftattr attrget (void);
void attrset (ftattr attr);
void attrsetfg (ftattr attr);
void attrsetbg (ftattr attr);
// cursor
void getyx (int *y, int *x);
void move (int y, int x);
// clear
void clear (void); // clrscr + move(0,0)
void clrtoeol (void); // end of line
void clrtobot (void);
// clear (non-ncurses)
void clrtoln (int ln); // clear down to ln ( excluding ln, as [y,ln) )
void clrcurln (void); // whole line
void clrtobeg (void); // begin of line
void clrtohome (void);
void clrscr (void); // clear and keep cursor untouched
void clrregion (int r1, int r2); // clear [r1,r2], bi-directional.
// flushing
void refresh (void); // optimized refresh
void redrawwin (void); // force refresh
// scrolling
void scroll (void); // scroll up
void rscroll (void); // scroll down
void scrl (int rows);
// output (non-ncurses)
void outc (unsigned char c);
void outs (const char *s);
void outstr (const char *str); // prepare and print a complete string.
// readback
int instr (char *str);
int innstr (char *str, int n); // n includes \0
int inansistr (char *str, int n); // n includes \0
// deprecated
void standout (void);
void standend (void);
// grayout advanced control
void grayout (int y, int end, int level);
//// flat-term internal processor
int fterm_inbuf (void); // raw input adapter
void fterm_rawc (int c); // raw output adapter
void fterm_rawnewline(void); // raw output adapter
void fterm_rawflush (void); // raw output adapter
void fterm_raws (const char *s);
void fterm_rawnc (int c, int n);
void fterm_rawnum (int arg);
void fterm_rawcmd (int arg, int defval, char c);
void fterm_rawcmd2 (int arg1, int arg2, int defval, char c);
void fterm_rawattr (ftattr attr); // optimized changing attribute
void fterm_rawclear (void);
void fterm_rawclreol (void);
void fterm_rawhome (void);
void fterm_rawscroll (int dy);
void fterm_rawcursor (void);
void fterm_rawmove (int y, int x);
void fterm_rawmove_opt(int y, int x);
void fterm_rawmove_rel(int dy, int dx);
int fterm_chattr (char *s, ftattr oa, ftattr na); // size(s) > FTATTR_MINCMD
void fterm_exec (void); // execute ft.cmd
void fterm_flippage (void);
void fterm_dupe2bk (void);
void fterm_markdirty (void); // mark as dirty
int fterm_strdlen (const char *s); // length of string for display
int fterm_prepare_str(int len);
//////////////////////////////////////////////////////////////////////////
// Flat Terminal Implementation
//////////////////////////////////////////////////////////////////////////
// initialization
void
initscr(void)
{
memset(&ft, sizeof(ft), 0);
resizeterm(FTSZ_DEFAULT_ROW, FTSZ_DEFAULT_COL);
ft.attr = ft.rattr = FTATTR_DEFAULT;
// clear both pages
ft.mi = 0; clrscr();
ft.mi = 1; clrscr();
ft.mi = 0;
fterm_rawclear();
move(0, 0);
}
int
resizeterm(int rows, int cols)
{
int dirty = 0, mi = 0, i = 0;
rows = ranged(rows, FTSZ_MIN_ROW, FTSZ_MAX_ROW);
cols = ranged(cols, FTSZ_MIN_COL, FTSZ_MAX_COL);
// enlarge buffer only
if (rows > ft.rows || cols > ft.cols)
{
for (mi = 0; mi < 2; mi++)
{
// allocate rows
if (rows > ft.rows)
{
ft.cmap[mi] = (ftchar**)realloc(ft.cmap[mi],
sizeof(ftchar*) * rows);
ft.amap[mi] = (ftattr**)realloc(ft.amap[mi],
sizeof(ftattr*) * rows);
// allocate new columns
for (i = ft.rows; i < rows; i++)
{
ft.cmap[mi][i] = (ftchar*)malloc((cols+1) * sizeof(ftchar));
ft.amap[mi][i] = (ftattr*)malloc((cols+1) * sizeof(ftattr));
memset(ft.cmap[mi][i], FTCHAR_ERASE,
(cols) * sizeof(ftchar));
memset(ft.amap[mi][i], FTATTR_ERASE,
(cols) * sizeof(ftattr));
// zero at end to prevent over-run
ft.cmap[mi][i][cols] = 0;
ft.amap[mi][i][cols] = 0;
}
}
// resize cols
if (cols > ft.cols)
{
for (i = 0; i < ft.rows; i++)
{
ft.cmap[mi][i] = (ftchar*)realloc(ft.cmap[mi][i],
(cols+1) * sizeof(ftchar));
ft.amap[mi][i] = (ftattr*)realloc(ft.amap[mi][i],
(cols+1) * sizeof(ftattr));
memset(ft.cmap[mi][i]+ft.cols, FTCHAR_ERASE,
(cols-ft.cols) * sizeof(ftchar));
memset(ft.amap[mi][i]+ft.cols, FTATTR_ERASE,
(cols-ft.cols) * sizeof(ftattr));
// zero at end to prevent over-run
ft.cmap[mi][i][cols] = 0;
ft.amap[mi][i][cols] = 0;
}
// no need to initialize dirty map.
ft.dmap = (ftchar*) realloc(ft.dmap,
(cols+1) * sizeof(ftchar));
}
}
dirty = 1;
}
if (ft.rows != rows || ft.cols != cols)
{
ft.rows = rows;
ft.cols = cols;
redrawwin();
}
return dirty;
}
// attributes
ftattr
attrget(void)
{
return ft.attr;
}
void
attrset(ftattr attr)
{
ft.attr = attr;
}
void
attrsetfg(ftattr attr)
{
ft.attr &= (~FTATTR_FGMASK);
ft.attr |= ((attr & FTATTR_FGMASK) << FTATTR_FGSHIFT);
}
void
attrsetbg(ftattr attr)
{
ft.attr &= (~FTATTR_BGMASK);
ft.attr |= ((attr & FTATTR_FGMASK) << FTATTR_BGSHIFT);
}
// clear
void
clrscr(void)
{
int r;
for (r = 0; r < ft.rows; r++)
memset(FTCMAP[r], FTCHAR_ERASE, ft.cols * sizeof(ftchar));
for (r = 0; r < ft.rows; r++)
memset(FTAMAP[r], FTATTR_ERASE, ft.cols * sizeof(ftattr));
fterm_markdirty();
}
void
clear(void)
{
clrscr();
move(0,0);
}
void
clrtoeol(void)
{
memset(FTPC, FTCHAR_ERASE, ft.cols - ft.x);
memset(FTPA, FTATTR_ERASE, ft.cols - ft.x);
fterm_markdirty();
}
void
clrtobeg(void)
{
memset(FTCROW, FTCHAR_ERASE, ft.x+1);
memset(FTAROW, FTATTR_ERASE, ft.x+1);
fterm_markdirty();
}
void
clrcurrline(void)
{
memset(FTCROW, FTCHAR_ERASE, ft.cols);
memset(FTAROW, FTATTR_ERASE, ft.cols);
fterm_markdirty();
}
void
clrtoln(int line)
{
if (line <= ft.y)
return;
clrregion(ft.y, line-1);
}
void
clrregion(int r1, int r2)
{
// bi-direction
if (r1 > r2)
{
int r = r1;
r1 = r2; r2 = r;
}
// check r1, r2 range
r1 = ranged(r1, 0, ft.rows-1);
r2 = ranged(r2, 0, ft.rows-1);
for (; r1 <= r2; r1++)
{
memset(FTCMAP[r1], FTCHAR_ERASE, ft.cols);
memset(FTAMAP[r1], FTATTR_ERASE, ft.cols);
}
fterm_markdirty();
}
void
clrtobot(void)
{
clrtoeol();
clrregion(ft.y+1, ft.rows-1);
}
void
clrtohome(void)
{
clrtobeg();
clrregion(ft.y-1, 0);
}
// flushing
void
redrawwin(void)
{
// flip page
fterm_flippage();
clrscr();
// clear raw terminal
fterm_rawclear();
// flip page again
fterm_flippage();
// now, refresh.
fterm_markdirty();
refresh();
}
void
refresh(void)
{
int y, x;
// prevent passive update
if(fterm_inbuf())
return;
if (!ft.dirty)
{
fterm_rawcursor();
return;
}
// if scroll, do it first
if (ft.scroll)
fterm_rawscroll(ft.scroll);
// calculate and optimize dirty
for (y = 0; y < ft.rows; y++)
{
int len = ft.cols, ds = 0, derase = 0;
char dbcs = 0, odbcs = 0; // 0: none, 1: lead, 2: tail
// reset dirty map
memset(FTD, 0, ft.cols * sizeof(ftchar));
// first run: character diff
for (x = 0; x < len; x++)
{
// build base dirty information
if (FTCMAP[y][x] != FTOCMAP[y][x])
FTD[x] |= FTDIRTY_CHAR, ds++;
if (FTAMAP[y][x] != FTOAMAP[y][x])
FTD[x] |= FTDIRTY_ATTR, ds++;
// determine DBCS status
if (dbcs == 1)
{
#ifdef FTCONF_PREVENT_INVALID_DBCS
// (1) check if lead is really valid.
// (2) check if tail is valid.
// - if not valid, only SBCS safe characters can be print.
if ((!FTDBCS_ISBADLEAD(FTCMAP[y][x-1])) &&
FTDBCS_ISTAIL(FTCMAP[y][x]) )
{
FTD[x-1] &= ~FTDIRTY_INVALID_DBCS;
}
else if (!FTDBCS_ISSBCSPRINT(FTCMAP[y][x]))
{
FTD[x] |= FTDIRTY_INVALID_DBCS;
}
#endif // FTCONF_PREVENT_INVALID_DBCS
dbcs = 2;
// TAIL: dirty prev and me if any is dirty.
if (FTD[x] || FTD[x-1])
{
FTD[x] |= FTDIRTY_DBCS;
FTD[x-1]|= FTDIRTY_CHAR;
}
}
else if (FTDBCS_ISLEAD(FTCMAP[y][x]))
{
// LEAD: clear dirty when tail was found.
dbcs = 1;
FTD[x] |= FTDIRTY_INVALID_DBCS;
}
else
{
// NON-DBCS
dbcs = 0;
}
if (odbcs == 1)
{
// TAIL: dirty prev and me if any is dirty.
odbcs = 2;
if (FTD[x] || FTD[x-1])
{
FTD[x] |= FTDIRTY_CHAR;
FTD[x-1]|= FTDIRTY_CHAR;
}
}
else if (FTDBCS_ISLEAD(FTOCMAP[y][x]))
{
// LEAD: dirty next?
odbcs = 1;
}
else
{
odbcs = 0;
}
}
#ifndef DBG_SHOWDIRTY
if (!ds)
continue;
#endif // DBG_SHOWDIRTY
// Optimization: calculate ERASE section
for (x = ft.cols - 1; x >= 0; x--)
if (FTCMAP[y][x] != FTCHAR_ERASE ||
FTAMAP[y][x] != FTATTR_ERASE)
break;
else if (FTD[x])
derase++;
// Optimize by fterm_rawclreol();
len = x+1;
for (x = 0; x < len; x++)
{
// logic: each move takes at least 4+ bytes (ESC [ n C)
// each attribute change takes 5+ bytes (ESC [ xx m)
// so do move if clean region > 4 bytes or if attribute is changed.
#ifndef DBG_SHOWDIRTY
if (!FTD[x])
continue;
#endif // !DBG_SHOWDIRTY
// optimized move
fterm_rawmove_opt(y, x);
#ifdef DBCSAWARE
if ((FTD[x] & FTDIRTY_DBCS) && (FT_DBCS_NOINTRESC))
{
// prevent changing attributes inside DBCS
}
else
#endif // DBCSAWARE
#ifdef DBG_SHOWDIRTY
fterm_rawattr(FTD[x] ?
(FTAMAP[y][x] | FTATTR_BOLD) : (FTAMAP[y][x] & ~FTATTR_BOLD));
#else // !DBG_SHOWDIRTY
fterm_rawattr(FTAMAP[y][x]);
#endif // !DBG_SHOWDIRTY
#ifdef FTCONF_PREVENT_INVALID_DBCS
if (FTD[x] & FTDIRTY_INVALID_DBCS)
fterm_rawc(FTCHAR_INVALID_DBCS);
else
#endif // FTCONF_PREVENT_INVALID_DBCS
fterm_rawc (FTCMAP[y][x]);
ft.rx++;
}
if (derase)
{
fterm_rawmove_opt(y, len);
fterm_rawclreol();
}
}
fterm_dupe2bk();
fterm_rawcursor();
ft.dirty = 0;
}
// cursor management
void
getyx(int *y, int *x)
{
if (y)
*y = ft.y;
if (x)
*x = ft.x;
}
void
move(int y, int x)
{
y = ranged(y, 0, ft.rows-1);
x = ranged(x, 0, ft.cols-1);
ft.y = y;
ft.x = x;
}
// scrolling
void
scrl(int rows)
{
if (!rows)
return;
if (rows > 0)
{
for (; rows > 0; rows--)
scroll();
} else {
for (; rows < 0; rows++)
rscroll();
}
}
void
scroll()
{
// scroll up
int y;
ftchar *c0 = FTCMAP[0], *oc0 = FTOCMAP[0];
ftattr *a0 = FTAMAP[0], *oa0 = FTOAMAP[0];
// prevent mixing buffered scroll up+down
if (ft.scroll < 0)
fterm_rawscroll(ft.scroll);
// smart scroll: move pointers
for (y = 0; y < ft.rows-1; y++)
{
FTCMAP[y] = FTCMAP[y+1];
FTAMAP[y] = FTAMAP[y+1];
FTOCMAP[y]= FTOCMAP[y+1];
FTOAMAP[y]= FTOAMAP[y+1];
}
FTCMAP[y] = c0;
FTAMAP[y] = a0;
FTOCMAP[y]= oc0;
FTOAMAP[y]= oa0;
// XXX also clear backup buffer
// must carefully consider if up then down scrolling.
fterm_flippage();
clrregion(ft.rows-1, ft.rows-1);
fterm_flippage();
clrregion(ft.rows-1, ft.rows-1);
ft.scroll ++;
// fterm_markdirty(); // should be already dirty
}
void
rscroll()
{
// scroll down
int y;
ftchar *c0 = FTCMAP[ft.rows -1], *oc0 = FTOCMAP[ft.rows -1];
ftattr *a0 = FTAMAP[ft.rows -1], *oa0 = FTOAMAP[ft.rows -1];
// prevent mixing buffered scroll up+down
if (ft.scroll > 0)
fterm_rawscroll(ft.scroll);
// smart scroll: move pointers
for (y = ft.rows -1; y > 0; y--)
{
FTCMAP[y] = FTCMAP[y-1];
FTAMAP[y] = FTAMAP[y-1];
FTOCMAP[y]= FTOCMAP[y-1];
FTOAMAP[y]= FTOAMAP[y-1];
}
FTCMAP[y] = c0;
FTAMAP[y] = a0;
FTOCMAP[y]= oc0;
FTOAMAP[y]= oa0;
// XXX also clear backup buffer
// must carefully consider if up then down scrolling.
fterm_flippage();
clrregion(0, 0);
fterm_flippage();
clrregion(0, 0);
ft.scroll --;
// fterm_markdirty(); // should be already dirty
}
// output
void
outs(const char *s)
{
if (!s)
return;
while (*s)
outc(*s++);
}
void
outstr(const char *str)
{
if (!str)
{
fterm_prepare_str(0);
return;
}
// calculate real length of str (stripping escapes)
// TODO only print by the returned size
fterm_prepare_str(fterm_strdlen(str));
outs(str);
// maybe the source string itself is broken...
// basically this should be done by clients, not term library.
#if 0
{
int isdbcs = 0;
while (*str)
{
if (isdbcs == 1) isdbcs = 2;
else if (FTDBCS_ISLEAD(*str)) isdbcs = 1;
else isdbcs = 0;
str++;
}
if (isdbcs == 1) // incomplete string!
outs("\b?");
}
#endif
}
void
outc(unsigned char c)
{
fterm_markdirty();
if (ft.szcmd)
{
// collecting commands
ft.cmd[ft.szcmd++] = c;
if ((ft.szcmd == 2 && c == '[') ||
(ANSI_IS_PARAM(c) && ft.szcmd < FTCMD_MAXLEN))
return;
// process as command
fterm_exec();
ft.szcmd = 0;
}
else if (c == ESC_CHR)
{
// start of escaped commands
ft.cmd[ft.szcmd++] = c;
}
else if (c == '\t')
{
// tab: move by 8
int x = ft.x;
if (x % 8 == 0)
x += 8;
else
x += (8-x);
ft.x = ranged(x, 0, ft.rows-1);
}
else if (c == '\b')
{
ft.x = ranged(ft.x-1, 0, ft.rows-1);
}
else if (c == '\r' || c == '\n')
{
// new line: cursor movement, and do not print anything
// XXX old screen.c also calls clrtoeol() for newlins.
clrtoeol();
ft.x = 0;
ft.y ++;
while (ft.y >= ft.rows)
{
// XXX scroll at next dirty?
// screen.c ignored such scroll.
// scroll();
ft.y --;
}
}
else if (iscntrl((unsigned char)c))
{
// unknown control characters: ignore
}
else // normal characters
{
// XXX allow x == ft.cols?
if (ft.x >= ft.cols)
{
ft.x = 0;
ft.y ++;
while (ft.y >= ft.rows)
{
// XXX scroll at next dirty?
// screen.c ignored such scroll.
// scroll();
ft.y --;
}
}
// normal characters
FTC = c;
#ifdef FTATTR_TRANSPARENT
if (ft.attr != FTATTR_TRANSPARENT)
#endif // FTATTR_TRANSPARENT
FTA = ft.attr;
ft.x ++;
}
}
// readback
int
instr (char *str)
{
int x = ft.cols -1;
*str = 0;
if (ft.y < 0 || ft.y >= ft.rows || ft.x < 0 || ft.x >= ft.cols)
return 0;
// determine stopping location
while (x >= ft.x && FTCROW[x] == FTCHAR_ERASE)
x--;
if (x < ft.x) return 0;
x = x - ft.x + 1;
memcpy(str, FTCROW+ft.x, x);
str[x] = 0;
return x;
}
int
innstr (char *str, int n)
{
int on = n;
int x = ranged(ft.x + n-1, 0, ft.cols-1);
*str = 0;
n = x - ft.x+1;
if (on < 1 || ft.y < 0 || ft.y >= ft.rows || ft.x < 0 || ft.x >= ft.cols)
return 0;
// determine stopping location
while (x >= ft.x && FTCROW[x] == FTCHAR_ERASE)
x--;
if (x < ft.x) return 0;
n = x - ft.x + 1;
if (n >= on) n = on-1;
memcpy(str, FTCROW+ft.x, n);
str[n] = 0;
return n;
}
int
inansistr (char *str, int n)
{
int x = ft.cols -1, i = 0, szTrail = 0;
char *ostr = str;
char cmd[FTATTR_MINCMD*2] = "";
ftattr a = FTATTR_DEFAULT;
*str = 0;
if (ft.y < 0 || ft.y >= ft.rows || ft.x < 0 || ft.x >= ft.cols)
return 0;
if (n < 1)
return 0;
n--; // preserve last zero
// determine stopping location
while (x >= ft.x && FTCROW[x] == FTCHAR_ERASE && FTAROW[x] == FTATTR_ERASE)
x--;
// retrieve [rt.x, x]
if (x < ft.x) return 0;
// preserve some bytes if last attribute is not FTATTR_DEFAULT
for (i = ft.x; n > szTrail && i <= x; i++)
{
*str = 0;
if (a != FTAROW[i])
{
fterm_chattr(cmd, a, FTAROW[i]);
a = FTAROW[i];
if (a != FTATTR_DEFAULT)
szTrail = 3; // ESC [ m
else
szTrail = 0;
if (strlen(cmd) >= n-szTrail)
break;
strcpy(str, cmd);
n -= strlen(cmd);
str += strlen(cmd);
}
// n should > szTrail
*str ++ = FTCROW[i];
n--;
}
if (szTrail && n >= szTrail)
{
*str++ = ESC_CHR; *str++ = '['; *str++ = 'm';
}
*str = 0;
return (str - ostr);
}
// core of piaip's flat-term
void
fterm_flippage (void)
{
// we have only 2 pages now.
ft.mi = 1 - ft.mi;
}
void
fterm_markdirty (void)
{
ft.dirty = 1;
}
void fterm_dupe2bk(void)
{
int r = 0;
for (r = 0; r < ft.rows; r++)
{
memcpy(FTOCMAP[r], FTCMAP[r], ft.cols * sizeof(ftchar));
memcpy(FTOAMAP[r], FTAMAP[r], ft.cols * sizeof(ftattr));
}
}
int
fterm_prepare_str(int len)
{
// clear and make (cursor, +len) as DBCS-ready.
int x = ranged(ft.x, 0, ft.cols-1);
int y = ranged(ft.y, 0, ft.rows-1);
int dbcs = 0, sdbcs = 0;
// TODO what if x+len is outside range?
// check if (x,y) is in valid range
if (x != ft.x || y != ft.y)
return -1;
len = ranged(x+len, x, ft.cols);
for (x = 0; x < len; x++)
{
// determine DBCS status
if (dbcs == 1)
dbcs = 2; // TAIL
else if (FTDBCS_ISLEAD(FTCROW[x]))
dbcs = 1; // LEAD
else
dbcs = 0;
if (x == ft.x) sdbcs = dbcs;
}
x = ft.x;
// fix start and end
if(sdbcs == 2) // TAIL, remove word
x--;
if (dbcs == 1) // LEAD, remove word
len ++;
len = ranged(len, 0, ft.rows);
len -= x;
memset(FTCROW + x, FTCHAR_ERASE, len);
return len;
}
void
fterm_exec(void)
{
ftchar cmd = ft.cmd[ft.szcmd-1];
char *p = (char*)ft.cmd + 2; // ESC [
int n = -1, x, y;
ft.cmd[ft.szcmd] = 0;
if (isdigit(*p))
{
n = atoi(p);
while (*p && isdigit(*p))
p++;
if (*p == ';')
p++;
// p points to next param now
}
switch(cmd)
{
// Cursor Movement
case 'A': // CUU: CSI n A
case 'B': // CUD: CSI n B
case 'C': // CUF: CSI n C
case 'D': // CUB: CSI n D
// Moves the cursor n (default 1) cells in the given direction.
// If the cursor is already at the edge of the screen, this has no effect.
if (n < 1)
n = 1;
getyx(&y, &x);
if (cmd == 'A') { y -= n; }
else if (cmd == 'B') { y += n; }
else if (cmd == 'C') { x += n; }
else if (cmd == 'D') { x -= n; }
move(y, x);
break;
case 'E': // CNL: CSI n E
case 'F': // CPL: CSI n F
// Moves cursor to beginning of the line
// n (default 1) lines up/down (next/previous line).
if (n < 1)
n = 1;
getyx(&y, &x);
if (cmd == 'E') { y -= n; }
else if (cmd == 'F') { y += n; }
move(y, 0);
break;
case 'G': // CHA: CSI n G
// Moves the cursor to column n.
getyx(&y, &x);
move(y, n-1);
break;
case 'H': // CUP: CSI n ; m H
case 'f': // HVP: CSI n ; m f
// Moves the cursor to row n, column m.
// The values are 1-based, and default to 1 (top left corner) if omitted.
// A sequence such as CSI ;5H is a synonym for CSI 1;5H as well as
// CSI 17;H is the same as CSI 17H and CSI 17;1H
y = n;
if (y >= 0 && isdigit(*p))
x = atoi((char*)p);
if (y < 0) y = 1;
if (x < 0) x = 1;
move(y-1, x-1);
break;
// Clear
case 'J': // ED: CSI n J
// Clears part of the screen.
// If n is zero (or missing), clear from cursor to end of screen.
// If n is one, clear from cursor to beginning of the screen.
// If n is two, clear entire screen
if (n == 0 || n < 0)
clrtobot();
else if (n == 1)
clrtohome();
else if (n == 2)
{
clrregion(0, ft.rows-1);
}
break;
case 'K': // EL: CSI n K
// Erases part of the line.
// If n is zero (or missing), clear from cursor to the end of the line.
// If n is one, clear from cursor to beginning of the line.
// If n is two, clear entire line. Cursor position does not change.
if (n == 0 || n < 0)
clrtoeol();
else if (n == 1)
clrtobeg();
else if (n == 2)
clrcurrline();
break;
case 's': // SCP: CSI s
// Saves the cursor position.
getyx(&ft.sy, &ft.sx);
break;
case 'u': // RCP: CSI u
// Restores the cursor position.
move(ft.sy, ft.sx);
break;
case 'S': // SU: CSI n S
// Scroll whole page up by n (default 1) lines.
// New lines are added at the bottom.
if (n < 1)
n = 1;
scrl(n);
break;
case 'T': // SD: CSI n T
// Scroll whole page down by n (default 1) lines.
// New lines are added at the top.
if (n < 1)
n = 1;
scrl(-n);
break;
case 'm': // SGR: CSI n [;k] m
// Sets SGR (Select Graphic Rendition) parameters.
// After CSI can be zero or more parameters separated with ;.
// With no parameters, CSI m is treated as CSI 0 m (reset / normal),
// which is typical of most of the ANSI codes.
// ---------------------------------------------------------
// SGR implementation:
// SGR 0 (reset/normal) is supported.
// SGR 1 (intensity: bold) is supported.
// SGR 2 (intensity: faint) is not supported.
// SGR 3 (italic: on) is not supported. (converted to inverse?)
// SGR 4 (underline: single) is not supported.
// SGR 5 (blink: slow) is supported.
// SGR 6 (blink: rapid) is converted to (blink: slow)
// SGR 7 (image: negative) is supported.
// SGR 8 (conceal) is not supported.
// SGR 21(underline: double) is not supported.
// SGR 22(intensity: normal) is supported.
// SGR 24(underline: none) is not supported.
// SGR 25(blink: off) is supported.
// SGR 27(image: positive) is not supported.
// SGR 28(reveal) is not supported.
// SGR 30-37 (FG) is supported.
// SGR 39 (FG-reset) is supported.
// SGR 40-47 (BG) is supported.
// SGR 49 (BG-reset) is supported.
if (n == -1) // first param
n = 0;
while (n > -1)
{
if (n >= 30 && n <= 37)
{
// set foreground
attrsetfg(n - 30);
}
else if (n >= 40 && n <= 47)
{
// set background
attrsetbg(n - 40);
}
else switch(n)
{
case 0:
attrset(FTATTR_DEFAULT);
break;
case 1:
attrset(attrget() | FTATTR_BOLD);
break;
case 22:
attrset(attrget() & ~FTATTR_BOLD);
break;
case 5:
case 6:
attrset(attrget() | FTATTR_BLINK);
break;
case 25:
attrset(attrget() & ~FTATTR_BLINK);
break;
case 3:
case 7:
{
ftattr a = attrget();
attrsetfg(FTATTR_GETBG(a));
attrsetbg(FTATTR_GETFG(a));
}
break;
case 39:
attrsetfg(FTATTR_DEFAULT_FG);
break;
case 49:
attrsetbg(FTATTR_DEFAULT_BG);
break;
}
// parse next command
n = -1;
if (*p == ';')
{
n = 0;
p++;
}
else if (isdigit(*p))
{
n = atoi(p);
while (isdigit(*p)) p++;
if (*p == ';')
p++;
}
}
break;
default: // unknown command.
break;
}
}
int
fterm_chattr(char *s, ftattr oattr, ftattr nattr)
{
ftattr
fg, bg, bold, blink,
ofg, obg, obold, oblink;
char lead = 1;
if (oattr == nattr)
return 0;
*s++ = ESC_CHR;
*s++ = '[';
fg = FTATTR_GETFG(nattr);
bg = FTATTR_GETBG(nattr);
bold = (nattr & FTATTR_BOLD) ? 1 : 0;
blink = (nattr & FTATTR_BLINK)? 1 : 0;
ofg = FTATTR_GETFG(oattr);
obg = FTATTR_GETBG(oattr);
obold = (oattr & FTATTR_BOLD) ? 1 : 0;
oblink = (oattr & FTATTR_BLINK)? 1 : 0;
if ((oblink != blink && !blink) ||
(obold != bold && !bold) )
{
if (lead) lead = 0; else *s++ = ';';
*s++ = '0';
ofg = FTATTR_DEFAULT_FG;
obg = FTATTR_DEFAULT_BG;
obold = 0; oblink = 0;
}
if (bold && !obold)
{
if (lead) lead = 0; else *s++ = ';';
*s++ = '1';
}
if (blink && !oblink)
{
if (lead) lead = 0; else *s++ = ';';
*s++ = '5'; // XXX 5(slow) or 6(fast)?
}
if (ofg != fg)
{
if (lead) lead = 0; else *s++ = ';';
*s++ = '3';
*s++ = '0' + fg;
}
if (obg != bg)
{
if (lead) lead = 0; else *s++ = ';';
*s++ = '4';
*s++ = '0' + bg;
}
*s++ = 'm';
*s++ = 0;
return 1;
}
int
fterm_strdlen(const char *s)
{
char ansi = 0;
int sz = 0;
// the logic should match outc().
while (s && *s)
{
if (!ansi) // ansi == 0
{
switch(*s)
{
case ESC_CHR:
ansi++;
break;
case '\r':
case '\n':
break;
case '\b':
if (sz) sz--;
break;
case '\t':
// XXX how to deal with this?
sz ++;
break;
default:
if (!iscntrl((unsigned char)*s))
sz++;
break;
}
}
else if (ansi == 1)
{
if (*s == '[')
ansi++;
else
ansi = 0;
}
else if (!ANSI_IS_PARAM(*s)) // ansi == 2
{
// TODO outc() take max to FTCMD_MAXLEN now...
ansi = 0;
}
s++;
}
return sz;
}
void
fterm_rawattr(ftattr rattr)
{
static char cmd[FTATTR_MINCMD*2];
if (!fterm_chattr(cmd, ft.rattr, rattr))
return;
fterm_raws(cmd);
ft.rattr = rattr;
}
void
fterm_rawnum(int arg)
{
if (arg < 0 || arg > 99)
{
// complex. use printf.
char sarg[16]; // max int
sprintf(sarg, "%d", arg);
fterm_raws(sarg);
} else if (arg < 10) {
// 0 .. 10
fterm_rawc('0' + arg);
} else {
fterm_rawc('0' + arg/10);
fterm_rawc('0' + arg%10);
}
}
void
fterm_rawcmd(int arg, int defval, char c)
{
fterm_rawc(ESC_CHR);
fterm_rawc('[');
if (arg != defval)
fterm_rawnum(arg);
fterm_rawc(c);
}
void
fterm_rawcmd2(int arg1, int arg2, int defval, char c)
{
fterm_rawc(ESC_CHR);
fterm_rawc('[');
// XXX Win/DOS telnet does now accept omitting first value
// ESC[nX and ESC[n;X works, but ESC[;mX does not work.
if (arg1 != defval || arg2 != defval)
{
fterm_rawnum(arg1);
if (arg2 != defval)
{
fterm_rawc(';');
fterm_rawnum(arg2);
}
}
fterm_rawc(c);
}
void
fterm_rawclear(void)
{
fterm_rawhome();
// ED: CSI n J, 0 = cursor to bottom, 2 = whole
fterm_raws(ESC_STR "[2J");
}
void
fterm_rawclreol(void)
{
#ifdef FTCONF_CLEAR_SETATTR
ftattr oattr = ft.rattr;
// XXX If we skip with "backround only" here, future updating
// may get wrong attributes. Or not? (consider DBCS...)
// if (FTATTR_GETBG(oattr) != FTATTR_GETBG(FTATTR_ERASE))
fterm_rawattr(FTATTR_ERASE);
#endif
// EL: CSI n K, n = 0
fterm_raws(ESC_STR "[K");
#ifdef FTCONF_CLEAR_SETATTR
fterm_rawattr(oattr);
#endif
}
void
fterm_rawhome(void)
{
// CUP: CSI n ; m H
fterm_raws(ESC_STR "[H");
ft.rx = ft.ry = 0;
}
void
fterm_rawmove_rel(int dy, int dx)
{
#ifndef FTCONF_USE_ANSI_RELMOVE
// Old BBS system does not output relative moves (ESC[ABCD) .
// Poor terminals (ex, pcman-1.0.5-FF20.xpi)
// do not support relmoves
fterm_rawmove(ft.ry + dy, ft.rx + dx);
#else
if (!dx)
{
int y = ranged(dy + ft.ry, 0, ft.rows-1);
dy = y - ft.ry;
if (!dy)
return;
fterm_rawcmd(abs(dy), 1, dy < 0 ? 'A' : 'B');
ft.ry = y;
}
else if (!dy)
{
int x = ranged(dx + ft.rx, 0, ft.cols-1);
dx = x - ft.rx;
if (!dx)
return;
fterm_rawcmd(abs(dx), 1, dx < 0 ? 'D' : 'C');
ft.rx = x;
}
else
{
// (dy, dx) are given - use fterm_move.
fterm_rawmove(ft.ry + dy, ft.rx + dx);
}
#endif
}
void
fterm_rawmove(int y, int x)
{
y = ranged(y, 0, ft.rows-1);
x = ranged(x, 0, ft.cols-1);
if (y == ft.ry && x == ft.rx)
return;
// CUP: CSI n ; m H
fterm_rawcmd2(y+1, x+1, 1, 'H');
ft.ry = y;
ft.rx = x;
}
void
fterm_rawmove_opt(int y, int x)
{
// optimized move
int ady = abs(y-ft.ry), adx=abs(x-ft.rx);
if (!adx && !ady)
return;
#ifdef DBG_DISABLE_OPTMOVE
return fterm_rawmove(y, x);
#endif
// known hacks: \r = (x=0), \b=(x--), \n = (y++)
#ifndef DBG_TEXT_FD
// x=0: the cheapest output. However not work for text mode fd output.
if (adx && x == 0)
{
fterm_rawc('\r');
ft.rx = x = adx = 0;
}
#endif // !DBG_TEXT_FD
// x--: compare with FTMV_COST: ESC[m;nH costs 5-8 bytes
if (x < ft.rx && y >= ft.ry && (adx+ady) < FTMV_COST)
{
while (adx > 0)
fterm_rawc('\b'), adx--;
ft.rx = x;
}
// if move right and same attributes between, use space.
if (x > ft.rx && (adx+ady) < FTMV_COST)
{
int i = 0;
for (; i < adx; i++)
{
// warning: count space only, to preven DBCS issue.
if (FTCMAP[ft.ry][ft.rx+i] != ' ' ||
FTAMAP[ft.ry][ft.rx+i] != ft.rattr)
break;
}
if (i == adx)
{
// safe to use spaces
fterm_rawnc(' ', adx);
x = ft.rx += adx;
adx = 0;
}
}
// finishing movement
if (y > ft.ry && ady < FTMV_COST && adx == 0)
{
while (ft.ry++ < y)
fterm_rawc('\n');
ft.ry = y;
}
else if (ady && adx)
{
fterm_rawmove(y, x);
}
else if (ady)
{
fterm_rawmove_rel(y-ft.ry, 0);
}
else if (adx)
{
fterm_rawmove_rel(0, x-ft.rx);
}
}
void
fterm_rawcursor(void)
{
fterm_rawattr(ft.attr);
fterm_rawmove_opt(ft.y, ft.x);
fterm_rawflush();
}
void
fterm_rawscroll (int dy)
{
#ifdef FTCONF_USE_ANSI_SCROLL
// SU: CSI n S (up)
// SD: CSI n T (down)
char cmd = (dy > 0) ? 'S' : 'T';
int ady = abs(dy);
if (ady == 0)
return;
if (ady >= ft.rows) ady = ft.rows;
fterm_rawcmd(ady, 1, cmd);
ft.scroll -= dy;
#else
// VT100 flavor:
// * ESC D: cursor down - at bottom of region, scroll up
// * ESC M: cursor up - at top of region, scroll down
// Elder BBS systems do \n at (rows-1) as scroll()
// and ESC-M at(0) as rscoll().
// SCP: CSI s / RCP: CSI u
// Warning: cannot use SCP/RCP here, because on Win/DOS telnet
// the position will change after scrolling (ex, (25,0)->(24,0).
//
// Since Scroll does not happen very often, let's relax and not
// optimize these commands here...
int ady = abs(dy);
if (ady == 0)
return;
if (ady >= ft.rows) ady = ft.rows;
// we are not going to preserve (rx,ry)
// so don't use fterm_move*.
if (dy > 0)
fterm_rawcmd2(ft.rows, 1, 1, 'H');
else
fterm_rawcmd2(1, 1, 1, 'H');
for (; ady > 0; ady--)
{
if (dy >0)
{
// Win/DOS telnet may have extra text in new line,
// because of the IME line.
fterm_raws("\n" ESC_STR "[K");
} else {
fterm_raws(ESC_STR "M"); // ESC_STR "[K");
}
}
// Do not use optimized move here, because in poor terminals
// the coordinates are already out of sync.
fterm_rawcmd2(ft.ry+1, ft.rx+1, 1, 'H');
ft.scroll -= dy;
#endif
}
void
fterm_raws(const char *s)
{
while (*s)
fterm_rawc(*s++);
}
void
fterm_rawnc(int c, int n)
{
while (n-- > 0)
fterm_rawc(c);
}
//////////////////////////////////////////////////////////////////////////
// grayout advanced control
//////////////////////////////////////////////////////////////////////////
void
grayout(int y, int end, int level)
{
char grattr = FTATTR_DEFAULT;
y = ranged(y, 0, ft.rows-1);
end = ranged(end, 0, ft.rows-1);
if (level == GRAYOUT_BOLD)
{
grattr |= FTATTR_BOLD;
}
else if (level == GRAYOUT_DARK)
{
grattr = FTATTR_MAKE(0,0);
grattr |= FTATTR_BOLD;
}
else if (level == GRAYOUT_NORM)
{
// normal text
}
else
{
// not supported yet
}
for (; y <= end; y++)
{
memset(FTAMAP[y], grattr, ft.cols);
}
}
//////////////////////////////////////////////////////////////////////////
// deprecated api
//////////////////////////////////////////////////////////////////////////
void
standout(void)
{
outs(ANSI_COLOR(7));
}
void
standend(void)
{
outs(ANSI_RESET);
}
#ifndef _PFTERM_TEST_MAIN
void
scr_dump(screen_backup_t *psb)
{
int y = 0;
void *p = NULL;
psb->row= ft.rows;
psb->col= ft.cols;
psb->y = ft.y;
psb->x = ft.x;
p = psb->raw_memory =
malloc (ft.rows * ft.cols * (sizeof(ftchar) + sizeof(ftattr)));
for (y = 0; y < ft.rows; y++)
{
memcpy(p, FTCMAP[y], ft.cols * sizeof(ftchar));
p += ft.cols * sizeof(ftchar);
memcpy(p, FTAMAP[y], ft.cols * sizeof(ftattr));
p += ft.cols * sizeof(ftattr);
}
}
void
scr_restore(const screen_backup_t *psb)
{
int y = 0;
void *p = NULL;
int c = ft.cols, r = ft.rows;
if (!psb || !psb->raw_memory)
return;
p = psb->raw_memory;
c = ranged(c, 0, psb->col);
r = ranged(r, 0, psb->row);
ft.y = psb->y;
ft.x = psb->x;
ft.y = ranged(ft.y, 0, ft.rows-1);
ft.x = ranged(ft.x, 0, ft.cols-1);
clrscr();
for (y = 0; y < r; y++)
{
memcpy(FTCMAP[y], p, c * sizeof(ftchar));
p += psb->col * sizeof(ftchar);
memcpy(FTAMAP[y], p, c * sizeof(ftattr));
p += psb->col * sizeof(ftattr);
}
free(psb->raw_memory);
ft.dirty = 1;
refresh();
}
void
move_ansi(int y, int x)
{
move(y, x);
}
void
region_scroll_up(int top, int bottom)
{
int i;
ftchar *c0;
ftattr *a0;
// logic same with old screen.c
if (top > bottom) {
i = top;
top = bottom;
bottom = i;
}
if (top < 0 || bottom >= ft.rows)
return;
c0 = FTCMAP[top];
a0 = FTAMAP[top];
for (i = top; i < bottom; i++)
{
FTCMAP[i] = FTCMAP[i+1];
FTAMAP[i] = FTAMAP[i+1];
}
FTCMAP[bottom] = c0;
FTAMAP[bottom] = a0;
clrregion(bottom, bottom);
fterm_markdirty();
}
#endif
//////////////////////////////////////////////////////////////////////////
// adapter
//////////////////////////////////////////////////////////////////////////
int
fterm_inbuf(void)
{
#ifdef _PFTERM_TEST_MAIN
return 0;
#else
return num_in_buf();
#endif
}
void
fterm_rawc(int c)
{
#ifdef _PFTERM_TEST_MAIN
// if (c == ESC_CHR) putchar('*'); else
putchar(c);
#else
ochar(c);
#endif
}
void
fterm_rawnewline(void)
{
#ifdef _PFTERM_TEST_MAIN
putchar('\n');
#else
ochar('\r');
ochar('\n');
#endif
}
void
fterm_rawflush(void)
{
#ifdef _PFTERM_TEST_MAIN
fflush(stdout);
#else
oflush();
#endif
}
//////////////////////////////////////////////////////////////////////////
// test
//////////////////////////////////////////////////////////////////////////
#ifdef _PFTERM_TEST_MAIN
int main(int argc, char* argv[])
{
char buf[512];
char *a1 = NULL;
initscr();
if (argc < 2)
{
// DBCS test
a1 = ANSI_COLOR(1;33) "測試" ANSI_COLOR(34) "中文"
ANSI_COLOR(7) "測試" ANSI_RESET "測試"
"測試a" ANSI_RESET "\n";
#if 0
outstr(a1);
move(0, 2);
outstr("中文1");
outstr(ANSI_COLOR(1;33)"中文2");
outstr(" 中\x85");
outstr("okok herer\x8a");
move(0, 8);
inansistr(buf, sizeof(buf)-1);
move(3,5); outs(ANSI_RESET "(From inansistr:) "); outs(buf);
move(7, 3);
sprintf(buf, "strlen()=%d\n", fterm_strdlen(a1));
outstr(buf);
refresh();
getchar();
outs(ANSI_COLOR(1;33) "test " ANSI_COLOR(34) "x"
ANSI_RESET "te" ANSI_COLOR(43;0;1;35) " st"
ANSI_COLOR(0) "testx\n");
refresh();
getchar();
clear();
outs("中文中文中文中文中文中文中文中文中文中文中文中文");
move(0, 0);
outs(" this\xFF (ff)is te.(80 tail)->\x80 (80)");
refresh();
getchar();
#endif
// test optimization
clear();
move(1, 0);
outs("x++ optimization test\n");
outs("1 2 3 4 5 6 7 8 9 0\n");
outs("1122233334444455555566666667777777788888888899999999990\n");
refresh();
getchar();
move(2, 0);
outs("1122233334444455555566666667777777788888888899999999990\n");
outs("1 2 3 4 5 6 7 8 9 0\n");
refresh();
getchar();
rscroll();
refresh();
getchar();
} else {
FILE *fp = fopen(argv[1], "r");
int c = 0;
while (fp && (c=getc(fp)) > 0)
{
outc(c);
}
fclose(fp);
refresh();
}
printf("\ncomplete. enter to exit.\n");
getchar();
return 0;
}
#endif // _PFTERM_TEST_MAIN
#endif // defined(EXP_PFTERM) || defined(USE_PFTERM)
// vim:ts=4:sw=4
