aboutsummaryrefslogtreecommitdiff
path: root/contrib/ncurses/tack/charset.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/ncurses/tack/charset.c')
-rw-r--r--contrib/ncurses/tack/charset.c709
1 files changed, 709 insertions, 0 deletions
diff --git a/contrib/ncurses/tack/charset.c b/contrib/ncurses/tack/charset.c
new file mode 100644
index 000000000000..c31b78b56863
--- /dev/null
+++ b/contrib/ncurses/tack/charset.c
@@ -0,0 +1,709 @@
+/*
+** Copyright (C) 1991, 1997 Free Software Foundation, Inc.
+**
+** This file is part of TACK.
+**
+** TACK is free software; you can redistribute it and/or modify
+** it under the terms of the GNU General Public License as published by
+** the Free Software Foundation; either version 2, or (at your option)
+** any later version.
+**
+** TACK is distributed in the hope that it will be useful,
+** but WITHOUT ANY WARRANTY; without even the implied warranty of
+** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+** GNU General Public License for more details.
+**
+** You should have received a copy of the GNU General Public License
+** along with TACK; see the file COPYING. If not, write to
+** the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+** Boston, MA 02111-1307, USA.
+*/
+
+#include <tack.h>
+
+MODULE_ID("$Id: charset.c,v 1.2 1999/05/09 18:30:49 tom Exp $")
+
+/*
+ Menu definitions for alternate character set and SGR tests.
+*/
+
+static void charset_bel(struct test_list *t, int *state, int *ch);
+static void charset_flash(struct test_list *t, int *state, int *ch);
+static void charset_civis(struct test_list *t, int *state, int *ch);
+static void charset_cvvis(struct test_list *t, int *state, int *ch);
+static void charset_cnorm(struct test_list *t, int *state, int *ch);
+static void charset_hs(struct test_list *t, int *state, int *ch);
+static void charset_status(struct test_list *t, int *state, int *ch);
+static void charset_dsl(struct test_list *t, int *state, int *ch);
+static void charset_enacs(struct test_list *t, int *state, int *ch);
+static void charset_smacs(struct test_list *t, int *state, int *ch);
+static void charset_attributes(struct test_list *t, int *state, int *ch);
+static void charset_sgr(struct test_list *t, int *state, int *ch);
+
+const struct test_list acs_test_list[] = {
+ {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
+ {MENU_NEXT, 3, "bel", 0, 0, charset_bel, 0},
+ {MENU_NEXT, 3, "flash", 0, 0, charset_flash, 0},
+ {MENU_NEXT, 3, "civis", 0, 0, charset_civis, 0},
+ {MENU_NEXT, 3, "cvvis", 0, 0, charset_cvvis, 0},
+ {MENU_NEXT, 3, "cnorm", 0, 0, charset_cnorm, 0},
+ {MENU_NEXT, 3, "hs", 0, 0, charset_hs, 0},
+ {MENU_NEXT, 3, "tsl) (fsl) (wsl", "hs", 0, charset_status, 0},
+ {MENU_NEXT, 3, "dsl", "hs", 0, charset_dsl, 0},
+ {MENU_NEXT, 0, "acsc) (enacs) (smacs) (rmacs", 0, 0, charset_enacs, 0},
+ {MENU_NEXT, 0, "smacs) (rmacs", 0, 0, charset_smacs, 0},
+ {MENU_NEXT, 11, 0, 0, 0, charset_attributes, 0},
+ {MENU_NEXT, 11, "sgr) (sgr0", "ma", 0, charset_sgr, 0},
+ {MENU_LAST, 0, 0, 0, 0, 0, 0}
+};
+
+const struct mode_list alt_modes[] = {
+ {"normal", "(sgr0)", "(sgr0)", 1},
+ {"standout", "(smso)", "(rmso)", 2},
+ {"underline", "(smul)", "(rmul)", 4},
+ {"reverse", "(rev)", "(sgr0)", 8},
+ {"blink", "(blink)", "(sgr0)", 16},
+ {"dim", "(dim)", "(sgr0)", 32},
+ {"bold", "(bold)", "(sgr0)", 64},
+ {"invis", "(invis)", "(sgr0)", 128},
+ {"protect", "(prot)", "(sgr0)", 256},
+ {"altcharset", "(smacs)", "(rmacs)", 512}
+};
+
+/* On many terminals the underline attribute is the last scan line.
+ This is OK unless the following line is reverse video.
+ Then the underline attribute does not show up. The following map
+ will reorder the display so that the underline attribute will
+ show up. */
+const int mode_map[10] = {0, 1, 3, 4, 5, 6, 7, 8, 9, 2};
+
+struct graphics_pair {
+ unsigned char c;
+ const char *name;
+};
+
+static struct graphics_pair glyph[] = {
+ {'+', "arrow pointing right"},
+ {',', "arrow pointing left"},
+ {'.', "arrow pointing down"},
+ {'0', "solid square block"},
+ {'i', "lantern symbol"},
+ {'-', "arrow pointing up"},
+ {'`', "diamond"},
+ {'a', "checker board (stipple)"},
+ {'f', "degree symbol"},
+ {'g', "plus/minus"},
+ {'h', "board of squares"},
+ {'j', "lower right corner"},
+ {'k', "upper right corner"},
+ {'l', "upper left corner"},
+ {'m', "lower left corner"},
+ {'n', "plus"},
+ {'o', "scan line 1"},
+ {'p', "scan line 3"},
+ {'q', "horizontal line"},
+ {'r', "scan line 7"},
+ {'s', "scan line 9"},
+ {'t', "left tee (|-)"},
+ {'u', "right tee (-|)"},
+ {'v', "bottom tee(_|_)"},
+ {'w', "top tee (T)"},
+ {'x', "vertical line"},
+ {'y', "less/equal"},
+ {'z', "greater/equal"},
+ {'{', "Pi"},
+ {'|', "not equal"},
+ {'}', "UK pound sign"},
+ {'~', "bullet"},
+ {'\0', "\0"}
+};
+
+/*
+** charset_hs(test_list, status, ch)
+**
+** (hs) test Has status line
+*/
+static void
+charset_hs(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ if (has_status_line != 1) {
+ ptext("(hs) Has-status line is not defined. ");
+ generic_done_message(t, state, ch);
+ }
+}
+
+/*
+** charset_status(test_list, status, ch)
+**
+** (tsl) (fsl) (wsl) test Status line
+*/
+static void
+charset_status(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ int i, max;
+ char *s;
+ static char m[] = "*** status line *** 123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.123456789.";
+
+ if (has_status_line != 1) {
+ return;
+ }
+ put_clear();
+ max = width_status_line == -1 ? columns : width_status_line;
+ sprintf(temp, "Terminal has status line of %d characters", max);
+ ptextln(temp);
+
+ put_str("This line s");
+ s = tparm(to_status_line, 0);
+ tc_putp(s);
+ for (i = 0; i < max; i++)
+ putchp(m[i]);
+ tc_putp(from_status_line);
+ putln("hould not be broken.");
+ ptextln("If the previous line is not a complete sentence then (tsl) to-status-line, (fsl) from-status-line, or (wsl) width-of-status-line is incorrect." );
+ generic_done_message(t, state, ch);
+}
+
+/*
+** charset_dsl(test_list, status, ch)
+**
+** (dsl) test Disable status line
+*/
+static void
+charset_dsl(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ if (has_status_line != 1) {
+ return;
+ }
+ if (dis_status_line) {
+ ptextln("Disable status line (dsl)");
+ tc_putp(dis_status_line);
+ ptext("If you can still see the status line then (dsl) disable-status-line has failed. ");
+ } else {
+ ptext("(dsl) Disable-status-line is not defined. ");
+ }
+ generic_done_message(t, state, ch);
+}
+
+
+void
+eat_cookie(void)
+{ /* put a blank if this is not a magic cookie
+ terminal */
+ if (magic_cookie_glitch < 1)
+ putchp(' ');
+}
+
+
+void
+put_mode(char *s)
+{ /* send the attribute string (with or without
+ % execution) */
+ tc_putp(tparm(s)); /* allow % execution */
+}
+
+
+void
+set_attr(int a)
+{ /* set the attribute from the bits in a */
+ int i, b[32];
+
+ if (magic_cookie_glitch > 0) {
+ char_count += magic_cookie_glitch;
+ }
+ if (a == 0 && exit_attribute_mode) {
+ put_mode(exit_attribute_mode);
+ return;
+ }
+ for (i = 0; i < 31; i++) {
+ b[i] = (a >> i) & 1;
+ }
+ tc_putp(tparm(set_attributes, b[1], b[2], b[3], b[4], b[5],
+ b[6], b[7], b[8], b[9]));
+}
+
+/*
+** charset_sgr(test_list, status, ch)
+**
+** (sgr) test Set Graphics Rendition
+*/
+static void
+charset_sgr(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ int i, j;
+
+ if (!set_attributes) {
+ ptext("(sgr) Set-graphics-rendition is not defined. ");
+ generic_done_message(t, state, ch);
+ return;
+ }
+ if (!exit_attribute_mode) {
+ ptextln("(sgr0) Set-graphics-rendition-zero is not defined.");
+ /* go ahead and test anyway */
+ }
+ ptext("Test video attributes (sgr)");
+
+ for (i = 0; i < (int) (sizeof(alt_modes) / sizeof(struct mode_list));
+ i++) {
+ put_crlf();
+ sprintf(temp, "%d %-20s", i, alt_modes[i].name);
+ put_str(temp);
+ set_attr(alt_modes[i].number);
+ sprintf(temp, "%s", alt_modes[i].name);
+ put_str(temp);
+ set_attr(0);
+ }
+
+ putln("\n\nDouble mode test");
+ for (i = 0; i <= 9; i++) {
+ sprintf(temp, " %2d ", mode_map[i]);
+ put_str(temp);
+ }
+ for (i = 0; i <= 9; i++) {
+ put_crlf();
+ sprintf(temp, "%d", mode_map[i]);
+ put_str(temp);
+ for (j = 0; j <= 9; j++) {
+ eat_cookie();
+ set_attr((1 << mode_map[i]) | (1 << mode_map[j]));
+ put_str("Aa");
+ set_attr(0);
+ if (j < 9)
+ eat_cookie();
+ }
+ }
+ put_crlf();
+
+ if (max_attributes >= 0) {
+ sprintf(temp, "(ma) Maximum attributes %d ", max_attributes);
+ ptext(temp);
+ }
+ generic_done_message(t, state, ch);
+}
+
+/*
+** test_one_attr(mode-number, begin-string, end-string)
+**
+** Display one attribute line.
+*/
+static void
+test_one_attr(
+ int n,
+ char *begin_mode,
+ char *end_mode)
+{
+ int i;
+
+ sprintf(temp, "%-10s %s ", alt_modes[n].name, alt_modes[n].begin_mode);
+ ptext(temp);
+ for (; char_count < 19;) {
+ putchp(' ');
+ }
+ if (begin_mode) {
+ putchp('.');
+ put_mode(begin_mode);
+ put_str(alt_modes[n].name);
+ for (i = strlen(alt_modes[n].name); i < 13; i++) {
+ putchp(' ');
+ }
+ if (end_mode) {
+ put_mode(end_mode);
+ sprintf(temp, ". %s", alt_modes[n].end_mode);
+ } else {
+ set_attr(0);
+ strcpy(temp, ". (sgr)");
+ }
+ ptextln(temp);
+ } else {
+ for (i = 0; i < magic_cookie_glitch; i++)
+ putchp('*');
+ put_str("*** missing ***");
+ for (i = 0; i < magic_cookie_glitch; i++)
+ putchp('*');
+ put_crlf();
+ }
+}
+
+/*
+** charset_attributes(test_list, status, ch)
+**
+** Test SGR
+*/
+static void
+charset_attributes(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ putln("Test video attributes");
+ test_one_attr(1, enter_standout_mode, exit_standout_mode);
+ test_one_attr(2, enter_underline_mode, exit_underline_mode);
+ test_one_attr(9, enter_alt_charset_mode, exit_alt_charset_mode);
+ if (!exit_attribute_mode && !set_attributes) {
+ ptextln("(sgr0) exit attribute mode is not defined.");
+ generic_done_message(t, state, ch);
+ return;
+ }
+ test_one_attr(3, enter_reverse_mode, exit_attribute_mode);
+ test_one_attr(4, enter_blink_mode, exit_attribute_mode);
+ test_one_attr(5, enter_dim_mode, exit_attribute_mode);
+ test_one_attr(6, enter_bold_mode, exit_attribute_mode);
+ test_one_attr(7, enter_secure_mode, exit_attribute_mode);
+ test_one_attr(8, enter_protected_mode, exit_attribute_mode);
+ generic_done_message(t, state, ch);
+}
+
+#define GLYPHS 256
+
+/*
+** charset_smacs(test_list, status, ch)
+**
+** display all posible acs characters
+** (smacs) (rmacs)
+*/
+static void
+charset_smacs(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ int i, c;
+
+ if (enter_alt_charset_mode) {
+ put_clear();
+ ptextln("The following characters are available. (smacs) (rmacs)");
+ for (i = ' '; i <= '`'; i += 32) {
+ put_crlf();
+ put_mode(exit_alt_charset_mode);
+ for (c = 0; c < 32; c++) {
+ putchp(c + i);
+ }
+ put_crlf();
+ put_mode(enter_alt_charset_mode);
+ for (c = 0; c < 32; c++) {
+ putchp(c + i);
+ }
+ put_mode(exit_alt_charset_mode);
+ put_crlf();
+ }
+ put_mode(exit_alt_charset_mode);
+ put_crlf();
+ generic_done_message(t, state, ch);
+ }
+}
+
+
+static void
+test_acs(
+ int attr)
+{ /* alternate character set */
+ int i, j;
+ char valid_glyph[GLYPHS];
+ char acs_table[GLYPHS];
+ static unsigned char vt100[] = "`afgjklmnopqrstuvwxyz{|}~";
+
+ line_count = 0;
+ for (i = 0; i < GLYPHS; i++) {
+ valid_glyph[i] = FALSE;
+ acs_table[i] = i;
+ }
+ if (acs_chars) {
+ sprintf(temp, "Alternate character set map: %s",
+ expand(acs_chars));
+ putln(temp);
+ for (i = 0; acs_chars[i]; i += 2) {
+ if (acs_chars[i + 1] == 0) {
+ break;
+ }
+ for (j = 0;; j++) {
+ if (glyph[j].c == (unsigned char) acs_chars[i]) {
+ acs_table[glyph[j].c] = acs_chars[i + 1];
+ valid_glyph[glyph[j].c] = TRUE;
+ break;
+ }
+ if (glyph[j].name[0] == '\0') {
+ if (isgraph(acs_chars[i])) {
+ sprintf(temp, " %c",
+ acs_chars[i]);
+ } else {
+ sprintf(temp, " 0x%02x",
+ (acs_chars[i] & 0xff));
+ }
+ strcpy(&temp[5], " *** has no mapping ***");
+ putln(temp);
+ break;
+ }
+ }
+ }
+ } else {
+ ptextln("acs_chars not defined (acsc)");
+ /* enable the VT-100 graphics characters (default) */
+ for (i = 0; vt100[i]; i++) {
+ valid_glyph[vt100[i]] = TRUE;
+ }
+ }
+ if (attr) {
+ set_attr(attr);
+ }
+ _nc_init_acs(); /* puts 'ena_acs' and incidentally links acs_map[] */
+ for (i = 0; glyph[i].name[0]; i++) {
+ if (valid_glyph[glyph[i].c]) {
+ put_mode(enter_alt_charset_mode);
+ put_this(acs_table[glyph[i].c]);
+ char_count++;
+ put_mode(exit_alt_charset_mode);
+ if (magic_cookie_glitch >= 1) {
+ sprintf(temp, " %-30.30s", glyph[i].name);
+ put_str(temp);
+ if (char_count + 33 >= columns)
+ put_crlf();
+ } else {
+ sprintf(temp, " %-24.24s", glyph[i].name);
+ put_str(temp);
+ if (char_count + 26 >= columns)
+ put_crlf();
+ }
+ if (line_count >= lines) {
+ (void) wait_here();
+ put_clear();
+ }
+ }
+ }
+ if (char_count > 1) {
+ put_crlf();
+ }
+#ifdef ACS_ULCORNER
+ maybe_wait(5);
+ put_mode(enter_alt_charset_mode);
+ put_this(ACS_ULCORNER);
+ put_this(ACS_TTEE);
+ put_this(ACS_URCORNER);
+ put_this(ACS_ULCORNER);
+ put_this(ACS_HLINE);
+ put_this(ACS_URCORNER);
+ char_count += 6;
+ put_mode(exit_alt_charset_mode);
+ put_crlf();
+ put_mode(enter_alt_charset_mode);
+ put_this(ACS_LTEE);
+ put_this(ACS_PLUS);
+ put_this(ACS_RTEE);
+ put_this(ACS_VLINE);
+ if (magic_cookie_glitch >= 1)
+ put_this(' ');
+ else {
+ put_mode(exit_alt_charset_mode);
+ put_this(' ');
+ put_mode(enter_alt_charset_mode);
+ }
+ put_this(ACS_VLINE);
+ char_count += 6;
+ put_mode(exit_alt_charset_mode);
+ put_str(" Here are 2 boxes");
+ put_crlf();
+ put_mode(enter_alt_charset_mode);
+ put_this(ACS_LLCORNER);
+ put_this(ACS_BTEE);
+ put_this(ACS_LRCORNER);
+ put_this(ACS_LLCORNER);
+ put_this(ACS_HLINE);
+ put_this(ACS_LRCORNER);
+ char_count += 6;
+ put_mode(exit_alt_charset_mode);
+ put_crlf();
+#endif
+}
+
+/*
+** charset_bel(test_list, status, ch)
+**
+** (bel) test Bell
+*/
+static void
+charset_bel(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ if (bell) {
+ ptextln("Testing bell (bel)");
+ tc_putp(bell);
+ ptext("If you did not hear the Bell then (bel) has failed. ");
+ } else {
+ ptext("(bel) Bell is not defined. ");
+ }
+ generic_done_message(t, state, ch);
+}
+
+/*
+** charset_flash(test_list, status, ch)
+**
+** (flash) test Visual bell
+*/
+static void
+charset_flash(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ if (flash_screen) {
+ ptextln("Testing visual bell (flash)");
+ tc_putp(flash_screen);
+ ptext("If you did not see the screen flash then (flash) has failed. ");
+ } else {
+ ptext("(flash) Flash is not defined. ");
+ }
+ generic_done_message(t, state, ch);
+}
+
+/*
+** charset_civis(test_list, status, ch)
+**
+** (civis) test Cursor invisible
+*/
+static void
+charset_civis(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ if (cursor_normal) {
+ if (cursor_invisible) {
+ ptext("(civis) Turn off the cursor. ");
+ tc_putp(cursor_invisible);
+ ptext("If you can still see the cursor then (civis) has failed. ");
+ } else {
+ ptext("(civis) Cursor-invisible is not defined. ");
+ }
+ generic_done_message(t, state, ch);
+ tc_putp(cursor_normal);
+ }
+}
+
+/*
+** charset_cvvis(test_list, status, ch)
+**
+** (cvvis) test Cursor very visible
+*/
+static void
+charset_cvvis(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ if (cursor_normal) {
+ if (cursor_visible) {
+ ptext("(cvvis) Make cursor very visible. ");
+ tc_putp(cursor_visible);
+ ptext("If the cursor is not very visible then (cvvis) has failed. ");
+ } else {
+ ptext("(cvvis) Cursor-very-visible is not defined. ");
+ }
+ generic_done_message(t, state, ch);
+ tc_putp(cursor_normal);
+ }
+}
+
+/*
+** charset_cnorm(test_list, status, ch)
+**
+** (cnorm) test Cursor normal
+*/
+static void
+charset_cnorm(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ if (cursor_normal) {
+ ptext("(cnorm) Normal cursor. ");
+ tc_putp(cursor_normal);
+ ptext("If the cursor is not normal then (cnorm) has failed. ");
+ } else {
+ ptext("(cnorm) Cursor-normal is not defined. ");
+ }
+ generic_done_message(t, state, ch);
+}
+
+/*
+** charset_enacs(test_list, status, ch)
+**
+** test Alternate character set mode and alternate characters
+** (acsc) (enacs) (smacs) (rmacs)
+*/
+static void
+charset_enacs(
+ struct test_list *t,
+ int *state,
+ int *ch)
+{
+ int c, i;
+
+ if (enter_alt_charset_mode || acs_chars) {
+ c = 0;
+ while (1) {
+ put_clear();
+ /*
+ for terminals that use separate fonts for
+ attributes (such as X windows) the line
+ drawing characters must be checked for
+ each font.
+ */
+ if (c >= '0' && c <= '9') {
+ test_acs(alt_modes[c - '0'].number);
+ set_attr(0);
+ } else {
+ test_acs(0);
+ }
+
+ while (1) {
+ ptextln("[r] to repeat, [012345789] to test with attributes on, [?] for a list of attributes, anything else to go to next test. ");
+ generic_done_message(t, state, ch);
+ if (*ch != '?') {
+ break;
+ }
+ for (i = 0; i <= 9; i++) {
+ sprintf(temp, " %d %s %s", i, alt_modes[i].begin_mode,
+ alt_modes[i].name);
+ ptextln(temp);
+ }
+ }
+ if (*ch >= '0' && *ch <= '9') {
+ c = *ch;
+ } else
+ if (*ch != 'r') {
+ break;
+ }
+ }
+ } else {
+ ptext("(smacs) Enter-alt-char-set-mode and (acsc) Alternate-char-set are not defined. ");
+ generic_done_message(t, state, ch);
+ }
+}
+
+/*
+** charset_can_test()
+**
+** Initialize the can_test data base
+*/
+void
+charset_can_test(void)
+{
+ int i;
+
+ for (i = 0; i < 9; i++) {
+ can_test(alt_modes[i].begin_mode, FLAG_CAN_TEST);
+ can_test(alt_modes[i].end_mode, FLAG_CAN_TEST);
+ }
+}