/*
* Clear around the box for fancy_bce_test().
*/
static void
fancy_bce_erases(BOX *box)
{
int i;
int first;
int limit;
cup(box->top - 1, min_cols / 2);
ed(1); /* clear from home to cursor */
cuf(1);
el(0); /* clear from cursor to end of line */
cup(box->bottom + 1, min_cols / 2);
ed(0); /* clear from cursor to end */
cub(1);
el(1); /* clear to beginning of line */
for (i = box->top; i <= box->bottom; i++) {
cup(i, box->left - 1);
el(1);
cup(i, box->right + 1);
limit = min_cols - box->right;
first = i + 1 - box->top;
if (first > limit)
first = limit;
dch(first);
limit -= first;
if (limit > 0)
ech(limit);
}
}
/*
* VT200 and up
*
* Test to ensure that 'ech' (erase character) is honored, with no parameter,
* explicit parameter, and longer than the screen width (to ensure that the
* terminal doesn't try to wrap-around the erasure).
*/
static int
tst_ECH(MENU_ARGS)
{
int i;
int last = max_lines - 4;
decaln();
for (i = 1; i <= max_lines; i++) {
cup(i, min_cols - i - 2);
do_csi("X"); /* make sure default-parameter works */
cup(i, min_cols - i - 1);
printf("*");
ech(min_cols);
printf("*"); /* this should be adjacent, in the upper-right corner */
}
vt_move(last, 1);
vt_clear(0);
vt_move(last, min_cols - (last + 10));
println("diagonal: ^^ (clear)");
println("ECH test: there should be E's with a gap before diagonal of **'s");
println("The lower-right diagonal region should be cleared. Nothing else.");
return MENU_HOLD;
}
int
bug_c(MENU_ARGS)
{
deccolm(TRUE); /* 132 column mode */
cup(1, 81);
deccolm(FALSE); /* 80 column mode */
cup(12, 5);
printf("Except for this line, the screen should be blank. ");
return MENU_HOLD;
}
/*
* Scroll the box up/down to check if the colors are being shifted in. Erase
* the colors with ECH and DCH.
*/
static int
fancy_bce_test(MENU_ARGS)
{
BOX box1;
BOX box2;
static const char *text1[] =
{
"The screen background should be blue, with a box made of asterisks",
" and this caption, in orange (non-bold yellow). ",
" There should be no cells with the default foreground or background.",
0
};
static const char *text2[] =
{
"The screen background should be black, with a box made of asterisks",
" and this caption, in white (actually gray - it is not bold). ",
" Only the asterisk box should be in color.",
0
};
if (make_box_params(&box1, 3, 10) < 0
|| make_box_params(&box2, 7, 18) < 0)
return MENU_NOHOLD;
set_test_colors();
decaln();
draw_box_filled(&box1, 'X');
draw_box_outline(&box2, '*');
fancy_bce_erases(&box2);
draw_box_caption(&box2, 1, text1);
fancy_bce_shifts(&box2);
cup(max_lines - 1, 1);
holdit();
reset_test_colors();
fancy_bce_erases(&box2);
draw_box_caption(&box2, 1, text2);
fancy_bce_shifts(&box2);
cup(max_lines - 1, 1);
holdit();
reset_colors();
return MENU_NOHOLD;
}
void
draw_box_outline(BOX *box, int mark)
{
int j;
for (j = box->top; j <= box->bottom; j++) {
__(cup(j, box->left), putchar(mark));
__(cup(j, box->right), putchar(mark));
}
cup(box->top, box->left);
for (j = box->left; j < box->right; j++)
putchar(mark);
cup(box->bottom, box->left);
for (j = box->left; j < box->right; j++)
putchar(mark);
}
/* VT220 & up.
*/
static int
tst_S8C1T(MENU_ARGS)
{
char *report;
int flag = input_8bits;
int pass;
vt_move(1, 1);
println(the_title);
vt_move(5, 1);
println("This tests the VT200+ control sequence to direct the terminal to emit 8-bit");
println("control-sequences instead of <esc> sequences.");
set_tty_raw(TRUE);
set_tty_echo(FALSE);
for (pass = 0; pass < 2; pass++) {
flag = !flag;
s8c1t(flag);
cup(1, 1);
dsr(6);
report = instr();
vt_move(10 + pass * 3, 1);
printf("8-bit controls %s: ", flag ? "enabled" : "disabled");
chrprint(report);
report_ok("1;1R", report);
}
restore_ttymodes();
vt_move(max_lines - 1, 1);
return MENU_HOLD;
}
void
draw_box_caption(BOX *box, int margin, char **c)
{
int x0 = (box->left + margin);
int y0 = (box->top + margin);
int x1 = (box->right - margin);
int y1 = (box->bottom - margin);
int x = x0;
int y = y0;
int t;
char *s;
while ((s = *c++) != 0) {
while ((t = *s++) != 0) {
if (x == x0) {
if (t == ' ')
continue;
cup(y, x++);
putchar(' ');
}
putchar(t);
x++;
if ((t == ' ') && (next_word(s) > (x1 - x - 2))) {
while (x < x1) {
putchar(' ');
x++;
}
}
if (x >= x1) {
putchar(' ');
x = x0;
y++;
}
}
}
while (y <= y1) {
if (x == x0) {
cup(y, x);
}
putchar(' ');
if (++x >= x1) {
putchar(' ');
x = x0;
y++;
}
}
}
int
bug_s(MENU_ARGS)
{
int i;
decstbm(20, 10); /* 20-10=-10, < 2, so no scroll region. */
cup(1, 1);
for (i = 1; i <= 20; i++)
printf("This is 20 lines of text (line %d), no scroll region.\n", i);
holdit();
ed(2);
decstbm(0, 1); /* Should be interpreted as decstbm(1,1) = none */
cup(1, 1);
for (i = 1; i <= 20; i++)
printf("This is 20 lines of text (line %d), no scroll region.\n", i);
holdit();
decstbm(0, 0); /* No scroll region (just in case...) */
return MENU_NOHOLD;
}
void
draw_box_filled(BOX *box, int mark)
{
int i, j;
for (i = box->top; i < box->bottom; i++) {
cup(i, box->left);
for (j = box->left; j < box->right; j++) {
putchar(mark);
}
}
}
int
bug_e(MENU_ARGS)
{
int i;
static const char *rend[2] =
{"m", "7m"};
deccolm(TRUE);
cup(1, 1);
decdwl();
println("This test should put an 'X' at line 3 column 100.");
for (i = 1; i <= 12; i++)
printf("1234567890%s%s", csi_output(), rend[i & 1]);
cup(1, 1); /* The bug appears when we jump from a double-wide line */
cup(3, 100); /* to a single-wide line, column > 66. */
printf("X");
cup(4, max_cols / 2);
printf("! !");
cup(5, 1);
printf("--------------------------- The 'X' should NOT be above here -");
printf("---+------------ but above here -----+");
cup(10, 1);
decdwl();
holdit();
deccolm(FALSE);
return MENU_NOHOLD;
}
/*
* Clear around the box for simple_bce_test().
*/
static void
simple_bce_erases(BOX *box)
{
int i;
cup(box->top - 1, min_cols / 2);
ed(1); /* clear from home to cursor */
cuf(1);
el(0); /* clear from cursor to end of line */
cup(box->bottom + 1, min_cols / 2);
ed(0); /* clear from cursor to end */
cub(1);
el(1); /* clear to beginning of line */
for (i = box->top; i <= box->bottom; i++) {
cup(i, box->left - 1);
el(1);
cup(i, box->right + 1);
el(0);
}
}
static void
show_line_deletions(void)
{
int row;
ed(2);
cup(1, 1);
printf("This test deletes every third line from a list, marking cursor with '*'.\n");
printf("The foreground and background should be yellow(orange) and blue, respectively.\n");
for (row = 5; row <= max_lines; row++) {
cup(row, 1);
printf(" row %3d: this is some text", row);
}
for (row = 7; row <= max_lines; row += 2 /* 3 - deletion */ ) {
cup(row, 1);
dl(1);
putchar('*'); /* cursor should be in column 1 */
}
cup(3, 1);
holdit();
}
static void
show_line_insertions(void)
{
int row;
ed(2);
cup(1, 1);
printf("This test inserts after every second line in a list, marking cursor with '*'.\n");
printf("The foreground and background should be yellow(orange) and blue, respectively.\n");
for (row = 5; row <= max_lines; row++) {
cup(row, 1);
printf(" row %3d: this is some text", row);
}
for (row = 7; row <= max_lines; row += 3 /* 2 + insertion */ ) {
cup(row, 1);
il(1);
putchar('*'); /* cursor should be in column 1 */
}
cup(3, 1);
holdit();
}
int
bug_w(MENU_ARGS)
{
int row, col;
cup(16, 1);
println(" This illustrates the \"wrap around bug\" which exists on a");
println(" standard VT100. At the top of the screen there should be");
println(" a row of +'s, and the rightmost column should be filled");
println(" with *'s. But if the bug is present, some of the *'s may");
println(" be placed in other places, e.g. in the leftmost column,");
println(" and the top line of +'s may be scrolled away.");
cup(1, 1);
for (col = 1; col <= min_cols - 1; col++)
printf("+");
for (row = 1; row <= max_lines; row++) {
hvp(row, min_cols);
printf("*");
}
cup(max_lines, 1);
return MENU_HOLD;
}
void
draw_box_filled(BOX *box, int mark)
{
int i, j;
int ch = (mark < 0) ? 'A' : mark;
for (i = box->top; i < box->bottom; i++) {
cup(i, box->left);
for (j = box->left; j < box->right; j++) {
putchar(ch);
if (mark < 0)
ch = ((ch - 'A' + 1) % 26) + 'A';
}
}
}
/*
* Scroll the box up/down to check if the colors are being shifted in.
*/
static void
fancy_bce_shifts(BOX *box)
{
int i;
int limit = box->top - 1;
decsclm(TRUE); /* slow it down a little */
cup(1, 1);
for (i = 0; i < limit; ++i)
dl(1);
for (i = 0; i < limit; ++i)
ri();
decsclm(FALSE);
}
static int
check_8bit_toggle(void)
{
char *report;
set_tty_raw(TRUE);
cup(1,1); dsr(6);
padding(5); /* FIXME: may not be needed */
report = get_reply();
restore_ttymodes();
if ((report = skip_csi(report)) != 0
&& !strcmp(report, "1;1R"))
return TRUE;
return FALSE;
}
static int
show_test_pattern(MENU_ARGS)
/* generate a color test pattern */
{
int i, j, k;
reset_colors();
ed(2);
cup(1, 1);
printf("There are %d color combinations", MAX_COLORS * MAX_COLORS);
for (k = 0; k <= 11; k += 11) {
cup(k + 2, 1);
printf("%dx%d matrix of foreground/background colors, bright *",
MAX_COLORS, MAX_COLORS);
if (k) {
sgr("1");
printf("on");
sgr("0");
} else {
printf("off");
}
printf("*");
for (i = 0; i < MAX_COLORS; i++) {
cup(k + 3, (i + 1) * 8 + 1);
printf("%s", colors[i]);
}
for (i = 0; i < MAX_COLORS; i++) {
cup(k + i + 4, 1);
printf("%s", colors[i]);
}
for (i = 0; i < MAX_COLORS; i++) {
for (j = 0; j < MAX_COLORS; j++) {
if (k)
sgr("1");
set_color_pair(j, i);
cup(k + 4 + i, (j + 1) * 8 + 1);
printf("Hello");
reset_colors();
}
}
}
reset_colors();
cup(max_lines - 1, 1);
return MENU_HOLD;
}
char cupTest(char** topology, int length){
char *testStr = (char*)calloc(maxStrLen, sizeof(char));
int i = 0;
int j = 0;
int combinations = 0;
combinations = pow(2, length) - 1;
// printf("length: %d, combinations %d\n", length, combinations);
for(i = 0; i < combinations; i++){
for(j = 0; j < length; j++){
if (getChar(i+1, j)){
memcpy(testStr, topology[j], maxByteLen);
// printf("0: %2d %2d: test %s topology %s\n", i, j, testStr, topology[j]);
break;
}
}
for(j++; j < length; j++){
if (getChar(i+1, j)){
memcpy(testStr, cup(testStr, topology[j]), maxByteLen);
//testStr = cup(testStr, topology[j]);
//printf("1: %2d %2d: test %s topology %s\n", i, j, testStr, topology[j]);
}
}
// find result in topology, if no return false;
for(j = 0; j < length; j++){
//printf("2: %2d %2d: test %s topology %s\n", i, j, testStr, topology[j]);
if (!strcmp(testStr, topology[j])){
//puts("test succeeded");
break;
}
}
if (j == length){
//puts("test failed");
free(testStr);
return false;
}
}
free(testStr);
return true;
}
int
bug_a(MENU_ARGS)
{
int i;
cup(10, 1);
println("This is a test of the VT100 'Scroll while toggle softscroll'");
println("bug. The cursor may disappear, or move UP the screen, or");
println("multiple copies of some lines may appear.");
holdit();
/* Invoke the bug */
esc("[24H"); /* Simplified cursor movement */
decsclm(FALSE);
for (i = 1; i <= 20; i++)
printf("\n");
decsclm(TRUE);
for (i = 1; i <= 10; i++)
printf("\n");
decsclm(FALSE);
for (i = 1; i <= 5; i++)
printf("\n");
/* That should be enough to show the bug. But we'll try another way: */
decsclm(TRUE); /* Set soft scroll */
nel(); /* "NextLine", move down */
decsclm(FALSE); /* Reset soft scroll */
nel(); /* "NextLine", move down */
for (i = 1; i <= 10; i++) { /* Show the bug */
printf("Softscroll bug test, line %d. ", i);
holdit();
}
println("That should have been enough to show the bug, if present.");
return MENU_HOLD;
}
int
bug_d(MENU_ARGS)
{
int i;
char result;
/* Make the bug appear */
do {
cup(14, 1);
/* The original code in the article says
* PRINT ESC$; "[13;1H"; CHR$(10%);
* but I guess a cup(14,1); would do.
* (To output a pure LF might be tricky).
*/
deccolm(TRUE); /* Make the bug visible */
cup(1, 9);
decdwl();
println("You should see blinking text at the bottom line.");
cup(3, 9);
decdwl();
println("Enter 0 to exit, 1 to try to invoke the bug again.");
cup(max_lines, 9);
decdwl();
sgr("1;5;7");
printf("If you can see this then the bug did not appear.");
sgr("");
cup(4, 9);
decdwl();
result = inchar();
readnl();
deccolm(FALSE);
} while (result == '1');
decsclm(TRUE); /* Syrup scroll */
cup(max_lines - 1, 1);
for (i = 1; i <= 5; i++)
println("If the bug is present, this should make things much worse!");
holdit();
decsclm(FALSE); /* Jump scroll */
return MENU_NOHOLD;
}
int
bug_b(MENU_ARGS)
{
char c;
decaln();
cup(1, 1);
el(0);
printf("Line 11 should be double-wide, line 12 should be cleared.");
cup(2, 1);
el(0);
printf("Then, the letters A-P should be written at the beginning");
cup(3, 1);
el(0);
printf("of lines 12-%d, and the empty line and A-E are scrolled away.", max_lines);
cup(4, 1);
el(0);
printf("If the bug is present, some lines are confused, look at K-P.");
cup(11, 1);
decdwl();
decstbm(12, max_lines);
cup(12, 1);
el(0);
printf("Here we go... ");
holdit();
cup(12, 1);
ri(); /* Bug comes here */
for (c = 'A'; c <= 'P'; c++)
printf("%c\n", c); /* Bug shows here */
holdit();
decstbm(0, 0); /* No scr. region */
return MENU_NOHOLD;
}
void
draw_box_outline(BOX *box, int mark)
{
int j;
int tlc = (mark < 0) ? 'l' : mark;
int trc = (mark < 0) ? 'k' : mark;
int llc = (mark < 0) ? 'm' : mark;
int lrc = (mark < 0) ? 'j' : mark;
int vrt = (mark < 0) ? 'x' : mark;
int hrz = (mark < 0) ? 'q' : mark;
int dot;
if (mark < 0)
scs(0, '0');
for (j = box->top, dot = tlc; j < box->bottom; j++) {
__(cup(j, box->left), putchar(dot));
dot = vrt;
}
for (j = box->top, dot = trc; j < box->bottom; j++) {
__(cup(j, box->right), putchar(dot));
dot = vrt;
}
cup(box->top, box->left + 1);
for (j = box->left + 1; j < box->right; j++)
putchar(hrz);
cup(box->bottom, box->left + 1);
for (j = box->left + 1; j < box->right; j++)
putchar(hrz);
__(cup(box->bottom, box->left), putchar(llc));
__(cup(box->bottom, box->right), putchar(lrc));
if (mark < 0)
scs(0, 'B');
}
/* Graphic rendition requires special handling with color, since SGR-0
* is supposed to reset the colors as well.
*/
static void
show_graphic_rendition(void)
{
ed(2);
/* *INDENT-OFF* */
cup( 1,20); printf("Color/Graphic rendition test pattern:");
cup( 4, 1); c_sgr("0"); printf("vanilla");
cup( 4,40); c_sgr("0;1"); printf("bold");
cup( 6, 6); c_sgr(";4"); printf("underline");
cup( 6,45); c_sgr(";1");c_sgr("4");printf("bold underline");
cup( 8, 1); c_sgr("0;5"); printf("blink");
cup( 8,40); c_sgr("0;5;1"); printf("bold blink");
cup(10, 6); c_sgr("0;4;5"); printf("underline blink");
cup(10,45); c_sgr("0;1;4;5"); printf("bold underline blink");
cup(12, 1); c_sgr("1;4;5;0;7"); printf("negative");
cup(12,40); c_sgr("0;1;7"); printf("bold negative");
cup(14, 6); c_sgr("0;4;7"); printf("underline negative");
cup(14,45); c_sgr("0;1;4;7"); printf("bold underline negative");
cup(16, 1); c_sgr("1;4;;5;7"); printf("blink negative");
cup(16,40); c_sgr("0;1;5;7"); printf("bold blink negative");
cup(18, 6); c_sgr("0;4;5;7"); printf("underline blink negative");
cup(18,45); c_sgr("0;1;4;5;7"); printf("bold underline blink negative");
cup(20, 6); c_sgr(""); set_foreground(9); printf("original foreground");
cup(20,45); c_sgr(""); set_background(9); printf("original background");
/* *INDENT-ON* */
c_sgr(""); /* same as c_sgr("0") */
decscnm(FALSE); /* Inverse video off */
cup(max_lines - 1, 1);
el(0);
printf("Dark background. ");
holdit();
decscnm(TRUE); /* Inverse video */
cup(max_lines - 1, 1);
el(0);
printf("Light background. ");
holdit();
decscnm(FALSE);
}
/*
* Test DEC's selective-erase (set-protected area) by drawing a box of
* *'s that will remain, and a big X of *'s that gets cleared..
*/
static int
tst_DECSCA(MENU_ARGS)
{
int i, j, pass;
int tmar = 5;
int bmar = max_lines - 8;
int lmar = 20;
int rmar = min_cols - lmar;
for (pass = 0; pass < 2; pass++) {
if (pass == 0)
decsca(1);
for (i = tmar; i <= bmar; i++) {
cup(i, lmar);
for (j = lmar; j <= rmar; j++) {
printf("*");
}
}
if (pass == 0) {
decsca(0);
for (j = 0; j <= 2; j++) {
for (i = 1; i < tmar; i++) {
cup(i, lmar - tmar + (i + j));
printf("*");
cup(i, rmar + tmar - (i + j));
printf("*");
}
for (i = bmar + 1; i < max_lines; i++) {
cup(i, lmar + bmar - i + j);
printf("*");
cup(i, rmar - bmar + i - j);
printf("*");
}
cup(max_lines / 2, min_cols / 2);
decsed(j);
}
for (i = rmar + 1; i <= min_cols; i++) {
cup(tmar, i);
printf("*");
cup(max_lines / 2, i);
printf("*");
}
cup(max_lines / 2, min_cols / 2);
decsel(0); /* after the cursor */
for (i = 1; i < lmar; i++) {
cup(tmar, i);
printf("*");
cup(max_lines / 2, i);
printf("*");
}
cup(max_lines / 2, min_cols / 2);
decsel(1); /* before the cursor */
cup(tmar, min_cols / 2);
decsel(2); /* the whole line */
vt_move(max_lines - 3, 1);
vt_clear(0);
println("If your terminal supports DEC protected areas (DECSCA, DECSED, DECSEL),");
println("there will be an solid box made of *'s in the middle of the screen.");
holdit();
}
}
return MENU_NOHOLD;
}
int
tst_movements(MENU_ARGS)
{
/* Test of:
CUF (Cursor Forward)
CUB (Cursor Backward)
CUD (Cursor Down) IND (Index) NEL (Next Line)
CUU (Cursor Up) RI (Reverse Index)
CUP (Cursor Position) HVP (Horizontal and Vertical Position)
ED (Erase in Display)
EL (Erase in Line)
DECALN (Screen Alignment Display)
DECAWM (Autowrap)
<CR> <BS>
Cursor control characters inside CSI sequences
*/
int i, row, col, pass, width, hlfxtra;
const char *ctext = "This is a correct sentence";
set_tty_crmod(TRUE); /* want to disable tab/space conversion */
for (pass = 0; pass <= 1; pass++) {
int inner_l, inner_r;
if (pass == 0) {
deccolm(FALSE);
width = min_cols;
} else {
deccolm(TRUE);
width = max_cols;
}
/* Compute left/right columns for a 60-column box centered in 'width' */
inner_l = (width - 60) / 2;
inner_r = 61 + inner_l;
hlfxtra = (width - 80) / 2;
if (LOG_ENABLED)
fprintf(log_fp, "tst_movements box(%d cols)\n", pass ? max_cols : min_cols);
decaln();
cup(9, inner_l);
ed(1);
cup(18, 60 + hlfxtra);
ed(0);
el(1);
cup(9, inner_r);
el(0);
/* 132: 36..97 */
/* 80: 10..71 */
for (row = 10; row <= 16; row++) {
cup(row, inner_l);
el(1);
cup(row, inner_r);
el(0);
}
cup(17, 30);
el(2);
for (col = 1; col <= width; col++) {
hvp(max_lines, col);
printf("*");
hvp(1, col);
printf("*");
}
cup(2, 2);
for (row = 2; row <= max_lines - 1; row++) {
printf("+");
cub(1);
ind();
}
cup(max_lines - 1, width - 1);
for (row = max_lines - 1; row >= 2; row--) {
printf("+");
cub(1);
ri();
}
cup(2, 1);
for (row = 2; row <= max_lines - 1; row++) {
printf("*");
cup(row, width);
printf("*");
cub(10);
if (row < 10)
nel();
else
printf("\n");
}
cup(2, 10);
cub(42 + hlfxtra);
cuf(2);
for (col = 3; col <= width - 2; col++) {
printf("+");
cuf(0);
cub(2);
cuf(1);
}
cup(max_lines - 1, inner_r - 1);
cuf(42 + hlfxtra);
cub(2);
for (col = width - 2; col >= 3; col--) {
printf("+");
cub(1);
cuf(1);
cub(0);
printf("%c", 8);
}
cup(1, 1);
cuu(10);
cuu(1);
cuu(0);
cup(max_lines, width);
cud(10);
cud(1);
cud(0);
cup(10, 2 + inner_l);
for (row = 10; row <= 15; row++) {
for (col = 2 + inner_l; col <= inner_r - 2; col++)
printf(" ");
cud(1);
cub(58);
}
cuu(5);
cuf(1);
printf("The screen should be cleared, and have an unbroken bor-");
cup(12, inner_l + 3);
printf("der of *'s and +'s around the edge, and exactly in the");
cup(13, inner_l + 3);
printf("middle there should be a frame of E's around this text");
cup(14, inner_l + 3);
printf("with one (1) free position around it. ");
holdit();
}
deccolm(FALSE);
/* DECAWM demo */
for (pass = 0; pass <= 1; pass++) {
static char on_left[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static char on_right[] = "abcdefghijklmnopqrstuvwxyz";
int height = sizeof(on_left) - 1;
int region = max_lines - 6;
if (LOG_ENABLED)
fprintf(log_fp, "tst_movements wrap(%d cols)\n", pass ? max_cols : min_cols);
/* note: DECCOLM clears the screen */
if (pass == 0) {
deccolm(FALSE);
width = min_cols;
} else {
deccolm(TRUE);
width = max_cols;
}
println("Test of autowrap, mixing control and print characters.");
println("The left/right margins should have letters in order:");
decstbm(3, region + 3);
decom(TRUE); /* this also homes the cursor */
for (i = 0; i < height; ++i) {
switch (i % 4) {
case 0:
/* draw characters as-is, for reference */
__(cup(region + 1, 1), printf("%c", on_left[i]));
__(cup(region + 1, width), printf("%c", on_right[i]));
printf("\n");
break;
case 1:
/* simple wrapping */
__(cup(region, width), printf("%c%c", on_right[i - 1], on_left[i]));
/* backspace at right margin */
__(cup(region + 1, width), printf("%c%c %c",
on_left[i], BS, on_right[i]));
printf("\n");
break;
case 2:
/* tab to right margin */
__(cup(region + 1, width), printf("%c%c%c%c%c%c",
on_left[i], BS, BS,
TAB, TAB, on_right[i]));
__(cup(region + 1, 2), printf("%c%c\n", BS, on_left[i]));
break;
default:
/* newline at right margin */
__(cup(region + 1, width), printf("\n"));
__(cup(region, 1), printf("%c", on_left[i]));
__(cup(region, width), printf("%c", on_right[i]));
break;
}
}
decom(FALSE);
decstbm(0, 0);
cup(max_lines - 2, 1);
holdit();
}
deccolm(FALSE); /* 80 cols */
if (LOG_ENABLED)
fprintf(log_fp, "tst_movements cursor-controls in ESC sequences\n");
vt_clear(2);
vt_move(1, 1);
println("Test of cursor-control characters inside ESC sequences.");
println("Below should be four identical lines:");
println("");
println("A B C D E F G H I");
for (i = 1; i < 10; i++) {
printf("%c", '@' + i);
do_csi("2%cC", BS); /* Two forward, one backspace */
}
println("");
/* Now put CR in CUF sequence. */
printf("A ");
for (i = 2; i < 10; i++)
printf("%s%c%dC%c", csi_output(), CR, 2 * i - 2, '@' + i);
println("");
/* Now put VT in CUU sequence. */
rm("20");
for (i = 1; i < 10; i++) {
printf("%c ", '@' + i);
do_csi("1\013A");
}
println("");
println("");
holdit();
if (LOG_ENABLED)
fprintf(log_fp, "tst_movements leading zeros in ESC sequences\n");
vt_clear(2);
vt_move(1, 1);
println("Test of leading zeros in ESC sequences.");
printf("Two lines below you should see the sentence \"%s\".", ctext);
for (col = 1; *ctext; col++)
printf("%s00000000004;00000000%dH%c", csi_output(), col, *ctext++);
cup(20, 1);
restore_ttymodes();
return MENU_HOLD;
}
int
tst_screen(MENU_ARGS)
{
/* Test of:
- DECSTBM (Set Top and Bottom Margins)
- TBC (Tabulation Clear)
- HTS (Horizontal Tabulation Set)
- SM RM (Set/Reset mode): - 80/132 chars
. - Origin: Relative/absolute
. - Scroll: Smooth/jump
. - Wraparound
- SGR (Select Graphic Rendition)
- SM RM (Set/Reset Mode) - Inverse
- DECSC (Save Cursor)
- DECRC (Restore Cursor)
*/
int i, j, cset, row, col, background;
static const char *tststr = "*qx`";
static const char *attr[5] =
{
";0", ";1", ";4", ";5", ";7"
};
set_tty_crmod(TRUE); /* want to disable tab/space conversion */
cup(1, 1);
decawm(TRUE); /* DECAWM: Wrap Around ON */
for (col = 1; col <= min_cols * 2; col++)
printf("*");
decawm(FALSE); /* DECAWM: Wrap Around OFF */
cup(3, 1);
for (col = 1; col <= min_cols * 2; col++)
printf("*");
decawm(TRUE); /* DECAWM: Wrap Around ON */
cup(5, 1);
println("This should be three identical lines of *'s completely filling");
println("the top of the screen without any empty lines between.");
println("(Test of WRAP AROUND mode setting.)");
holdit();
ed(2);
tbc(3);
cup(1, 1);
for (col = 1; col <= min_cols - 2; col += 3) {
cuf(3);
hts();
}
cup(1, 4);
for (col = 4; col <= min_cols - 2; col += 6) {
tbc(0);
cuf(6);
}
cup(1, 7);
tbc(1);
tbc(2); /* no-op */
cup(1, 1);
for (col = 1; col <= min_cols - 2; col += 6)
printf("%c*", TAB);
cup(2, 2);
for (col = 2; col <= min_cols - 2; col += 6)
printf(" *");
cup(4, 1);
println("Test of TAB setting/resetting. These two lines");
printf("should look the same. ");
holdit();
for (background = 0; background <= 1; background++) {
if (background)
decscnm(FALSE);
else
decscnm(TRUE);
deccolm(TRUE); /* 132 cols */
ed(2); /* VT100 clears screen on SM3/RM3, but not obviously, so... */
cup(1, 1);
tbc(3);
for (col = 1; col <= max_cols; col += TABWIDTH) {
cuf(TABWIDTH);
hts();
}
cup(1, 1);
for (col = 1; col <= max_cols; col += 10)
printf("%.*s", (max_cols > col) ? (max_cols - col) : 10, "1234567890");
for (row = 3; row <= 20; row++) {
cup(row, row);
printf("This is %d column mode, %s background.", max_cols,
background ? "dark" : "light");
}
holdit();
deccolm(FALSE); /* 80 cols */
ed(2); /* VT100 clears screen on SM3/RM3, but not obviously, so... */
cup(1, 1);
for (col = 1; col <= min_cols; col += 10)
printf("%.*s", (min_cols > col) ? (min_cols - col) : 10, "1234567890");
for (row = 3; row <= 20; row++) {
cup(row, row);
printf("This is %d column mode, %s background.", min_cols,
background ? "dark" : "light");
}
holdit();
}
do_scrolling();
ed(2);
decstbm(max_lines - 1, max_lines);
printf(
"\nOrigin mode test. This line should be at the bottom of the screen.");
cup(1, 1);
printf("%s",
"This line should be the one above the bottom of the screen. ");
holdit();
ed(2);
decom(FALSE); /* Origin mode (absolute) */
cup(max_lines, 1);
printf(
"Origin mode test. This line should be at the bottom of the screen.");
cup(1, 1);
printf("%s", "This line should be at the top of the screen. ");
holdit();
decstbm(1, max_lines);
ed(2);
/* *INDENT-OFF* */
cup( 1,20); printf("Graphic rendition test pattern:");
cup( 4, 1); sgr("0"); printf("vanilla");
cup( 4,40); sgr("0;1"); printf("bold");
cup( 6, 6); sgr(";4"); printf("underline");
cup( 6,45);sgr(";1");sgr("4");printf("bold underline");
cup( 8, 1); sgr("0;5"); printf("blink");
cup( 8,40); sgr("0;5;1"); printf("bold blink");
cup(10, 6); sgr("0;4;5"); printf("underline blink");
cup(10,45); sgr("0;1;4;5"); printf("bold underline blink");
cup(12, 1); sgr("1;4;5;0;7"); printf("negative");
cup(12,40); sgr("0;1;7"); printf("bold negative");
cup(14, 6); sgr("0;4;7"); printf("underline negative");
cup(14,45); sgr("0;1;4;7"); printf("bold underline negative");
cup(16, 1); sgr("1;4;;5;7"); printf("blink negative");
cup(16,40); sgr("0;1;5;7"); printf("bold blink negative");
cup(18, 6); sgr("0;4;5;7"); printf("underline blink negative");
cup(18,45); sgr("0;1;4;5;7"); printf("bold underline blink negative");
/* *INDENT-ON* */
sgr("");
decscnm(FALSE); /* Inverse video off */
cup(max_lines - 1, 1);
el(0);
printf("Dark background. ");
holdit();
decscnm(TRUE); /* Inverse video */
cup(max_lines - 1, 1);
el(0);
printf("Light background. ");
holdit();
decscnm(FALSE);
ed(2);
/* *INDENT-OFF* */
cup(8,12); printf("normal");
cup(8,24); printf("bold");
cup(8,36); printf("underscored");
cup(8,48); printf("blinking");
cup(8,60); printf("reversed");
cup(10,1); printf("stars:");
cup(12,1); printf("line:");
cup(14,1); printf("x'es:");
cup(16,1); printf("diamonds:");
/* *INDENT-ON* */
for (cset = 0; cset <= 3; cset++) {
for (i = 0; i <= 4; i++) {
cup(10 + 2 * cset, 12 + 12 * i);
sgr(attr[i]);
if (cset == 0 || cset == 2)
scs_normal();
else
scs_graphics();
for (j = 0; j <= 4; j++) {
printf("%c", tststr[cset]);
}
decsc();
cup(cset + 1, i + 1);
sgr("");
scs_normal();
printf("A");
decrc();
for (j = 0; j <= 4; j++) {
printf("%c", tststr[cset]);
}
}
}
sgr("0");
scs_normal();
cup(21, 1);
println("Test of the SAVE/RESTORE CURSOR feature. There should");
println("be ten characters of each flavour, and a rectangle");
println("of 5 x 4 A's filling the top left of the screen.");
restore_ttymodes();
return MENU_HOLD;
}
int
tst_doublesize(MENU_ARGS)
{
/* Test of:
DECSWL (Single Width Line)
DECDWL (Double Width Line)
DECDHL (Double Height Line) (also implicit double width)
*/
int col, i, w, w1;
/* Print the test pattern in both 80 and 132 character width */
for (w = 0; w <= 1; w++) {
w1 = 13 * w;
ed(2);
cup(1, 1);
if (w) {
deccolm(TRUE);
printf("%3d column mode", max_cols);
} else {
deccolm(FALSE);
printf("%3d column mode", min_cols);
}
cup(5, 3 + 2 * w1);
printf("v------- left margin");
cup(7, 3 + 2 * w1);
printf("This is a normal-sized line");
decdhl(0);
decdhl(1);
decdwl();
decswl();
cup(9, 2 + w1);
printf("This is a Double-width line");
decswl();
decdhl(0);
decdhl(1);
decdwl();
cup(11, 2 + w1);
decdwl();
decswl();
decdhl(1);
decdhl(0);
printf("This is a Double-width-and-height line");
cup(12, 2 + w1);
decdwl();
decswl();
decdhl(0);
decdhl(1);
printf("This is a Double-width-and-height line");
cup(14, 2 + w1);
decdwl();
decswl();
decdhl(1);
decdhl(0);
el(2);
printf("This is another such line");
cup(15, 2 + w1);
decdwl();
decswl();
decdhl(0);
decdhl(1);
printf("This is another such line");
cup(17, 3 + 2 * w1);
printf("^------- left margin");
cup(21, 1);
printf("This is not a double-width line");
for (i = 0; i <= 1; i++) {
cup(21, 6);
if (i) {
printf("**is**");
decdwl();
} else {
printf("is not");
decswl();
}
cup(max_lines - 1, 1);
holdit();
}
}
/* Set vanilla tabs for next test */
cup(1, 1);
tbc(3);
for (col = 1; col <= max_cols; col += TABWIDTH) {
cuf(TABWIDTH);
hts();
}
deccolm(FALSE);
ed(2);
/* *INDENT-OFF* */
scs_graphics();
cup( 8,1); decdhl(0); printf("lqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqk");
cup( 9,1); decdhl(1); printf("lqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqk");
cup(10,1); decdhl(0); printf("x%c%c%c%c%cx",9,9,9,9,9);
cup(11,1); decdhl(1); printf("x%c%c%c%c%cx",9,9,9,9,9);
cup(12,1); decdhl(0); printf("x%c%c%c%c%cx",9,9,9,9,9);
cup(13,1); decdhl(1); printf("x%c%c%c%c%cx",9,9,9,9,9);
scs(1, '0'); /* should look the same as scs_graphics() */
cup(14,1); decdhl(0); printf("x x");
cup(15,1); decdhl(1); printf("x x");
cup(16,1); decdhl(0); printf("mqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqj");
cup(17,1); decdhl(1); printf("mqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqj");
scs_normal();
/* *INDENT-ON* */
sgr("1;5");
cup(12, 3);
printf("* The mad programmer strikes again * ");
cup(13, 3);
printf("%c", 9);
cub(6);
printf("* The mad programmer strikes again *");
sgr("0");
cup(max_lines - 2, 1);
println("Another test pattern... a frame with blinking bold text,");
printf("all in double-height double-width size. ");
holdit();
decstbm(8, max_lines); /* Absolute origin mode, so cursor is set at (1,1) */
cup(8, 1);
for (i = 1; i <= 12; i++)
ri();
decstbm(0, 0); /* No scroll region */
cup(1, 1);
printf("%s", "Exactly half of the box should remain. ");
return MENU_HOLD;
}
/*
* VT220 and higher implement the 22, 24, 25 and 27 codes.
* VT510 implements concealed text.
*
* ISO 6429 specifies additional SGR codes so that one needn't use SGR 0
* to reset everything before switching, e.g., set/clear pairs are
* bold 1/22
* faint 2/22
* italics 3/23
* underline 4/24
* blink 5/25
* inverse 7/27
* concealed 8/28
*/
static int
test_iso_6429_sgr(MENU_ARGS)
{
set_test_colors();
ed(2);
/* *INDENT-OFF* */
cup( 1,20); printf("Extended/Graphic rendition test pattern:");
cup( 4, 1); c_sgr("0"); printf("vanilla");
cup( 4,40); c_sgr("0;1"); printf("bold");
cup( 6, 6); c_sgr("22;4"); printf("underline");
cup( 6,45); c_sgr("24;1;4"); printf("bold underline");
cup( 8, 1); c_sgr("22;24;5"); printf("blink");
cup( 8,40); c_sgr("25;5;1"); printf("bold blink");
cup(10, 6); c_sgr("22;4;5"); printf("underline blink");
cup(10,45); c_sgr("24;25;1;4;5"); printf("bold underline blink");
cup(12, 1); c_sgr("22;24;25;7"); printf("negative");
cup(12,40); c_sgr("1"); printf("bold negative");
cup(14, 6); c_sgr("22;4;7"); printf("underline negative");
cup(14,45); c_sgr("1;4;7"); printf("bold underline negative");
cup(16, 1); c_sgr("22;24;5;7"); printf("blink negative");
cup(16,40); c_sgr("1"); printf("bold blink negative");
cup(18, 6); c_sgr("22;4"); printf("underline blink negative");
cup(18,45); c_sgr("1"); printf("bold underline blink negative");
cup(20, 6); c_sgr(""); set_foreground(9); printf("original foreground");
cup(20,45); c_sgr(""); set_background(9); printf("original background");
cup(22, 1); c_sgr(";8"); printf("concealed");
cup(22,40); c_sgr("8;7"); printf("concealed negative");
/* *INDENT-ON* */
c_sgr(""); /* same as c_sgr("0") */
printf(" <- concealed text");
decscnm(FALSE); /* Inverse video off */
cup(max_lines - 1, 1);
el(0);
printf("Dark background. ");
holdit();
decscnm(TRUE); /* Inverse video */
cup(max_lines - 1, 1);
el(0);
printf("Light background. ");
holdit();
decscnm(FALSE);
cup(max_lines - 1, 1);
el(0);
printf("Dark background. ");
holdit();
reset_colors();
return MENU_NOHOLD;
}
int
tst_insdel(MENU_ARGS)
{
/* Test of:
SM/RM(4) (= IRM (Insertion/replacement mode))
ICH (Insert Character)
DCH (Delete character)
IL (Insert line)
DL (Delete line)
*/
int i, row, col, sw, dblchr, scr132;
for (scr132 = 0; scr132 <= 1; scr132++) {
if (scr132) {
deccolm(TRUE);
sw = max_cols;
} else {
deccolm(FALSE);
sw = min_cols;
}
ed(2);
cup(1, 1);
for (row = 1; row <= max_lines; row++) {
cup(row, 1);
for (col = 1; col <= sw; col++)
printf("%c", 'A' - 1 + row);
}
cup(4, 1);
printf("Screen accordion test (Insert & Delete Line). ");
holdit();
ri();
el(2);
decstbm(2, max_lines - 1);
decom(TRUE);
cup(1, 1);
for (row = 1; row <= max_lines; row++) {
il(row);
dl(row);
}
decom(FALSE);
decstbm(0, 0);
cup(2, 1);
printf("Top line: A's, bottom line: %c's, this line, nothing more. ",
'A' - 1 + max_lines);
holdit();
cup(2, 1);
ed(0);
cup(1, 2);
printf("B");
cub(1);
sm("4");
for (col = 2; col <= sw - 1; col++)
printf("*");
rm("4");
cup(4, 1);
printf("Test of 'Insert Mode'. The top line should be 'A*** ... ***B'. ");
holdit();
ri();
el(2);
cup(1, 2);
dch(sw - 2);
cup(4, 1);
printf("Test of 'Delete Character'. The top line should be 'AB'. ");
holdit();
for (dblchr = 1; dblchr <= 2; dblchr++) {
ed(2);
for (row = 1; row <= max_lines; row++) {
cup(row, 1);
if (dblchr == 2)
decdwl();
for (col = 1; col <= sw / dblchr; col++)
printf("%c", 'A' - 1 + row);
cup(row, sw / dblchr - row);
dch(row);
}
cup(4, 1);
println("The right column should be staggered ");
printf("by one. ");
holdit();
}
ed(2);
cup(1, 1);
println("If your terminal has the ANSI 'Insert Character' function");
println("(the VT102 does not), then you should see a line like this");
println(" A B C D E F G H I J K L M N O P Q R S T U V W X Y Z");
println("below:");
println("");
for (i = 'Z'; i >= 'A'; i--) {
printf("%c%c", i, BS);
ich(2);
}
cup(10, 1);
holdit();
if (sw == max_cols)
deccolm(FALSE);
}
return MENU_NOHOLD;
}
