#include #include #ifdef __MINGW32__ #ifdef UNIX #undef UNIX #endif /* UNIX */ #endif /* __MINGW32__ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef VMS #include #endif #if defined(VMS) && defined(__GNUC__) #include #undef LINES #undef COLS #define LINES lines #define COLS cols extern int _NOSHARE(LINES); extern int _NOSHARE(COLS); #endif /* VMS && __GNUC__ */ #ifdef USE_COLOR_STYLE #include #include #endif #ifdef NEED_WCHAR_H #include #endif #if defined(COLOR_CURSES) int lynx_has_color = FALSE; #endif #ifdef HAVE_XCURSES char *XCursesProgramName = "Lynx"; #endif #if defined(USE_COLOR_STYLE) && !defined(USE_COLOR_TABLE) #define COLOR_BKGD ((s_normal != NOSTYLE) ? hashStyles[s_normal].color : A_NORMAL) #else #define COLOR_BKGD ((COLOR_PAIRS >= 9) ? (chtype) get_color_pair(9) : A_NORMAL) #endif #ifdef USE_CURSES_PADS WINDOW *LYwin = 0; int LYshiftWin = 0; int LYwideLines = FALSE; int LYtableCols = 0; /* in 1/12 of screen width */ BOOL LYuseCursesPads = TRUE; /* use pads for left/right shifting */ #endif /* * These are routines to start and stop curses and to cleanup the screen at the * end. */ static int dumbterm(char *terminal); BOOLEAN LYCursesON = FALSE; #if defined(USE_BLINK) && defined(__EMX__) static void make_blink_boldbg(void); #endif #if defined(USE_COLOR_TABLE) || defined(USE_SLANG) int Current_Attr; static int Masked_Attr; #endif #ifdef USE_SLANG unsigned Lynx_Color_Flags = 0; BOOLEAN FullRefresh = FALSE; int curscr = 0; #ifdef SLANG_MBCS_HACK /* * Will be set by size_change. - KW */ int PHYSICAL_SLtt_Screen_Cols = 10; #endif /* SLANG_MBCS_HACK */ void LY_SLrefresh(void) { if (FullRefresh) { SLsmg_suspend_smg(); SLsmg_resume_smg(); FullRefresh = FALSE; } else { SLsmg_refresh(); } return; } /* the following renamed from LY_SLclear since it is more like erase() described in curses man pages than like clear(); but for USE_SLANG clear() is still a macro calling this, and will do the same thing as erase(). - kw */ void LY_SLerase(void) { SLsmg_gotorc(0, 0); SLsmg_erase_eos(); } #ifdef VMS void VTHome(void) { printf("\033[;H"); return; } #endif /* VMS */ void LYaddAttr(int a) { Current_Attr |= a; SLsmg_set_color(Current_Attr & ~Masked_Attr); } void LYsubAttr(int a) { Current_Attr &= ~a; SLsmg_set_color(Current_Attr & ~Masked_Attr); } static void lynx_setup_attrs(void) { static int monoattr[] = { 0, SLTT_BOLD_MASK, SLTT_REV_MASK, SLTT_REV_MASK | SLTT_BOLD_MASK, SLTT_ULINE_MASK, SLTT_ULINE_MASK | SLTT_BOLD_MASK, SLTT_ULINE_MASK | SLTT_REV_MASK, SLTT_ULINE_MASK | SLTT_BOLD_MASK | SLTT_REV_MASK }; int n; for (n = 1; n <= 7; n++) SLtt_set_mono(n, NULL, (monoattr[n] & ~Masked_Attr)); } void lynx_setup_colors(void) { CTRACE((tfp, "lynx_setup_colors\n")); SLtt_set_color(0, NULL, DEFAULT_FG, DEFAULT_BG); SLtt_set_color(1, NULL, "blue", DEFAULT_BG); /* bold */ SLtt_set_color(2, NULL, "yellow", "blue"); /* reverse */ SLtt_set_color(4, NULL, "magenta", DEFAULT_BG); /* underline */ /* * The other objects are '|'ed together to get rest. */ SLtt_set_color(3, NULL, "green", DEFAULT_BG); /* bold-reverse */ SLtt_set_color(5, NULL, "blue", DEFAULT_BG); /* bold-underline */ SLtt_set_color(6, NULL, "red", DEFAULT_BG); /* reverse-underline */ SLtt_set_color(7, NULL, "magenta", "cyan"); /* reverse-underline-bold */ /* * Now set monochrome attributes. */ lynx_setup_attrs(); } static void sl_suspend(int sig) { #ifdef SIGSTOP #ifndef VMS int r, c; lynx_enable_mouse(0); if (sig == SIGTSTP) SLsmg_suspend_smg(); SLang_reset_tty(); kill(getpid(), SIGSTOP); #if SLANG_VERSION > 9929 SLang_init_tty(-1, 0, 1); #else SLang_init_tty(3, 0, 1); #endif /* SLANG_VERSION > 9929 */ signal(SIGTSTP, sl_suspend); #if defined(REAL_UNIX_SYSTEM) && !defined(__CYGWIN__) SLtty_set_suspend_state(1); #endif if (sig == SIGTSTP) SLsmg_resume_smg(); /* * Get new window size in case it changed. */ r = SLtt_Screen_Rows; c = SLtt_Screen_Cols; size_change(0); if ((r != SLtt_Screen_Rows) || (c != SLtt_Screen_Cols)) { recent_sizechange = TRUE; } lynx_enable_mouse(1); #endif /* !VMS */ #endif /* SIGSTOP */ return; } #else #ifdef FANCY_CURSES #ifndef VMS /* *INDENT-OFF* */ /* definitions for the mono attributes we can use */ static struct { const char *name; int code; } Mono_Attrs[7] = { { "normal", A_NORMAL }, { "bold", A_BOLD }, { "reverse", A_REVERSE }, { "underline", A_UNDERLINE }, { "standout", A_STANDOUT }, { "blink", A_BLINK }, { "dim", A_DIM }, }; /* *INDENT-ON* */ int string_to_attr(char *name) { unsigned i; for (i = 0; i < TABLESIZE(Mono_Attrs); i++) { if (!strcasecomp(Mono_Attrs[i].name, name)) { return Mono_Attrs[i].code; } } return 0; } #endif /* VMS */ #ifdef USE_COLOR_STYLE static char *attr_to_string(int code) { static char result[sizeof(Mono_Attrs) + 80]; unsigned i; int pair = PAIR_NUMBER(code); int bold = (pair != 0 && (code & A_BOLD) != 0); if (bold) code &= ~A_BOLD; *result = 0; for (i = 0; i < TABLESIZE(Mono_Attrs); i++) { if (Mono_Attrs[i].code & code) { if (*result) strcat(result, "+"); strcat(result, Mono_Attrs[i].name); } } if (pair != 0) { short f, b; if (pair_content((short) pair, &f, &b) != ERR) { const char *fg = lookup_color(bold ? f + COLORS : f); const char *bg = lookup_color(b); if (*result) strcat(result, "+"); sprintf(result + strlen(result), "%s/%s", fg, bg); } } return result; } #endif /* USE_COLOR_STYLE */ #endif /* FANCY_CURSES */ #endif /* USE_SLANG */ /* * This function boxes windows for (n)curses. */ void LYbox(WINDOW * win, BOOLEAN formfield GCC_UNUSED) { #ifdef USE_SLANG SLsmg_draw_box(win->top_y, win->left_x, win->height, win->width + 4); #else #ifdef VMS /* * This should work for VAX-C and DEC-C, since they both have the same * win._max_y and win._max_x members -TD * * (originally VMSbox by FM) */ int i; wmove(win, 0, 0); waddstr(win, "\033)0\016l"); for (i = 1; i < win->_max_x; i++) waddch(win, 'q'); waddch(win, 'k'); for (i = 1; i < win->_max_y - 1; i++) { wmove(win, i, 0); waddch(win, 'x'); wmove(win, i, win->_max_x - 1); waddch(win, 'x'); } wmove(win, i, 0); waddch(win, 'm'); for (i = 1; i < win->_max_x; i++) waddch(win, 'q'); waddstr(win, "j\017"); #else /* !VMS */ int boxvert, boxhori; UCSetBoxChars(current_char_set, &boxvert, &boxhori, BOXVERT, BOXHORI); #ifdef CSS if (formfield) wcurses_css(win, "frame", ABS_ON); #endif /* * If we don't have explicitly specified characters for either vertical or * horizontal lines, the characters that box() would use for the corners * probably also won't work well. So we specify our own ASCII characters * for the corners and call wborder() instead of box(). - kw */ LynxWChangeStyle(win, s_menu_frame, STACK_ON); #ifdef HAVE_WBORDER if (!boxvert || !boxhori) box(win, boxvert, boxhori); else if (boxvert == '*' || boxhori == '*') wborder(win, boxvert, boxvert, boxhori, boxhori, '*', '*', '*', '*'); else wborder(win, boxvert, boxvert, boxhori, boxhori, '/', '\\', '\\', '/'); #else box(win, boxvert, boxhori); #endif LynxWChangeStyle(win, s_menu_frame, STACK_OFF); #ifdef CSS if (formfield) wcurses_css(win, "frame", ABS_OFF); #endif #endif /* VMS */ wrefresh(win); #endif /* USE_SLANG */ } #if defined(USE_COLOR_STYLE) /* Ok, explanation of the USE_COLOR_STYLE styles. The basic styles (ie non * HTML) are set the same as the SLANG version for ease of programming. The * other styles are simply the HTML enum from HTMLDTD.h + 16. */ HTCharStyle displayStyles[DSTYLE_ELEMENTS]; /* * set a style's attributes - RP */ void setStyle(int style, int color, int cattr, int mono) { displayStyles[style].color = color; displayStyles[style].cattr = cattr; displayStyles[style].mono = mono; } void setHashStyle(int style, int color, int cattr, int mono, char *element) { bucket *ds = &hashStyles[style]; CTRACE2(TRACE_STYLE, (tfp, "CSS(SET): <%s> hash=%d, ca=%#x, ma=%#x\n", element, style, color, mono)); ds->color = color; ds->cattr = cattr; ds->mono = mono; ds->code = style; FREE(ds->name); StrAllocCopy(ds->name, element); } /* * set the curses attributes to be color or mono - RP */ static void LYAttrset(WINDOW * win, int color, int mono) { if (lynx_has_color && LYShowColor >= SHOW_COLOR_ON && color >= 0) { CTRACE2(TRACE_STYLE, (tfp, "CSS:LYAttrset color %#x -> (%s)\n", color, attr_to_string(color))); wattrset(win, color); } else if (mono >= 0) { CTRACE2(TRACE_STYLE, (tfp, "CSS:LYAttrset mono %#x -> (%s)\n", mono, attr_to_string(mono))); wattrset(win, mono); } else { CTRACE2(TRACE_STYLE, (tfp, "CSS:LYAttrset (A_NORMAL)\n")); wattrset(win, A_NORMAL); } } void curses_w_style(WINDOW * win, int style, int dir) { #if OMIT_SCN_KEEPING # define SPECIAL_STYLE /*(CSHASHSIZE+1) */ 88888 /* if TRACEs are not compiled in, this macro is redundant - we needn't valid 'ds' to stack off. */ #endif int YP, XP; #if !OMIT_SCN_KEEPING bucket *ds = (style == NOSTYLE ? &nostyle_bucket : &hashStyles[style]); #else bucket *ds = (style == NOSTYLE ? &nostyle_bucket : (style == SPECIAL_STYLE ? &special_bucket : &hashStyles[style])); #endif if (!ds->name) { CTRACE2(TRACE_STYLE, (tfp, "CSS.CS:Style %d not configured\n", style)); #if !OMIT_SCN_KEEPING return; #endif } CTRACE2(TRACE_STYLE, (tfp, "CSS.CS:<%s%s> style %d code %#x, color %#x\n", (dir ? "" : "/"), ds->name, style, ds->code, ds->color)); getyx(win, YP, XP); if (style == s_normal && dir) { LYAttrset(win, ds->color, ds->mono); if (win == LYwin && CACHE_VALIDATE_YX(YP, XP)) cached_styles[YP][XP] = s_normal; return; } switch (dir) { /* ABS_OFF is the same as STACK_OFF for the moment */ case STACK_OFF: if (last_colorattr_ptr) { int last_attr = last_styles[--last_colorattr_ptr]; LYAttrset(win, last_attr, last_attr); } else LYAttrset(win, A_NORMAL, -1); break; case STACK_ON: /* remember the current attributes */ if (last_colorattr_ptr >= MAX_LAST_STYLES) { CTRACE2(TRACE_STYLE, (tfp, "........... %s (0x%x) %s\r\n", "attribute cache FULL, dropping last", last_styles[last_colorattr_ptr], "in LynxChangeStyle(curses_w_style)")); last_colorattr_ptr = MAX_LAST_STYLES - 1; } last_styles[last_colorattr_ptr++] = LYgetattrs(win); /* don't cache style changes for active links */ #if OMIT_SCN_KEEPING /* since we don't compute the hcode to stack off in HTML.c, we * don't know whether this style is configured. So, we * shouldn't simply return on stacking on unconfigured * styles, we should push curr attrs on stack. -HV */ if (!ds->name) break; #endif /* FALL THROUGH */ case ABS_ON: /* change without remembering the previous style */ /* don't cache style changes for active links and edits */ if (style != s_alink && style != s_curedit && style != s_aedit && style != s_aedit_sel && style != s_aedit_pad && style != s_aedit_arr) { CTRACE2(TRACE_STYLE, (tfp, "CACHED: <%s> @(%d,%d)\n", ds->name, YP, XP)); if (win == LYwin && CACHE_VALIDATE_YX(YP, XP)) cached_styles[YP][XP] = style; } LYAttrset(win, ds->color, ds->mono); break; } } /* * wrapper function to set on-screen styles - RP */ void wcurses_css(WINDOW * win, char *name, int dir) { int try_again = 1; while (try_again) { int tmpHash = hash_code(name); CTRACE2(TRACE_STYLE, (tfp, "CSSTRIM:trying to set [%s] style - ", name)); if (tmpHash == NOSTYLE) { char *pclass = strrchr(name, '.'); CTRACE2(TRACE_STYLE, (tfp, "undefined, trimming at %p\n", pclass)); if (pclass) *pclass = '\0'; else try_again = 0; } else { CTRACE2(TRACE_STYLE, (tfp, "ok (%d)\n", hash_code(name))); curses_w_style(win, hash_code(name), dir); try_again = 0; } } } void curses_css(char *name, int dir) { wcurses_css(LYwin, name, dir); } void curses_style(int style, int dir) { curses_w_style(LYwin, style, dir); } #endif /* USE_COLOR_STYLE */ static BOOL lynx_called_initscr = FALSE; #if defined(USE_COLOR_TABLE) && defined(COLOR_CURSES) #define COLOR_CFG_MAX 8 /* * This block of code is designed to produce the same color effects using SVr4 * curses as the slang library's implementation in this module. That maps the * SGR codes into a 0-7 index into the color table, with special treatment for * backgrounds. There's a bit of convoluted (but necessary) code handling the * special case of initialization before 'initscr()' is called. * 1997/1/19 - T.E.Dickey */ /* *INDENT-OFF* */ #define COLOR_CFG(c) c, (c) == DEFAULT_COLOR static struct { int fg, dft_fg, bg, dft_bg; } lynx_color_cfg[] = { /*0*/ { COLOR_CFG(DEFAULT_FG), COLOR_CFG(DEFAULT_BG)}, /*1*/ { COLOR_CFG(COLOR_BLUE), COLOR_CFG(DEFAULT_BG)}, /*2*/ { COLOR_CFG(COLOR_YELLOW+8), COLOR_CFG(COLOR_BLUE)}, /*3*/ { COLOR_CFG(COLOR_GREEN), COLOR_CFG(DEFAULT_BG)}, /*4*/ { COLOR_CFG(COLOR_MAGENTA), COLOR_CFG(DEFAULT_BG)}, /*5*/ { COLOR_CFG(COLOR_BLUE), COLOR_CFG(DEFAULT_BG)}, /*6*/ { COLOR_CFG(COLOR_RED), COLOR_CFG(DEFAULT_BG)}, /*7*/ { COLOR_CFG(COLOR_MAGENTA), COLOR_CFG(COLOR_CYAN)} }; /* *INDENT-ON* */ #define COLOR_PAIRS_MAX (COLOR_CFG_MAX * 3 + 1) /* * Hold the codes for color-pairs here until 'initscr()' is called. */ static struct { int fg; int bg; } lynx_color_pairs[COLOR_PAIRS_MAX]; /* * If we find an exact match for the given default colors, force curses to use * color pair 0, which corresponds to the terminal's default colors. Normally * curses assumes white-on-black, but we can override the assumption with this * function. */ static int get_color_pair(int n) { #ifdef USE_CURSES_PAIR_0 if ((n < (int) TABLESIZE(lynx_color_pairs)) && lynx_color_pairs[n].fg == default_fg && lynx_color_pairs[n].bg == default_bg) return 0; #endif return COLOR_PAIR(n); } /* * Lynx "knows" about 16 colors. ANSI colors (and most color terminal * emulators) only go to 8, though some curses implementations (ncurses and * PDCurses) handle 16. If lynx's configuration calls for a color past the * number of colors that the terminal handles (COLORS), map the extra value * to bold. */ #define is_boldc(c) ((c) > (COLORS-1)) #define map2bold(c) (is_boldc(c) ? ((c) & (COLORS-1)) : (c)) /* * Return the extra color as A_BOLD. * If there is no extra color, return A_NORMAL. */ static int lynx_color_cfg_attr(int code) { int result = A_NORMAL; if (code >= 0 && code < COLOR_CFG_MAX) { int fg = lynx_color_cfg[code].fg; if (is_boldc(fg) && (fg & COLORS)) result = A_BOLD; } return result; } static int encode_color_attr(int color_attr) { int result; int code = 0; int offs = 1; if (color_attr & A_BOLD) code |= 1; if (color_attr & (A_REVERSE | A_DIM)) code |= 2; if (color_attr & A_UNDERLINE) code |= 4; result = lynx_color_cfg_attr(code); if (code + offs < COLOR_PAIRS) { result |= get_color_pair(code + offs); } return result; } static int decode_mono_code(int mono_code) { int result = 0; if (mono_code & 1) result |= A_BOLD; if (mono_code & 2) result |= A_REVERSE; if (mono_code & 4) result |= A_UNDERLINE; return result; } /* * Map the SGR attributes (0-7) into ANSI colors, modified with the actual BOLD * attribute to get 16 colors. */ int LYgetTableAttr(void) { int result; if (lynx_has_color && LYShowColor >= SHOW_COLOR_ON) { result = encode_color_attr(Current_Attr); } else { result = Current_Attr; } return result & ~Masked_Attr; } #ifdef USE_COLOR_STYLE /* * Return a string that corresponds to the attributes that would be returned by * LYgetTableAttr(). */ char *LYgetTableString(int code) { int mask = decode_mono_code(code); int second = encode_color_attr(mask); int pair = PAIR_NUMBER(second); int mono = mask & A_ATTRIBUTES; int fg = lynx_color_pairs[pair].fg; int bg = lynx_color_pairs[pair].bg; unsigned n; char *result = 0; CTRACE((tfp, "LYgetTableString(%d)\n", code)); if (fg == 0 && bg == 0) { fg = COLOR_WHITE; } CTRACE((tfp, "%#x -> %#x (mono %#x pair %d) fg=%d, bg=%d\n", mask, second, mono, pair, fg, bg)); for (n = 0; n < TABLESIZE(Mono_Attrs); ++n) { if ((Mono_Attrs[n].code & mono) != 0) { if (result != 0) StrAllocCat(result, "+"); StrAllocCat(result, Mono_Attrs[n].name); } } if (result == 0) StrAllocCopy(result, "normal"); StrAllocCat(result, ":"); StrAllocCat(result, lookup_color(fg)); if (bg >= 0) { StrAllocCat(result, ":"); StrAllocCat(result, lookup_color(bg)); } CTRACE((tfp, "->%s\n", result)); return result; } #endif /* * Initialize a curses color-pair based on our configured color values. */ static void lynx_init_color_pair(int n) { #ifdef USE_COLOR_STYLE (void) n; /* we only use lynx_color_pairs[] data */ #else int m; if (lynx_called_initscr) { for (m = 0; m <= 16; m += 8) { int pair = n + m + 1; if (pair < COLOR_PAIRS) init_pair((short) pair, (short) map2bold(lynx_color_pairs[pair].fg), (short) map2bold(lynx_color_pairs[pair].bg)); } if (n == 0 && LYShowColor >= SHOW_COLOR_ON) { wbkgd(LYwin, COLOR_BKGD | ' '); } } #endif } static void lynx_map_color(int n) { int j; CTRACE((tfp, "lynx_map_color(%d)\n", n)); if (n + 1 < (int) TABLESIZE(lynx_color_pairs)) { for (j = n + 1; j < COLOR_PAIRS_MAX; j += COLOR_CFG_MAX) { lynx_color_pairs[j].fg = lynx_color_cfg[n].fg; lynx_color_pairs[j].bg = lynx_color_cfg[n].bg; } /* special case (does not apply to 3rd set) */ lynx_color_pairs[n + 1 + COLOR_CFG_MAX].bg = lynx_color_cfg[0].bg; } lynx_init_color_pair(n); } /* * Change a configured color value. This may be called before initscr(), so * we may not be able to call init_pair() to finish the change. */ int lynx_chg_color(int color, int fg, int bg) { CTRACE((tfp, "lynx_chg_color(color=%d, fg=%d, bg=%d)\n", color, fg, bg)); if (fg == ERR_COLOR || bg == ERR_COLOR) return -1; if (color >= 0 && color < COLOR_CFG_MAX) { lynx_color_cfg[color].fg = fg; lynx_color_cfg[color].bg = bg; lynx_map_color(color); } else { return -1; } return 0; } void lynx_set_color(int a) { if (lynx_has_color && LYShowColor >= SHOW_COLOR_ON) { wattrset(LYwin, lynx_color_cfg_attr(a) | (((a + 1) < COLOR_PAIRS) ? (chtype) get_color_pair(a + 1) : A_NORMAL)); } } void lynx_standout(int flag) { if (flag) LYaddAttr(A_REVERSE); else LYsubAttr(A_REVERSE); } static void lynx_init_colors(void) { if (lynx_has_color) { size_t n; CTRACE((tfp, "lynx_init_colors (default %d/%d)\n", default_fg, default_bg)); lynx_color_cfg[0].fg = default_fg; lynx_color_cfg[0].bg = default_bg; for (n = 0; n < TABLESIZE(lynx_color_cfg); n++) { lynx_init_color_pair(n); } } else if (LYShowColor != SHOW_COLOR_NEVER) { LYShowColor = SHOW_COLOR_OFF; } } void lynx_setup_colors(void) { int n; CTRACE((tfp, "lynx_setup_colors\n")); #ifdef USE_DEFAULT_COLORS if (!LYuse_default_colors) { for (n = 0; n < COLOR_CFG_MAX; n++) { if (lynx_color_cfg[n].dft_fg) lynx_color_cfg[n].fg = COLOR_BLACK; if (lynx_color_cfg[n].dft_bg) lynx_color_cfg[n].bg = COLOR_WHITE; } } #endif for (n = 0; n < COLOR_CFG_MAX; n++) lynx_map_color(n); } #endif /* USE_COLOR_TABLE */ void LYnoVideo(int a) { CTRACE((tfp, "LYnoVideo(%d)\n", a)); #ifdef USE_SLANG if (a & 1) Masked_Attr |= SLTT_BOLD_MASK; if (a & 2) Masked_Attr |= SLTT_REV_MASK; if (a & 4) Masked_Attr |= SLTT_ULINE_MASK; lynx_setup_attrs(); #else #ifdef USE_COLOR_TABLE Masked_Attr = decode_mono_code(a); #endif #endif } #define NEWTERM_NAME "newterm" #if !defined(VMS) && !defined(USE_SLANG) /* * If newterm is not defined, assume a curses subset which * supports only initscr. --gil */ #if defined(HAVE_NEWTERM) && defined(HAVE_DELSCREEN) && !defined(PDCURSES) && !(defined(NCURSES) && defined(HAVE_RESIZETERM)) static SCREEN *LYscreen = NULL; #define LYDELSCR() { \ if (recent_sizechange) { \ CTRACE((tfp, "Screen size: delscreen()\n")); \ delscreen(LYscreen); \ LYscreen = NULL; } } /* * Surrogates for newterm and delscreen */ #else /* HAVE_NEWTERM */ static WINDOW *LYscreen = NULL; #undef NEWTERM_NAME #define NEWTERM_NAME "initscr" #undef newterm #define newterm(type, out, in) (initscr()) #define LYDELSCR() /* nothing */ #endif /* HAVE_NEWTERM */ #else /* !defined(VMS) && !defined(USE_SLANG) */ /* * Provide last recourse definitions of LYscreen and LYDELSCR for * stop_curses, which only tests LYscreen for zero/nonzero but * never uses it as a pointer or L-value. */ #define LYscreen TRUE #define LYDELSCR() /* nothing */ #endif /* !defined(VMS) && !defined(USE_SLANG) */ #if defined(PDCURSES) && defined(PDC_BUILD) && PDC_BUILD >= 2401 int saved_scrsize_x = 0; int saved_scrsize_y = 0; #endif void start_curses(void) { #ifdef USE_SLANG static int slinit; if (LYCursesON) { CTRACE((tfp, "start_curses: Hmm, already ON.\n")); return; } if (slinit == 0) { #if defined(HAVE_TTYNAME) if (isatty(fileno(stdout)) && LYReopenInput() < 0) { fprintf(stderr, "Cannot open tty input\n"); exit_immediately(EXIT_FAILURE); } #endif #if defined(USE_KEYMAPS) if (-1 == lynx_initialize_keymaps()) exit_immediately(EXIT_FAILURE); #else SLtt_get_terminfo(); #endif #if (defined(__DJGPP__) && !defined(DJGPP_KEYHANDLER)) || defined(__CYGWIN__) SLkp_init(); #endif /* __DJGPP__ && !DJGPP_KEYHANDLER */ #if defined(REAL_UNIX_SYSTEM) && !defined(__CYGWIN__) #if SLANG_VERSION >= 9935 SLang_TT_Read_FD = fileno(stdin); #endif /* SLANG_VERSION >= 9935 */ #endif /* REAL_UNIX_SYSTEM && !__CYGWIN__ */ #if !defined(USE_KEYMAPS) && defined(ENHANCED_LINEEDIT) && defined(ESCDELAY) /* way to get ESC that's not part of a recognized sequence through */ ESCDELAY = 2000; #endif /* * Check whether a saved show_color:off override is in effect. - kw */ if (LYrcShowColor == SHOW_COLOR_NEVER) { SLtt_Use_Ansi_Colors = 0; } /* * Check whether we're forcing color on. - FM */ if ((LYShowColor > 1) && (Lynx_Color_Flags & SL_LYNX_USE_COLOR)) SLtt_Use_Ansi_Colors = 1; /* * Check whether a -nocolor override is in effect. - kw */ if (Lynx_Color_Flags & SL_LYNX_OVERRIDE_COLOR) SLtt_Use_Ansi_Colors = 0; /* * Make sure our flags are in register. - FM */ if (SLtt_Use_Ansi_Colors == 1) { if (LYShowColor != SHOW_COLOR_ALWAYS) { LYShowColor = SHOW_COLOR_ON; } } else { if (LYShowColor != SHOW_COLOR_NEVER) { LYShowColor = SHOW_COLOR_OFF; } } size_change(0); #if (defined(VMS) || defined(REAL_UNIX_SYSTEM)) && !defined(__CYGWIN__) if ((Masked_Attr & SLTT_ULINE_MASK) == 0) { SLtt_add_color_attribute(4, SLTT_ULINE_MASK); SLtt_add_color_attribute(5, SLTT_ULINE_MASK); } /* * If set, the blink escape sequence will turn on high intensity * background (rxvt and maybe Linux console). */ SLtt_Blink_Mode = term_blink_is_boldbg; #endif /* (VMS || REAL_UNIX_SYSTEM) && !__CYGWIN__ */ } #ifdef __DJGPP__ _eth_init(); #endif /* __DJGPP__ */ slinit = 1; Current_Attr = 0; #ifndef VMS #if SLANG_VERSION > 9929 SLang_init_tty(-1, 0, 1); #else SLang_init_tty(3, 0, 1); #endif /* SLANG_VERSION > 9929 */ #endif /* !VMS */ SLsmg_init_smg(); SLsmg_Display_Eight_Bit = LYlowest_eightbit[current_char_set]; if (SLsmg_Display_Eight_Bit > 191) SLsmg_Display_Eight_Bit = 191; /* may print ctrl chars otherwise - kw */ scrollok(0, 0); SLsmg_Backspace_Moves = 1; #if SLANG_VERSION > 10306 SLsmg_touch_screen(); #endif #ifndef VMS #if defined(REAL_UNIX_SYSTEM) && !defined(__CYGWIN__) SLtty_set_suspend_state(1); #endif /* REAL_UNIX_SYSTEM && !__CYGWIN__ */ #ifdef SIGTSTP if (!no_suspend) signal(SIGTSTP, sl_suspend); #endif /* SIGTSTP */ signal(SIGINT, cleanup_sig); #endif /* !VMS */ lynx_enable_mouse(1); #else /* USE_SLANG; Now using curses: */ int keypad_on = 0; #ifdef VMS /* * If we are VMS then do initscr() everytime start_curses() is called! */ CTRACE((tfp, "Screen size: initscr()\n")); initscr(); /* start curses */ #else /* Unix: */ #if defined(HAVE_TTYNAME) if (isatty(fileno(stdout)) && LYReopenInput() < 0) { fprintf(stderr, "Cannot open tty input\n"); exit_immediately(EXIT_FAILURE); } #endif #ifdef __CYGWIN__ /* * Workaround for buggy Cygwin, which breaks subprocesses of a * full-screen application (tested with cygwin dll, dated * 2002/6/23 -TD) */ if (!lynx_called_initscr) { FILE *fp = fopen("/dev/tty", "w"); if (fp != 0) stdout = fp; } #endif if (!LYscreen) { /* * If we're not VMS then only do initscr() one time, and one time only! */ #if defined(HAVE_NEWTERM) #if !(defined(NCURSES) && !defined(HAVE_RESIZETERM)) BOOLEAN savesize; savesize = recent_sizechange; size_change(0); recent_sizechange = savesize; /* avoid extra redraw */ #if defined(__MVS__) { /* * The requirement to do this may be a bug in OS/390. * * Put screen geometry in environment variables used by * XOpen curses before calling newterm(). I believe this * completes work left unfinished by AJL & FM -- gil */ static char lines_putenv[] = "LINES=abcde", cols_putenv[] = "COLUMNS=abcde"; sprintf(lines_putenv + 6, "%d", LYlines & 0xfff); sprintf(cols_putenv + 8, "%d", LYcols & 0xfff); putenv(lines_putenv); putenv(cols_putenv); CTRACE((tfp, "start_curses putenv %s, %s\n", lines_putenv, cols_putenv)); } #endif /* defined(__MVS__) */ #endif /* !(defined(NCURSES) && defined(HAVE_RESIZETERM)) */ CTRACE((tfp, "Screen size: %s()\n", NEWTERM_NAME)); if (!(LYscreen = newterm(NULL, stdout, stdin))) { /* start curses */ fprintf(tfp, "%s\n", gettext("Terminal initialisation failed - unknown terminal type?")); exit_immediately(EXIT_FAILURE); } #else CTRACE((tfp, "Screen size: initscr()\n")); initscr(); #endif /* HAVE_NEWTERM */ lynx_called_initscr = TRUE; LYlines = LYscreenHeight(); LYcols = LYscreenWidth(); #if defined(SIGWINCH) && defined(NCURSES_VERSION) size_change(0); recent_sizechange = FALSE; /* prevent mainloop drawing 1st doc twice */ #endif /* SIGWINCH */ CTRACE((tfp, "Screen size is now %d x %d\n", LYlines, LYcols)); #ifdef USE_CURSES_PADS if (LYuseCursesPads) { LYwin = newpad(LYlines, MAX_COLS); LYshiftWin = 0; LYwideLines = FALSE; } else { LYwin = stdscr; } #endif #if defined(USE_KEYMAPS) && defined(NCURSES_VERSION) # if HAVE_KEYPAD /* Need to switch keypad on before initializing keymaps, otherwise when the keypad is switched on, some keybindings may be overriden. */ keypad(LYwin, TRUE); keypad_on = 1; # endif /* HAVE_KEYPAD */ if (-1 == lynx_initialize_keymaps()) { endwin(); exit_immediately(EXIT_FAILURE); } #endif /* * This is a workaround for a bug in SVr4 curses, observed on Solaris * 2.4: if your terminal's alternate-character set contains codes in * the range 128-255, they'll be sign-extended in the acs_map[] table, * which in turn causes their values to be emitted as 255 (0xff). * "Fix" this by forcing the table to 8-bit codes (it has to be * anyway). */ #if defined(ALT_CHAR_SET) && !defined(NCURSES_VERSION) { int n; for (n = 0; n < 128; n++) if (ALT_CHAR_SET[n] & 0x80) { ALT_CHAR_SET[n] &= 0xff; ALT_CHAR_SET[n] |= A_ALTCHARSET; } } #endif #if defined(USE_COLOR_STYLE) || defined(USE_COLOR_TABLE) if (has_colors()) { lynx_has_color = TRUE; start_color(); #ifndef COLORS /* map2boldc() relies on COLORS being a power of 2 */ if (COLORS > 16) COLORS = 16; if (COLORS < 8) COLORS = 2; if (COLORS > 8 && COLORS != 16) COLORS = 8; #endif #ifdef USE_DEFAULT_COLORS if (LYuse_default_colors) { #if defined(EXP_ASSUMED_COLOR) && defined(USE_COLOR_TABLE) /* * Adjust the color mapping table to match the ASSUMED_COLOR * setting in lynx.cfg */ if (assume_default_colors(default_fg, default_bg) != OK) { default_fg = COLOR_WHITE; default_bg = COLOR_BLACK; } CTRACE((tfp, "initializing default colors %d/%d\n", default_fg, default_bg)); if (default_fg >= 0 || default_bg >= 0) { unsigned n; for (n = 0; n < TABLESIZE(lynx_color_cfg); n++) { if (default_fg >= 0 && lynx_color_cfg[n].fg < 0) lynx_color_cfg[n].fg = default_fg; if (default_bg >= 0 && lynx_color_cfg[n].bg < 0) lynx_color_cfg[n].bg = default_bg; CTRACE((tfp, "color_cfg[%u] = %d/%d\n", n, lynx_color_cfg[n].fg, lynx_color_cfg[n].bg)); } lynx_setup_colors(); } #else #if defined(HAVE_USE_DEFAULT_COLORS) if (!default_color_reset) { if (lynx_called_initscr) { if (LYuse_default_colors && (use_default_colors() == OK)) { default_fg = DEFAULT_COLOR; default_bg = DEFAULT_COLOR; } else { default_fg = COLOR_WHITE; default_bg = COLOR_BLACK; default_color_reset = TRUE; } } } #endif /* HAVE_USE_DEFAULT_COLORS */ #endif /* EXP_ASSUMED_COLOR */ } #endif /* USE_DEFAULT_COLORS */ } #endif /* USE_COLOR_STYLE || USE_COLOR_TABLE */ #ifdef USE_COLOR_STYLE /* Curses forgets color settings when we call delscreen() */ if (!isEmpty(lynx_lss_file) && LYCanReadFile(lynx_lss_file)) { style_readFromFile(lynx_lss_file); } parse_userstyles(); #endif #ifdef USE_COLOR_TABLE lynx_init_colors(); #endif } #ifdef __DJGPP__ _eth_init(); #endif /* __DJGPP__ */ #endif /* not VMS */ /* nonl(); *//* seems to slow things down */ #ifdef VMS crmode(); raw(); #else #ifdef HAVE_CBREAK cbreak(); #else crmode(); #endif /* HAVE_CBREAK */ signal(SIGINT, cleanup_sig); #endif /* VMS */ noecho(); #ifdef HAVE_KEYPAD if (!keypad_on) keypad(LYwin, TRUE); #endif /* HAVE_KEYPAD */ lynx_enable_mouse(1); fflush(stdin); fflush(stdout); fflush(stderr); #endif /* USE_SLANG */ #if defined(WIN_EX) LYclear(); #endif #if defined(USE_BLINK) && defined(__EMX__) if (term_blink_is_boldbg) /* Now actually make it so! */ make_blink_boldbg(); #endif LYCursesON = TRUE; #if defined(PDCURSES) && defined(PDC_BUILD) && PDC_BUILD >= 2401 if ((scrsize_x != 0) && (scrsize_y != 0)) { if (saved_scrsize_x == 0) { saved_scrsize_x = COLS; saved_scrsize_y = LINES; } CTRACE((tfp, "resize_term: x=%d, y=%d\n", scrsize_x, scrsize_y)); CTRACE((tfp, "saved terminal size: x=%d, y=%d\n", saved_scrsize_x, saved_scrsize_y)); resize_term(scrsize_y, scrsize_x); LYclear(); } #endif CTRACE((tfp, "start_curses: done.\n")); } /* end of start_curses() */ void lynx_enable_mouse(int state) { #ifdef USE_MOUSE /***********************************************************************/ #if defined(WIN_EX) /* modify lynx_enable_mouse() for pdcurses configuration so that mouse support is disabled unless -use_mouse is specified */ HANDLE hConIn = INVALID_HANDLE_VALUE; hConIn = GetStdHandle(STD_INPUT_HANDLE); if (LYUseMouse == 0) { SetConsoleMode(hConIn, ENABLE_WINDOW_INPUT); FlushConsoleInputBuffer(hConIn); return; } #endif (void) state; if (LYUseMouse == 0) return; #if defined(USE_SLANG) SLtt_set_mouse_mode(state, 0); SLtt_flush_output(); #else #if defined(WIN_EX) && defined(PDCURSES) if (state) { SetConsoleMode(hConIn, ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT); FlushConsoleInputBuffer(hConIn); } #else #if defined(NCURSES) if (state) { /* Compensate for small value of maxclick in ncurses. */ static int was = 0; if (!was) { int old = mouseinterval(-1); was++; if (old < 200) /* Default 166 */ mouseinterval(300); } /* Inform ncurses which mouse events we're interested in. * We shouldn't need to include BUTTONn_PRESSED and BUTTONn_RELEASED * events, since ncurses should translate them to click events. - kw * However, if we do not include them, then ncurses effectively * ignores mouseinterval(), thus translates *any* sequence of * press/release to a click, which leads to inconveniences. * We special-case these events in LYStrings.c. */ mousemask(BUTTON_CTRL | BUTTON_ALT | BUTTON1_PRESSED | BUTTON1_RELEASED | BUTTON1_CLICKED | BUTTON1_DOUBLE_CLICKED | BUTTON1_TRIPLE_CLICKED | BUTTON2_PRESSED | BUTTON2_RELEASED | BUTTON2_CLICKED | BUTTON3_PRESSED | BUTTON3_RELEASED | BUTTON3_CLICKED | BUTTON3_DOUBLE_CLICKED | BUTTON3_TRIPLE_CLICKED, NULL); } else mousemask(0, NULL); #endif /* NCURSES */ #endif /* WIN_EX and PDCURSES */ #if defined(PDCURSES) if (state) mouse_set( BUTTON1_CLICKED | BUTTON1_PRESSED | BUTTON1_RELEASED | BUTTON2_CLICKED | BUTTON2_PRESSED | BUTTON2_RELEASED | BUTTON3_CLICKED | BUTTON3_PRESSED | BUTTON3_RELEASED); #endif #endif /* NOT USE_SLANG */ /***********************************************************************/ #endif /* USE_MOUSE */ } /* * SVr4 curses (and ncurses) initialize the terminal I/O to raw mode, and * simulate other modes in the library. This means that when running, it * simulates the OCRNL setting. Normally that is not a problem. However, when * spawning a subprocess (e.g., xli), the subprocess may write to the screen. * Fine so far - curses resets the terminal I/O to the normal state on exit. * But the subprocess's messages can still be coming to the screen when lynx * returns to the screen mode. This function delays restoring OCRNL until * after the first getch() call. * * The OCRNL setting is controlled by nl()/nonl() of course - but we do not * want to give up that optimization since it would be a bit slower. (Note - * slang does not use this optimization; if it did, the same screen glitch * would occur). * * FIXME: for simplicity, only ncurses is implemented here - the TTY and * SET_TTY definitions are ncurses-specific. The same effect could be done for * other curses implementations, since the "cur_term->Nttyb" part is common to * SVr4 curses. */ void lynx_nl2crlf(int normal GCC_UNUSED) { #if defined(NCURSES_VERSION_PATCH) && defined(SET_TTY) && defined(TERMIOS) && defined(ONLCR) static TTY saved_tty; static int did_save = FALSE; static int waiting = FALSE; static int can_fix = TRUE; if (!did_save) { saved_tty = cur_term->Nttyb; did_save = TRUE; #if NCURSES_VERSION_PATCH < 20010529 /* workaround for optimizer bug with nonl() */ if ((tigetstr("cud1") != 0 && *tigetstr("cud1") == '\n') || (tigetstr("ind") != 0 && *tigetstr("ind") == '\n')) can_fix = FALSE; #endif } if (can_fix) { if (normal) { if (!waiting) { cur_term->Nttyb.c_oflag |= ONLCR; waiting = TRUE; nonl(); } } else { if (waiting) { cur_term->Nttyb = saved_tty; SET_TTY(fileno(stdout), &saved_tty); waiting = FALSE; nl(); LYrefresh(); } } } #endif } void stop_curses(void) { if (LYCursesON) { echo(); } #if defined(PDCURSES) && defined(PDC_BUILD) && PDC_BUILD >= 2401 resetty(); #endif #ifdef __DJGPP__ _eth_release(); #endif /* __DJGPP__ */ #if defined(DOSPATH) && !(defined(USE_SLANG) || defined(_WIN_CC)) #if defined(PDCURSES) endwin(); #else /* !PDCURSES */ #ifdef __DJGPP__ ScreenClear(); #else /* some flavor of win32? */ #ifdef __MINGW32__ clear(); #else clrscr(); #endif #endif /* win32 */ #endif /* PDCURSES */ #else if (LYCursesON == TRUE) { lynx_nl2crlf(TRUE); lynx_enable_mouse(0); if (LYscreen || lynx_called_initscr) { endwin(); /* stop curses */ LYDELSCR(); } } else { #ifdef SH_EX int i; for (i = 0; i <= 3; i++) { printf("\r\n"); } #endif } fflush(stdout); #endif /* defined(DOSPATH) && !(defined(USE_SLANG) || defined(_WIN_CC)) */ fflush(stderr); LYCursesON = FALSE; CTRACE((tfp, "stop_curses: done.\n")); #if defined(SIGTSTP) && defined(USE_SLANG) #ifndef VMS if (!no_suspend) signal(SIGTSTP, SIG_DFL); #endif /* !VMS */ #endif /* SIGTSTP && USE_SLANG */ #ifndef VMS signal(SIGINT, SIG_DFL); #endif /* !VMS */ } #ifdef VMS #ifdef USE_SLANG extern void longname(char *, char *); #endif /* USE_SLANG */ /* * Check terminal type, start curses & setup terminal. */ BOOLEAN setup(char *terminal) { int c; int status; char *dummy = 0, *cp, term[81]; /* * If the display was not set by a command line option then see if it is * available from the environment. */ if ((cp = LYgetXDisplay()) != 0) { StrAllocCopy(x_display, cp); } else { FREE(x_display); } /* * Get terminal type, and convert to lower case. */ term[0] = '\0'; longname(dummy, term); if (term[0] == '\0' && (form_get_data || form_post_data)) { /* * Some yoyo used these under conditions which require -dump, so force * that mode here. - FM */ dump_output_immediately = TRUE; LYcols = DFT_COLS; if (keypad_mode == NUMBERS_AS_ARROWS) keypad_mode = LINKS_ARE_NUMBERED; status = mainloop(); exit_immediately(status); } LYLowerCase(term); printf("%s%s\n", gettext("Terminal ="), term); if ((strlen(term) < 5) || strncmp(term, "vt", 2) || !isdigit(term[2])) { printf("%s\n", gettext("You must use a vt100, 200, etc. terminal with this program.")); printf(CONFIRM_PROCEED, "n/y"); c = getchar(); if (c != 'y' && c != 'Y') { printf("\n"); return (FALSE); } strcpy(term, "vt100"); } ttopen(); start_curses(); LYlines = LYscreenHeight(); LYcols = LYscreenWidth(); return (TRUE); } #else /* Not VMS: */ /* * Check terminal type, start curses & setup terminal. */ BOOLEAN setup(char *terminal) { char *term_putenv = NULL; char *buffer = NULL; char *cp; /* * If the display was not set by a command line option then see if it is * available from the environment . */ if ((cp = LYgetXDisplay()) != NULL) { StrAllocCopy(x_display, cp); } else { FREE(x_display); } if (terminal != NULL) { HTSprintf0(&term_putenv, "TERM=%.106s", terminal); (void) putenv(term_putenv); } /* * Query the terminal type. */ if (dumbterm(LYGetEnv("TERM"))) { printf("\n\n %s\n\n", gettext("Your Terminal type is unknown!")); printf(" %s [vt100] ", gettext("Enter a terminal type:")); if (LYSafeGets(&buffer, stdin) != 0) { LYTrimLeading(buffer); LYTrimTrailing(buffer); } if (isEmpty(buffer)) StrAllocCopy(buffer, "vt100"); HTSprintf0(&term_putenv, "TERM=%.106s", buffer); FREE(buffer); (void) putenv(term_putenv); printf("\n%s %s\n", gettext("TERMINAL TYPE IS SET TO"), LYGetEnv("TERM")); LYSleepMsg(); } start_curses(); #ifdef HAVE_TTYTYPE /* * Account for lossage on the 'sun' terminal type (80x24) Sun text console * driver. It only supports reverse video, but all SGR sequences produce * that same reverse video, and the terminfo entry lists different SGRs for * 'bold' and 'rev'. As a result, the current link is indistinguishable * from all other links. The workaround here is to disable the 'rev' * capability. */ if ((strncmp((const char *) ttytype, "sun", 3) == 0)) { LYnoVideo(2); } #endif /* HAVE_TTYTYPE */ LYlines = LYscreenHeight(); LYcols = LYscreenWidth(); return (1); } static int dumbterm(char *terminal) { int dumb = FALSE; /* * Began checking for terminal == NULL in case that TERM environment * variable is not set. Thanks to Dick Wesseling (ftu@fi.ruu.nl). */ if (terminal == NULL || !strcasecomp(terminal, "network") || !strcasecomp(terminal, "unknown") || !strcasecomp(terminal, "dialup") || !strcasecomp(terminal, "dumb") || !strcasecomp(terminal, "switch") || !strcasecomp(terminal, "ethernet")) dumb = TRUE; return (dumb); } #ifdef FANCY_CURSES #ifndef USE_COLOR_STYLE #ifdef USE_COLOR_TABLE static void LYsetWAttr(WINDOW * win) { wattrset(win, LYgetTableAttr()); } void LYaddWAttr(WINDOW * win, int a) { Current_Attr |= a; LYsetWAttr(win); } void LYaddAttr(int a) { LYaddWAttr(LYwin, a); } void LYsubWAttr(WINDOW * win, int a) { Current_Attr &= ~a; LYsetWAttr(win); } void LYsubAttr(int a) { LYsubWAttr(LYwin, a); } #endif /* USE_COLOR_TABLE */ #endif /* !USE_COLOR_STYLE */ #endif /* FANCY_CURSES */ #endif /* VMS */ /* Use this rather than the 'wprintw()' function to write a blank-padded * string to the given window, since someone's asserted that printw doesn't * handle 8-bit characters unlike addstr (though more info would be useful). * * We're blank-filling so that with SVr4 curses, it'll show the background * color to a uniform width in the popup-menu. */ #ifndef USE_SLANG void LYpaddstr(WINDOW * the_window, int width, const char *the_string) { int y, x; int actual = strlen(the_string); getyx(the_window, y, x); if (width + x > LYcolLimit) width = LYcolLimit - x; if (actual > width) actual = width; LYwaddnstr(the_window, the_string, actual); width -= actual; while (width-- > 0) waddstr(the_window, " "); } /* * Work around limitation of curses's order-of-refresh by setting a pointer to * the topmost window that should be displayed. * * FIXME: the associated call on 'keypad()' is not needed for Unix, but * something in the OS/2 EMX port requires it. */ static WINDOW *my_subwindow; void LYsubwindow(WINDOW * param) { if (param != 0) { my_subwindow = param; #if defined(NCURSES) || defined(PDCURSES) keypad(my_subwindow, TRUE); #if defined(USE_COLOR_STYLE) LynxWChangeStyle(my_subwindow, s_menu_bg, STACK_ON); { long b = LYgetattrs(my_subwindow); wbkgd(my_subwindow, b | ' '); } LynxWChangeStyle(my_subwindow, s_menu_bg, STACK_OFF); #elif defined(HAVE_GETBKGD) /* not defined in ncurses 1.8.7 */ wbkgd(my_subwindow, getbkgd(LYwin)); #endif #endif scrollok(my_subwindow, TRUE); } else { touchwin(LYwin); delwin(my_subwindow); my_subwindow = 0; } } WINDOW *LYtopwindow(void) { return (my_subwindow ? my_subwindow : LYwin); } #endif WINDOW *LYstartPopup(int *top_y, int *left_x, int *height, int *width) { WINDOW *form_window = 0; #ifdef USE_SLANG static WINDOW fake_window; if (*left_x < 1 || (*left_x + *width + 4) >= LYcolLimit) { *left_x = 1; *width = LYcolLimit - 5; } SLsmg_fill_region(*top_y, *left_x - 1, *height, *width + 4, ' '); form_window = &fake_window; form_window->top_y = *top_y; form_window->left_x = *left_x; form_window->height = *height; form_window->width = *width; #else if (*left_x > 0 && (*left_x + *width + 4) < LYcolLimit) form_window = newwin(*height, *width + 4, *top_y, *left_x - 1); if (form_window == 0) { if (*width > LYcolLimit - 4) { *width = LYcolLimit - 4; *left_x = 1; } else { *left_x = LYcolLimit - 4 - *width; } form_window = newwin(*height, *width + 4, *top_y, *left_x - 1); } if (form_window == 0) { HTAlert(POPUP_FAILED); } else { LYsubwindow(form_window); } #endif /* USE_SLANG */ return form_window; } void LYstartTargetEmphasis(void) { #ifdef USE_COLOR_STYLE if (s_whereis != NOSTYLE) { curses_style(s_whereis, STACK_ON); return; } #endif #if defined(FANCY_CURSES) || defined(USE_SLANG) lynx_start_bold(); lynx_start_reverse(); #endif /* FANCY_CURSES || USE_SLANG */ lynx_start_underline(); } void LYstopTargetEmphasis(void) { #ifdef USE_COLOR_STYLE if (s_whereis != NOSTYLE) { curses_style(s_whereis, STACK_OFF); return; } #endif lynx_stop_underline(); #if defined(FANCY_CURSES) || defined(USE_SLANG) lynx_stop_reverse(); lynx_stop_bold(); #endif /* FANCY_CURSES || USE_SLANG */ } /* * Accommodate the different flavors of touchline */ void LYtouchline(int row) { #if defined(HAVE_WREDRAWLN) && !defined(NCURSES_VERSION) wredrawln(LYwin, row, 1); #else #if defined(HAVE_TOUCHLINE) /* touchline() is not available on VMS before version 7.0, and then only on * Alpha, since prior ports of curses were broken. BSD touchline() has a * 4th parameter since it is used internally by touchwin(). */ #if defined(HAVE_BSD_TOUCHLINE) touchline(LYwin, row, 0, COLS); #else touchline(LYwin, row, 1); #endif #else #if !defined(USE_SLANG) touchwin(LYwin); #else SLsmg_touch_lines(row, 1); #endif #endif #endif } /* * Wrapper for waddnstr(). */ void LYwaddnstr(WINDOW * w GCC_UNUSED, const char *src, size_t len) { #ifdef USE_CURSES_PADS /* * If we've configured to use pads for left/right scrolling, that can * interfere with calls to this function that assume they're wrapping. * Writing to a pad which is wider than the screen will simply not wrap. * * Link-highlighting uses wrapping. You can see this by viewing the * options screen in a terminal which is narrower than 80 columns. * * Check for that case, and use curses's wrapping in a derived window to * simplify things, e.g., in case the string contains multibyte or * multicolumn characters. */ int y0, x0; getyx(LYwin, y0, x0); if (LYuseCursesPads && (LYwin == w) /* popups do not wrap */ &&LYshiftWin == 0 && LYwideLines == FALSE && ((int) len > (LYcolLimit - x0)) && (x0 < LYcolLimit)) { WINDOW *sub = derwin(LYwin, LYlines, LYcolLimit, 0, 0); if (sub != 0) { wmove(sub, y0, x0); LYwideLines = TRUE; LYwaddnstr(sub, src, len); getyx(sub, y0, x0); delwin(sub); wmove(LYwin, y0, x0); } LYwideLines = FALSE; return; } #endif /* * We only want to trace this function for the color-style code. It would * be too much logging if not needed. */ #ifdef USE_COLOR_STYLE if (TRACE) { int y, x; LYGetYX(y, x); CTRACE2(TRACE_STYLE, (tfp, "[%2d,%2d] LYwaddnstr(%.*s, %u)\n", y, x, (int) len, src, (unsigned) len)); } #endif /* * There's no guarantee that a library won't temporarily write on its input. * Be safe and copy it when we have const-data. */ while ((int) len > 0) { char temp[MAX_LINE]; size_t use = (len >= MAX_LINE) ? MAX_LINE - 1 : len; memcpy(temp, src, use); temp[use] = 0; waddstr(w, temp); len -= use; } } /* * Determine the number of cells the given string would take up on the screen, * limited by the maxCells parameter. This is used for constructing aligned * text in the options and similar forms. * * FIXME: make this account for wrapping, too. * FIXME: make this useful for "lynx -dump", which hasn't initialized curses. */ int LYstrExtent(const char *string, int len, int maxCells) { int result = 0; int used; if (len < 0) used = strlen(string); else used = len; result = used; #ifdef WIDEC_CURSES if (used > 0 && lynx_called_initscr) { static WINDOW *fake_win; static int fake_max; int n; if (fake_max < maxCells) { fake_max = (maxCells + 1) * 2; if (fake_win != 0) { delwin(fake_win); fake_win = 0; } } if (fake_win == 0) { fake_win = newwin(2, fake_max, 0, 0); } if (fake_win != 0) { int new_x = 0; int new_y = 0; result = 0; wmove(fake_win, 0, 0); for (n = 0; n < used; ++n) { if (IsNormalChar(string[n])) { waddch(fake_win, UCH(string[n])); getyx(fake_win, new_y, new_x); if (new_y > 0 || new_x > maxCells) break; result = new_x; } } } } #endif if (result > maxCells) result = maxCells; return result; } /* * A simple call that relies upon the coincidence that multicell characters * use at least as many bytes as cells. */ int LYstrExtent2(const char *string, int len) { return LYstrExtent(string, len, len); } /* * Returns the total number of cells that the string would use. */ int LYstrCells(const char *string) { return LYstrExtent2(string, strlen(string)); } #ifdef VMS /* * Cut-down termio -- * Do character-oriented stream input for Jeff. * Code ripped off from Micro-Emacs 3.7 by Daniel Lawrence. * * Ever-so-slightly modified by Kathryn Huxtable. 29-Jan-1991. * Cut down for Lou. 8 Sep 1992. * Cut down farther for Lou. 19 Apr 1993. * We don't set PASSALL or PASTHRU since we don't * want to block CTRL/C, CTRL/Y, CTRL/S or CTRL/Q. * Simply setting NOECHO and doing timed reads * is sufficient. * Further mods by Fote. 29-June-1993 * ttopen() and ttclose() are now terminal initialization * and restoration procedures, called once at startup * and at exit, respectively, of the LYNX image. * ttclose() should be called before an exit from LYNX * no matter how the exit is invoked. * setup(terminal) does the ttopen(). * cleanup() calls cleanup_files() and ttclose(). * ttgetc() now handles NOECHO and NOFLITR (instead of * setting the terminal itself to NOECHO in ttopen()). * VMSsignal() added for handling both Ctrl-C *and* Ctrl-Y * interrupts, and disabling system response to Ctrl-T. * Further mods by Fote. 15-Dec-1993 * Added edit handler in ttopen() which will invoke * VMSexit() and behave intelligently on ACCVIO's. * Further mods by Fote. 29-Dec-1993 * Simplified ttgetc(). * Further mods by Fote. 16-Jan-1994 * Added code in ttopen() which will invoke VMSVersion() * to get the version of VMS as VersionVMS for use by * by new or modified interrupt or spawning routines. * Further mods by Fote. 27-Jan-1994 * Added back a typeahead() which supports 'z' or 'Z' as * an "Zap transfer" command via HTCheckForInterrupt() * in LYUtils.c. */ #include #include #include #include #include #include #include #include #include #include #include #ifdef signal #undef signal #endif /* signal */ #include #ifdef system #undef system #endif /* system */ #include #include #define EFN 0 /* Event flag */ static unsigned char buffer[20]; /* Input buffer */ static int in_pos, in_len; /* For escape sequences */ static int oldmode[3]; /* Old TTY mode bits */ static int newmode[3]; /* New TTY mode bits */ static short iochan; /* TTY I/O channel */ static $DESCRIPTOR(term_nam_dsc, "TT"); /* Descriptor for iochan */ static unsigned long mask = LIB$M_CLI_CTRLY | LIB$M_CLI_CTRLT; /* ^Y and ^T */ static unsigned long old_msk; /* Saved control mask */ static short trap_flag = FALSE; /* TRUE if AST is set */ BOOLEAN DidCleanup = FALSE; /* Exit handler flag */ static char VersionVMS[20]; /* Version of VMS */ int VMSVersion(char *VerString, int VerLen) { unsigned long status, itm_cod = SYI$_VERSION; int i, verlen = 0; struct dsc$descriptor version; char *m; version.dsc$a_pointer = VerString; version.dsc$w_length = VerLen - 1; version.dsc$b_dtype = DSC$K_DTYPE_B; version.dsc$b_class = DSC$K_CLASS_S; status = lib$getsyi(&itm_cod, 0, &version, &verlen, 0, 0); if (!(status & 1) || verlen == 0) return 0; /* * Cut out trailing spaces */ for (m = VerString + verlen, i = verlen - 1; i > 0 && VerString[i] == ' '; --i) *(--m) = '\0'; return strlen(VerString) + 1; /* Transmit ending 0 too */ } void VMSexit(void) { /* * If we get here and DidCleanup is not set, it was via an ACCVIO, or * outofmemory forced exit, so make *sure* we attempt a cleanup and reset * the terminal. */ if (!DidCleanup) { if (LYOutOfMemory == FALSE) { fprintf(stderr, gettext("\nA Fatal error has occurred in %s Ver. %s\n"), LYNX_NAME, LYNX_VERSION); fprintf(stderr, gettext("\nPlease notify your system administrator to confirm a bug, and if\n\ confirmed, to notify the lynx-dev list. Bug reports should have concise\n\ descriptions of the command and/or URL which causes the problem, the\n\ operating system name with version number, the TCPIP implementation, the\n\ TRACEBACK if it can be captured, and any other relevant information.\n")); if (LYTraceLogFP == NULL) { fprintf(stderr, RETURN_TO_CLEANUP); (void) getchar(); } } else if (LYCursesON) { HTAlert(MEMORY_EXHAUSTED_ABORT); } cleanup(); } if (LYOutOfMemory == TRUE) { printf("\r\n%s\r\n\r\n", MEMORY_EXHAUSTED_ABORT); fflush(stdout); fflush(stderr); } } /* * TTOPEN -- * This function is called once to set up the terminal * device streams. It translates TT until it finds * the terminal, then assigns a channel to it, sets it * to EDIT, and sets up the Ctrl-C and Ctrl-Y interrupt * handling. */ int ttopen(void) { int iosb[2]; int status; static unsigned long condition; static struct _exit_block { unsigned long forward; unsigned long address; unsigned long zero; unsigned long condition; } exit_handler_block; status = sys$assign(&term_nam_dsc, &iochan, 0, 0); if (status != SS$_NORMAL) exit_immediately(status); status = sys$qiow(EFN, iochan, IO$_SENSEMODE, &iosb, 0, 0, &oldmode, sizeof(oldmode), 0, 0, 0, 0); if (status != SS$_NORMAL) exit_immediately(status); status = iosb[0] & 0xFFFF; if (status != SS$_NORMAL) exit_immediately(status); newmode[0] = oldmode[0]; newmode[1] = oldmode[1]; newmode[2] = oldmode[2] | TT2$M_EDIT; status = sys$qiow(EFN, iochan, IO$_SETMODE, &iosb, 0, 0, &newmode, sizeof(newmode), 0, 0, 0, 0); if (status != SS$_NORMAL) exit_immediately(status); status = iosb[0] & 0xFFFF; if (status != SS$_NORMAL) exit_immediately(status); /* * Declare the exit handler block. */ exit_handler_block.forward = 0; exit_handler_block.address = (unsigned long) &VMSexit; exit_handler_block.zero = 0; exit_handler_block.condition = (unsigned long) &condition; status = sys$dclexh(&exit_handler_block); if (status != SS$_NORMAL) exit_immediately(status); /* * Set the AST. */ lib$disable_ctrl(&mask, &old_msk); trap_flag = TRUE; status = sys$qiow(EFN, iochan, IO$_SETMODE | IO$M_CTRLCAST | IO$M_CTRLYAST, &iosb, 0, 0, &cleanup_sig, SIGINT, 0, 0, 0, 0); if (status != SS$_NORMAL) { lib$enable_ctrl(&old_msk); exit_immediately(status); } /* * Get the version of VMS. */ if (VMSVersion(VersionVMS, 20) < 3) /* * Load zeros on error. */ strcpy(VersionVMS, "V0.0-0"); return (0); } /* ttopen */ /* * TTCLOSE -- * This function gets called just before we go back home * to the command interpreter. It puts the terminal back * in a reasonable state. */ int ttclose(void) { int status; int iosb[1]; status = sys$qiow(EFN, iochan, IO$_SETMODE, &iosb, 0, 0, &oldmode, sizeof(oldmode), 0, 0, 0, 0); if (status != SS$_NORMAL || (iosb[0] & 0xFFFF) != SS$_NORMAL) exit_immediately(status); if (trap_flag) { status = sys$dassgn(iochan); status = lib$enable_ctrl(&old_msk); trap_flag = FALSE; } return (0); } /* ttclose */ /* * TTGETC -- * Read a character from the terminal, with NOECHO and NOFILTR. */ int ttgetc(void) { int status; unsigned short iosb[4]; if (in_pos < in_len) return (buffer[in_pos++]); status = sys$qiow(EFN, iochan, IO$_READVBLK | IO$M_NOECHO | IO$M_NOFILTR, &iosb, 0, 0, &buffer, 1, 0, 0, 0, 0); if ((status & 1) == 1) status = iosb[0]; if (status == SS$_PARTESCAPE) { /* * Escape sequence in progress. Fake a successful read. */ status = 1; } if ((status & 1) != 1 && status != SS$_DATAOVERUN) exit_immediately(status); in_pos = 1; in_len = iosb[1] + iosb[3]; return (buffer[0]); } /* * TYPEAHEAD -- Fote Macrides 27-Jan-1994 * Check whether a keystroke has been entered, and return * it, or -1 if none was entered. */ int typeahead(void) { int status; unsigned short iosb[4]; if (dump_output_immediately) return -1; if (in_pos < in_len) return (buffer[in_pos++]); again: status = sys$qiow(EFN, iochan, IO$_READVBLK | IO$M_TIMED | IO$M_NOECHO | IO$M_NOFILTR, &iosb, 0, 0, &buffer, 1, 0, 0, 0, 0); if ((status & 1) == 1) status = iosb[0]; if (status == SS$_PARTESCAPE) { /* * Escape sequence in progress, finish reading it. */ goto again; } in_pos = 1; in_len = iosb[1] + iosb[3]; if (status == SS$_TIMEOUT || status == SS$_DATAOVERUN) return (-1); return (buffer[0]); } /* * VMSSIGNAL -- Fote Macrides 29-Jun-1993 * Sets up AST for both Ctrl-C and Ctrl-Y, with system response * to Ctrl-T disabled. If called with a sig other than SIGINT, * it will use the C library's system(sig, func). * The equivalent of VMSsignal(SIGINT, cleanup_sig) is done on * intialization by ttopen(), so don't do it again. * VMSsignal(SIGINT, SIG_DFL) is treated as a call to ttclose(). * Call VMSsignal(SIGINT, SIG_IGN) before system() calls to * enable Ctrl-C and Ctrl-Y in the subprocess, and then call * VMSsignal(SIG_INT, cleanup_sig) on return from the subprocess. * For func's which set flags and do not invoke an exit from * LYNX, the func should reassert itself. * The VMS signal() calls do not fully emulate the Unix calls, * and VMSsignal() is just a "helper", also not a full emulation. */ void VMSsignal(int sig, void (*func) ()) { int status; short iosb[4]; static int SIG_IGN_flag; /* * Pass all signals other than SIGINT to signal(). * Also pass SIGINT to signal() if we're dumping. */ if (sig != SIGINT || dump_output_immediately) { signal(sig, func); return; } /* * If func is SIG_DFL, treat it as ttclose(). */ if (func == SIG_DFL) { ttclose(); return; } /* * Clear any previous AST. */ if (trap_flag) { status = sys$dassgn(iochan); status = lib$enable_ctrl(&old_msk); trap_flag = FALSE; } /* * If func is SIG_IGN, leave the TT channel closed and the system response * to interrupts enabled for system() calls. */ if (func == SIG_IGN) return; /* * If we get to here, we have a LYNX func, so set the AST. */ lib$disable_ctrl(&mask, &old_msk); trap_flag = TRUE; status = sys$assign(&term_nam_dsc, &iochan, 0, 0); status = sys$qiow(EFN, iochan, IO$_SETMODE | IO$M_CTRLCAST | IO$M_CTRLYAST, &iosb, 0, 0, func, SIGINT, 0, 0, 0, 0); } /* VMSsignal */ /* * DCLspawn_exception, spawn_DCLprocess, DCLsystem -- F.Macrides 16-Jan-1994 * Exception-handler routines for regulating interrupts and enabling * Control-T during spawns. Includes TRUSTED flag for versions of VMS * which require it in captive accounts. This code should be used * instead of the VAXC or DECC system(), by including LYUtils.h in * modules which have system() calls. It helps ensure that we return * to Lynx instead of breaking out to DCL if a user issues interrupts * or generates an ACCVIO during spawns. */ #ifdef __DECC static unsigned int DCLspawn_exception(void *sigarr, void *mecharr) #else static int DCLspawn_exception(void *sigarr, void *mecharr) #endif /* __DECC */ { int status; status = lib$sig_to_ret(sigarr, mecharr); return (SS$_UNWIND); } static int spawn_DCLprocess(char *command) { int status; unsigned long Status = 0; /* * Keep DECC from complaining. */ struct dsc$descriptor_s command_desc; command_desc.dsc$w_length = strlen(command); command_desc.dsc$b_class = DSC$K_CLASS_S; command_desc.dsc$b_dtype = DSC$K_DTYPE_T; command_desc.dsc$a_pointer = command; VAXC$ESTABLISH(DCLspawn_exception); #ifdef __ALPHA /** OpenVMS/AXP lacked the TRUSTED flag before v6.1 **/ if (VersionVMS[1] > '6' || (VersionVMS[1] == '6' && VersionVMS[2] == '.' && VersionVMS[3] >= '1')) #else if (VersionVMS[1] >= '6') #endif /* __ALPHA */ { /* * Include TRUSTED flag. */ unsigned long trusted = CLI$M_TRUSTED; status = lib$spawn(&command_desc, 0, 0, &trusted, 0, 0, &Status); /* * If it was invalid, try again without the flag. */ if (status == LIB$_INVARG) status = lib$spawn(&command_desc, 0, 0, 0, 0, 0, &Status); } else status = lib$spawn(&command_desc, 0, 0, 0, 0, 0, &Status); /* * Return -1 on error. */ if ((status & 1) != 1 || (Status & 1) != 1) return (-1); /* * Return 0 on success. */ return (0); } int DCLsystem(char *command) { int status; VMSsignal(SIGINT, SIG_IGN); status = spawn_DCLprocess(command); VMSsignal(SIGINT, cleanup_sig); /* * Returns 0 on success, -1 any error. */ return (status); } #endif /* VMS */ /* * Return the physical screen dimensions that we're allowed to use. */ int LYscreenHeight(void) { int result = LINES; if (result <= 0) result = DFT_ROWS; return result; } int LYscreenWidth(void) { int result = COLS; #if defined(PDCURSES_EXP) && defined(WIN_EX) && defined(CJK_EX) /* 1999/08/26 (Thu) 17:53:38 */ { extern int current_codepage; /* PDCurses lib. */ if (current_codepage == 932) result--; } #endif if (result <= 0) result = DFT_COLS; return result; } /* * Set the window's background color (make the pad's color agree), e.g., when * we have just parsed it from the config file, or after clearing the screen. */ void LYnormalColor(void) { #if defined(USE_COLOR_STYLE) && defined(USE_CURSES_PADS) if (LYwin != stdscr) { int color = displayStyles[DSTYLE_NORMAL].color; if (color >= 0) { wbkgd(LYwin, color | ' '); LYrefresh(); } } #endif } /* * The functions ifdef'd with USE_CURSES_PADS are implemented that way so we * don't break the slang configuration. */ void LYclear(void) { #ifdef USE_CURSES_PADS wclear(LYwin); #else clear(); #endif LYnormalColor(); } void LYclrtoeol(void) { #ifdef USE_CURSES_PADS wclrtoeol(LYwin); #else clrtoeol(); #endif } void LYerase(void) { #ifdef USE_CURSES_PADS werase(LYwin); #else erase(); #endif LYnormalColor(); } void LYmove(int y, int x) { #ifdef USE_CURSES_PADS wmove(LYwin, y, x); #else move(y, x); #endif } void LYrefresh(void) { #ifdef USE_CURSES_PADS if (LYwin != stdscr) { /* * Workaround for special case where lynx is prompting for a mailto, * and has a subject line that is wider than the screen. The * wnoutrefresh() call resets newscr's position to match stdscr's, * which happens to be the window's origin because we were not updating * that, and other stray wmove's in lynx fail because the coordinate * is on/after the right margin. Force things to look ok here. */ int y, x; getyx(LYwin, y, x); if (x > LYcolLimit) x = LYcolLimit; wmove(stdscr, y, x); wnoutrefresh(stdscr); pnoutrefresh(LYwin, 0, LYshiftWin, 0, 0, LYlines, LYscreenWidth() - 1); /* * Keep a popup window visible. This can happen if the user presses * '/' to do a search within a popup. */ if (my_subwindow != 0) { touchwin(my_subwindow); wnoutrefresh(my_subwindow); } doupdate(); } else { refresh(); } #else refresh(); #endif } void lynx_force_repaint(void) { clearok(curscr, TRUE); } void lynx_start_title_color(void) { #ifdef SH_EX lynx_start_reverse(); #endif } void lynx_stop_title_color(void) { #ifdef SH_EX lynx_stop_reverse(); #endif } void lynx_start_link_color(int flag, int pending) { if (flag) { /* makes some terminals work wrong because * they can't handle two attributes at the * same time */ /* lynx_start_bold(); */ lynx_start_reverse(); #if defined(USE_SLANG) #ifndef __DJGPP__ if (SLtt_Use_Ansi_Colors) #endif /* !__DJGPP__ */ lynx_start_underline(); #endif /* USE_SLANG */ #if defined(FANCY_CURSES) && defined(COLOR_CURSES) if (lynx_has_color && LYShowColor >= SHOW_COLOR_ON) lynx_start_underline(); #endif /* USE_SLANG */ } else { lynx_start_bold(); /* * Make sure when flag is OFF that "unhighlighted" links will be * underlined if appropriate. - LE & FM */ if (pending) lynx_start_underline(); } } void lynx_stop_link_color(int flag, int pending GCC_UNUSED) { #ifdef USE_COLOR_STYLE LynxChangeStyle(flag == ON ? s_alink : s_a, ABS_OFF); #else if (flag) { lynx_stop_reverse(); #if defined(USE_SLANG) #ifndef __DJGPP__ if (SLtt_Use_Ansi_Colors) #endif /* !__DJGPP__ */ lynx_stop_underline(); #endif /* USE_SLANG */ #if defined(FANCY_CURSES) && defined(COLOR_CURSES) if (lynx_has_color && LYShowColor >= SHOW_COLOR_ON) lynx_stop_underline(); #endif /* FANCY_CURSES && COLOR_CURSES */ } else { lynx_stop_bold(); /* * If underlining was turned on above, turn it off. - LE & FM */ if (pending) lynx_stop_underline(); } #endif } /* FIXME: consider inlining these */ void lynx_stop_target_color(void) { lynx_stop_underline(); lynx_stop_reverse(); lynx_stop_bold(); } void lynx_start_target_color(void) { lynx_start_bold(); lynx_start_reverse(); lynx_start_underline(); } void lynx_start_status_color(void) { #if defined(USE_COLOR_TABLE) && defined(COLOR_CURSES) if (lynx_has_color && LYShowColor >= SHOW_COLOR_ON) lynx_set_color(2); else #endif lynx_start_reverse(); } void lynx_stop_status_color(void) { #if defined(USE_COLOR_TABLE) && defined(COLOR_CURSES) if (lynx_has_color && LYShowColor >= SHOW_COLOR_ON) lynx_set_color(0); else #endif lynx_stop_reverse(); } void lynx_start_h1_color(void) { if (bold_H1 || bold_headers) lynx_start_bold(); } void lynx_stop_h1_color(void) { if (bold_H1 || bold_headers) lynx_stop_bold(); } void lynx_start_prompt_color(void) { lynx_start_reverse(); } void lynx_stop_prompt_color(void) { lynx_stop_reverse(); } void lynx_start_radio_color(void) { lynx_start_bold(); } void lynx_stop_radio_color(void) { lynx_stop_bold(); } void lynx_stop_all_colors(void) { lynx_stop_underline(); lynx_stop_reverse(); lynx_stop_bold(); } /* * Wrappers for LYUnderlineLinks flag. */ void lynx_start_bold(void) { start_bold(); } void lynx_start_reverse(void) { start_reverse(); } void lynx_start_underline(void) { start_underline(); } void lynx_stop_bold(void) { stop_bold(); } void lynx_stop_reverse(void) { stop_reverse(); } void lynx_stop_underline(void) { stop_underline(); } /* * If LYShowCursor is ON, move the cursor to the left of the current option, so * that blind users, who are most likely to have LYShowCursor ON, will have * it's string spoken or passed to the braille interface as each option is made * current. Otherwise, move it to the bottom, right column of the screen, to * "hide" the cursor as for the main document, and let sighted users rely on * the current option's highlighting or color without the distraction of a * blinking cursor in the window. - FM */ void LYstowCursor(WINDOW * win, int row, int col) { if (LYShowCursor) { wmove(win, row, col); } else { LYHideCursor(); } #ifdef USE_SLANG SLsmg_refresh(); #else wrefresh(win); #endif /* USE_SLANG */ } #if defined(USE_BLINK) && defined(__EMX__) /* Can't put it earler due to BOOLEAN conflict */ # define BOOLEAN os2BOOLEAN # define INCL_VIO # include "os2.h" static void make_blink_boldbg(void) { VIOINTENSITY buf; /* VIO windows have it anyway, */ /* but FS session need a switch */ buf.cb = sizeof(buf); buf.type = 2; /* VIOINTENSITY request */ buf.fs = 1; /* Intensity == boldbg */ VioSetState(&buf, 0); } #endif #if defined(HAVE_WATTR_GET) /* * getattrs() is not in X/Open curses, but it is more convenient than this. */ long LYgetattrs(WINDOW * win) { #if ( defined(HAVE_GETATTRS) && ( !defined(NCURSES_VERSION_MAJOR) || NCURSES_VERSION_MAJOR < 5 ) ) long result = 0; result = getattrs(win); #else attr_t result = 0; short pair = 0; /* * FIXME: this ignores the color-pair, which for most implementations is * not stored in the attribute value. */ wattr_get(win, &result, &pair, NULL); #endif return result; } #endif /* HAVE_WATTR_GET */ #if defined(NCURSES_VERSION_PATCH) && NCURSES_VERSION_PATCH > 20021012 #ifndef HAVE_USE_LEGACY_CODING /* * Between ncurses 5.3 and 5.4 as part of fixes for wide-character mode, the * locale support no longer allows characters in the range 128-159 to be * treated as printable characters. Here is a workaround to fool * waddch_nosync() into treating "all" 8-bit characters as printable. */ NCURSES_CONST char *unctrl(chtype ch) { static char result[3]; unsigned data = (unsigned char) ch; if (data < 32) { result[0] = '^'; result[1] = ch | '@'; result[2] = 0; } else if (data == 127) { result[0] = '^'; result[1] = '?'; result[2] = 0; } else { result[0] = data; result[1] = 0; } return result; } #endif /* HAVE_USE_LEGACY_CODING */ #endif