diff options
Diffstat (limited to 'mdk-stage1/slang/slcurses.c')
-rw-r--r-- | mdk-stage1/slang/slcurses.c | 972 |
1 files changed, 972 insertions, 0 deletions
diff --git a/mdk-stage1/slang/slcurses.c b/mdk-stage1/slang/slcurses.c new file mode 100644 index 000000000..f1212afc8 --- /dev/null +++ b/mdk-stage1/slang/slcurses.c @@ -0,0 +1,972 @@ +/* Copyright (c) 1998, 1999, 2001 John E. Davis + * This file is part of the S-Lang library. + * + * You may distribute under the terms of either the GNU General Public + * License or the Perl Artistic License. + */ +#include "slinclud.h" + +#include <signal.h> +#include <errno.h> + +#include "slang.h" +#include "_slang.h" +#include "slcurses.h" + +/* This file is meant to implement a primitive curses implementation in + * terms of SLsmg calls. The fact is that the interfaces are sufficiently + * different that a 100% emulation is not possible. + */ + +SLcurses_Window_Type *SLcurses_Stdscr; +int SLcurses_Esc_Delay = 150; /* 0.15 seconds */ +SLtt_Char_Type SLcurses_Acs_Map [128]; +int SLcurses_Is_Endwin = 1; +int SLcurses_Num_Colors = 8; + +static void blank_line (SLsmg_Char_Type *b, unsigned int len, SLsmg_Char_Type color) +{ + SLsmg_Char_Type *bmax; + + bmax = b + len; + color = SLSMG_BUILD_CHAR(' ', color); + + while (b < bmax) *b++ = color; +} + +static int va_mvprintw (SLcurses_Window_Type *w, int r, int c, int do_move, + char *fmt, va_list ap) +{ + char buf[1024]; + + if (do_move) SLcurses_wmove (w, r, c); + + (void) _SLvsnprintf (buf, sizeof(buf), fmt, ap); + + SLcurses_waddnstr (w, buf, -1); + return 0; +} + +int SLcurses_mvprintw (int r, int c, char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + va_mvprintw (SLcurses_Stdscr, r, c, 1, fmt, ap); + va_end(ap); + + return 0; +} + +int SLcurses_mvwprintw (SLcurses_Window_Type *w, int r, int c, char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + va_mvprintw (w, r, c, 1, fmt, ap); + va_end(ap); + + return 0; +} + +int SLcurses_wprintw (SLcurses_Window_Type *w, char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + va_mvprintw (w, 0, 0, 0, fmt, ap); + va_end(ap); + + return 0; +} + +int SLcurses_printw (char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + va_mvprintw (SLcurses_Stdscr, 0, 0, 0, fmt, ap); + va_end(ap); + + return 0; +} + +int SLcurses_nil (void) +{ + return 0; +} + +int SLcurses_has_colors(void) +{ + return SLtt_Use_Ansi_Colors; +} + +int SLcurses_nodelay (SLcurses_Window_Type *w, int onoff) +{ + w->delay_off = (onoff ? 0 : -1); + return 0; +} + +int SLcurses_wgetch (SLcurses_Window_Type *w) +{ + if (w == NULL) + return ERR; + + SLcurses_wrefresh (w); + + if ((w->delay_off == -1) || + SLang_input_pending (w->delay_off)) + { + if (w->use_keypad) + { + int ch = SLang_getkey (); + if (ch == '\033') + { + if (0 == SLang_input_pending (ESCDELAY / 100)) + return ch; + } + else if (ch == 0xFFFF) return ERR; + SLang_ungetkey (ch); + return SLkp_getkey (); + } + return SLang_getkey (); + } + + return ERR; +} + +int SLcurses_getch (void) +{ + return SLcurses_wgetch (SLcurses_Stdscr); +} + +/* This is a super hack. That fact is that SLsmg and curses + * are incompatible. + */ +static unsigned char Color_Objects[256]; + +static unsigned int map_attr_to_object (SLtt_Char_Type attr) +{ + unsigned int obj; + SLtt_Char_Type at; + + obj = (attr >> 8) & 0xFF; + + if (SLtt_Use_Ansi_Colors) + { + if (Color_Objects[obj] != 0) return obj; + + at = SLtt_get_color_object (obj & 0xF); + + if (attr & A_BOLD) at |= SLTT_BOLD_MASK; + if (attr & A_UNDERLINE) at |= SLTT_ULINE_MASK; + if (attr & A_REVERSE) at |= SLTT_REV_MASK; + + SLtt_set_color_object (obj, at); + + Color_Objects[obj] = 1; + } + else obj = obj & 0xF0; + + return obj; + +} + +int SLcurses_start_color (void) +{ + int f, b; + int obj; + + if (SLtt_Use_Ansi_Colors == 0) return -1; + + obj = 0; + for (f = 0; f < 16; f++) + { + for (b = 0; b < 16; b++) + { + obj++; + SLtt_set_color_fgbg (obj, f, b); + } + } + return 0; +} + +#ifdef SIGINT +static void sigint_handler (int sig) +{ + SLang_reset_tty (); + SLsmg_reset_smg (); + exit (sig); +} +#endif + +/* Values are assumed to be 0, 1, 2. This fact is exploited */ +static int TTY_State; + +static int init_tty (int suspend_ok) +{ + if (-1 == SLang_init_tty (-1, 1, 0)) + return -1; + +#ifdef REAL_UNIX_SYSTEM + if (suspend_ok) SLtty_set_suspend_state (1); +#endif + return 0; +} + +int SLcurses_raw (void) +{ + TTY_State = 1; + return init_tty (0); +} + +int SLcurses_cbreak (void) +{ + TTY_State = 2; + return init_tty (1); +} + +#if defined(SIGTSTP) && defined(SIGSTOP) +static void sigtstp_handler (int sig) +{ + sig = errno; + + SLsmg_suspend_smg (); + + if (TTY_State) + SLang_reset_tty (); + + kill(getpid(),SIGSTOP); + + SLsmg_resume_smg (); + + if (TTY_State) init_tty (TTY_State - 1); + + signal (SIGTSTP, sigtstp_handler); + errno = sig; +} +#endif + +SLcurses_Window_Type *SLcurses_initscr (void) +{ + SLcurses_Is_Endwin = 0; + SLsmg_Newline_Behavior = SLSMG_NEWLINE_MOVES; + SLtt_get_terminfo (); + +#if !defined(IBMPC_SYSTEM) && !defined(VMS) + if (-1 == (SLcurses_Num_Colors = SLtt_tgetnum ("Co"))) +#endif + SLcurses_Num_Colors = 8; + + if ((-1 == SLkp_init ()) + || (-1 == SLcurses_cbreak ()) + || (NULL == (SLcurses_Stdscr = SLcurses_newwin (0, 0, 0, 0))) + || (-1 == SLsmg_init_smg ())) + { + SLang_doerror (NULL); + SLang_exit_error ("SLcurses_initscr: init failed\n"); + return NULL; + } + +#ifdef SIGINT + signal (SIGINT, sigint_handler); +#endif + +#if defined(SIGTSTP) && defined(SIGSTOP) + signal (SIGTSTP, sigtstp_handler); +#endif + + SLtt_set_mono (A_BOLD >> 8, NULL, SLTT_BOLD_MASK); + SLtt_set_mono (A_UNDERLINE >> 8, NULL, SLTT_ULINE_MASK); + SLtt_set_mono (A_REVERSE >> 8, NULL, SLTT_REV_MASK); + /* SLtt_set_mono (A_BLINK >> 8, NULL, SLTT_BLINK_MASK); */ + SLtt_set_mono ((A_BOLD|A_UNDERLINE) >> 8, NULL, SLTT_ULINE_MASK|SLTT_BOLD_MASK); + SLtt_set_mono ((A_REVERSE|A_UNDERLINE) >> 8, NULL, SLTT_ULINE_MASK|SLTT_REV_MASK); + + if (SLtt_Has_Alt_Charset) + { + SLcurses_Acs_Map[SLSMG_ULCORN_CHAR] = SLSMG_ULCORN_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_URCORN_CHAR] = SLSMG_URCORN_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_LLCORN_CHAR] = SLSMG_LLCORN_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_LRCORN_CHAR] = SLSMG_LRCORN_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_UTEE_CHAR] = SLSMG_UTEE_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_DTEE_CHAR] = SLSMG_DTEE_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_LTEE_CHAR] = SLSMG_LTEE_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_RTEE_CHAR] = SLSMG_RTEE_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_VLINE_CHAR] = SLSMG_VLINE_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_HLINE_CHAR] = SLSMG_HLINE_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_PLUS_CHAR] = SLSMG_PLUS_CHAR | A_ALTCHARSET; + SLcurses_Acs_Map[SLSMG_CKBRD_CHAR] = SLSMG_CKBRD_CHAR | A_ALTCHARSET; + } + else + { + /* ugly defaults to use on terminals which don't support graphics */ + SLcurses_Acs_Map[SLSMG_ULCORN_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_URCORN_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_LLCORN_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_LRCORN_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_UTEE_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_DTEE_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_LTEE_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_RTEE_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_VLINE_CHAR] = '|'; + SLcurses_Acs_Map[SLSMG_HLINE_CHAR] = '-'; + SLcurses_Acs_Map[SLSMG_PLUS_CHAR] = '+'; + SLcurses_Acs_Map[SLSMG_CKBRD_CHAR] = '#'; + } + + return SLcurses_Stdscr; +} + +int SLcurses_wattrset (SLcurses_Window_Type *w, SLtt_Char_Type ch) +{ + unsigned int obj; + + obj = map_attr_to_object (ch); + w->color = obj; + w->attr = ch; + return 0; +} + +int SLcurses_wattroff (SLcurses_Window_Type *w, SLtt_Char_Type ch) +{ + if (SLtt_Use_Ansi_Colors) + return SLcurses_wattrset (w, 0); + + w->attr &= ~ch; + return SLcurses_wattrset (w, w->attr); +} + +int SLcurses_wattron (SLcurses_Window_Type *w, SLtt_Char_Type ch) +{ + if (SLtt_Use_Ansi_Colors) + return SLcurses_wattrset (w, ch); + + w->attr |= ch; + return SLcurses_wattrset (w, w->attr); +} + +int SLcurses_delwin (SLcurses_Window_Type *w) +{ + if (w == NULL) return 0; + if (w->lines != NULL) + { + SLsmg_Char_Type **lines = w->lines; + if (w->is_subwin == 0) + { + unsigned int r, rmax; + + rmax = w->nrows; + for (r = 0; r < rmax; r++) + { + SLfree ((char *)lines[r]); + } + } + + SLfree ((char *)lines); + } + + SLfree ((char *)w); + if (w == SLcurses_Stdscr) + SLcurses_Stdscr = NULL; + return 0; +} + +SLcurses_Window_Type *SLcurses_newwin (unsigned int nrows, unsigned int ncols, + unsigned int r, unsigned int c) +{ + SLcurses_Window_Type *win; + SLsmg_Char_Type **lines; + + if (r >= (unsigned int) SLtt_Screen_Rows) + return NULL; + if (c >= (unsigned int) SLtt_Screen_Cols) + return NULL; + + if (NULL == (win = (SLcurses_Window_Type *) SLmalloc (sizeof (SLcurses_Window_Type)))) + return NULL; + + SLMEMSET ((char *) win, 0, sizeof (SLcurses_Window_Type)); + + if (nrows == 0) + nrows = (unsigned int) SLtt_Screen_Rows - r; + if (ncols == 0) + ncols = (unsigned int) SLtt_Screen_Cols - c; + + lines = (SLsmg_Char_Type **) SLmalloc (nrows * sizeof (SLsmg_Char_Type *)); + if (lines == NULL) + { + SLcurses_delwin (win); + return NULL; + } + + SLMEMSET ((char *) lines, 0, nrows * sizeof (SLsmg_Char_Type *)); + + win->lines = lines; + win->scroll_max = win->nrows = nrows; + win->ncols = ncols; + win->_begy = r; + win->_begx = c; + win->_maxx = (c + ncols) - 1; + win->_maxy = (r + nrows) - 1; + win->modified = 1; + win->delay_off = -1; + + for (r = 0; r < nrows; r++) + { + SLsmg_Char_Type *b; + + b = (SLsmg_Char_Type *) SLmalloc (ncols * sizeof (SLsmg_Char_Type)); + if (b == NULL) + { + SLcurses_delwin (win); + return NULL; + } + lines [r] = b; + blank_line (b, ncols, 0); + } + + return win; +} + +int SLcurses_wmove (SLcurses_Window_Type *win, unsigned int r, unsigned int c) +{ + if (win == NULL) return -1; + win->_cury = r; + win->_curx = c; + win->modified = 1; + return 0; +} + +static int do_newline (SLcurses_Window_Type *w) +{ + w->_curx = 0; + w->_cury += 1; + if (w->_cury >= w->scroll_max) + { + w->_cury = w->scroll_max - 1; + if (w->scroll_ok) + SLcurses_wscrl (w, 1); + } + + return 0; +} + +int SLcurses_waddch (SLcurses_Window_Type *win, SLtt_Char_Type attr) +{ + SLsmg_Char_Type *b, ch; + SLsmg_Char_Type color; + + if (win == NULL) return -1; + + if (win->_cury >= win->nrows) + { + /* Curses seems to move current postion to top of window. */ + win->_cury = win->_curx = 0; + return -1; + } + + win->modified = 1; + + ch = SLSMG_EXTRACT_CHAR(attr); + + if (attr == ch) + color = win->color; + else + { + /* hack to pick up the default color for graphics chars */ + if (((attr & A_COLOR) == 0) && ((attr & A_ALTCHARSET) != 0)) + { + /* FIXME: priority=medium: Use SLSMG_?? instead of << */ + attr |= win->color << 8; + } + color = map_attr_to_object (attr); + } + + if (ch < ' ') + { + if (ch == '\n') + { + SLcurses_wclrtoeol (win); + return do_newline (win); + } + + if (ch == '\r') + { + win->_curx = 0; + return 0; + } + + if (ch == '\b') + { + if (win->_curx > 0) + win->_curx--; + + return 0; + } + + /* HACK HACK!!!! */ + if (ch == '\t') ch = ' '; + } + + if (win->_curx >= win->ncols) + do_newline (win); + + b = win->lines[win->_cury] + win->_curx; + *b = SLSMG_BUILD_CHAR(ch,color); + win->_curx++; + + return 0; +} + +int SLcurses_wnoutrefresh (SLcurses_Window_Type *w) +{ + unsigned int len; + unsigned int r, c; + unsigned int i, imax; + + if (SLcurses_Is_Endwin) + { + if (TTY_State) init_tty (TTY_State - 1); + SLsmg_resume_smg (); + SLcurses_Is_Endwin = 0; + } + + if (w == NULL) + { + SLsmg_refresh (); + return -1; + } + + if (w->modified == 0) + return 0; + + r = w->_begy; + c = w->_begx; + + len = w->ncols; + imax = w->nrows; + + for (i = 0; i < imax; i++) + { + SLsmg_gotorc (r, c); + SLsmg_write_color_chars (w->lines[i], len); + r++; + } + + if (w->has_box) + SLsmg_draw_box(w->_begy, w->_begx, w->nrows, w->ncols); + + SLsmg_gotorc (w->_begy + w->_cury, w->_begx + w->_curx); + w->modified = 0; + return 0; +} + +int SLcurses_wrefresh (SLcurses_Window_Type *w) +{ + if (w == NULL) + return -1; + + if (w->modified == 0) + return 0; + + SLcurses_wnoutrefresh (w); + SLsmg_refresh (); + return 0; +} + +int SLcurses_wclrtoeol (SLcurses_Window_Type *w) +{ + SLsmg_Char_Type *b, *bmax; + SLsmg_Char_Type blank; + + if (w == NULL) return -1; + if (w->_cury >= w->nrows) + return 0; + + w->modified = 1; + + blank = SLSMG_BUILD_CHAR(' ',w->color); + + b = w->lines[w->_cury]; + bmax = b + w->ncols; + b += w->_curx; + + while (b < bmax) *b++ = blank; + return 0; +} + +int SLcurses_wclrtobot (SLcurses_Window_Type *w) +{ + SLsmg_Char_Type *b, *bmax; + SLsmg_Char_Type blank; + unsigned int r; + + if (w == NULL) return -1; + + w->modified = 1; + blank = SLSMG_BUILD_CHAR(' ',w->color); + SLcurses_wclrtoeol (w); + for (r = w->_cury + 1; r < w->nrows; r++) + { + b = w->lines [r]; + bmax = b + w->ncols; + + while (b < bmax) *b++ = blank; + } + + return 0; +} + +int SLcurses_wscrl (SLcurses_Window_Type *w, int n) +{ + SLsmg_Char_Type **lines; + unsigned int r, rmax, rmin, ncols; + SLsmg_Char_Type color; + + if ((w == NULL) || (w->scroll_ok == 0)) + return -1; + + w->modified = 1; +#if 0 + if (w->is_subwin) + { + SLang_reset_tty (); + SLsmg_reset_smg (); + fprintf (stderr, "\rAttempt to scroll a subwindow\n"); + exit (1); + } +#endif + + color = w->color; + ncols = w->ncols; + lines = w->lines; + rmax = w->scroll_max; + rmin = w->scroll_min; + if (rmax > w->nrows) + rmax = w->nrows; + if (rmin >= rmax) + return 0; + + while (n > 0) + { + for (r = rmin + 1; r < rmax; r++) + { + /* lines[r - 1] = lines[r]; */ + memcpy ((char *)lines[r - 1], (char *)lines[r], + sizeof (SLsmg_Char_Type) * ncols); + } + blank_line (lines[rmax - 1], ncols, color); + n--; + } + + rmax--; + while (n < 0) + { + for (r = rmax; r > rmin; r--) + { + memcpy ((char *)lines[r], (char *)lines[r - 1], + sizeof (SLsmg_Char_Type) * ncols); + } + blank_line (lines[rmin], ncols, color); + n++; + } + + /* wmove (w, w->nrows - 1, 0); */ + /* wclrtobot (w); */ + return 0; +} + +/* Note: if len is < 0, entire string will be used. + */ +int SLcurses_waddnstr (SLcurses_Window_Type *w, char *str, int len) +{ + SLsmg_Char_Type *b; + SLsmg_Char_Type color; + unsigned char ch; + unsigned int nrows, ncols, crow, ccol; + + if ((w == NULL) + || (str == NULL)) + return -1; + + w->modified = 1; + nrows = w->nrows; + ncols = w->ncols; + crow = w->_cury; + ccol = w->_curx; + color = w->color; + + if (w->scroll_max <= nrows) + nrows = w->scroll_max; + + if (crow >= nrows) + crow = 0; /* wrap back to top */ + + b = w->lines [crow] + ccol; + + while (len && ((ch = (unsigned char) *str++) != 0)) + { + len--; + + if (ch == '\n') + { + w->_cury = crow; + w->_curx = ccol; + SLcurses_wclrtoeol (w); + do_newline (w); + crow = w->_cury; + ccol = w->_curx; + b = w->lines[crow]; + continue; + } + + if (ccol >= ncols) + { + ccol = 0; + crow++; + if (crow >= nrows) + { + w->_curx = 0; + w->_cury = crow; + do_newline (w); + crow = w->_cury; + ccol = w->_curx; + } + + b = w->lines [crow]; + } + + if (ch == '\t') + { + unsigned int n = ccol; + n += SLsmg_Tab_Width; + n = SLsmg_Tab_Width - (n % SLsmg_Tab_Width); + if (ccol + n > ncols) n = ncols - len; + ccol += n; + while (n--) + *b++ = SLSMG_BUILD_CHAR(' ',color); + continue; + } + + *b++ = SLSMG_BUILD_CHAR(ch, color); + ccol++; + } + + w->_curx = ccol; + w->_cury = crow; + + return 0; +} + +/* This routine IS NOT CORRECT. It needs to compute the proper overlap + * and copy accordingly. Here, I just assume windows are same size. + */ +#if 0 +int SLcurses_overlay (SLcurses_Window_Type *swin, SLcurses_Window_Type *dwin) +{ + SLsmg_Char_Type *s, *smax, *d, *dmax; + + if ((swin == NULL) || (dwin == NULL)) + return -1; + + s = swin->buf; + smax = swin->bufmax; + d = dwin->buf; + dmax = dwin->bufmax; + + while ((s < smax) && (d < dmax)) + { + SLsmg_Char_Type ch = *s++; + if (SLSMG_EXTRACT_CHAR(ch) != ' ') + *d = ch; + d++; + } + + return -1; /* not implemented */ +} + +#endif + +SLcurses_Window_Type *SLcurses_subwin (SLcurses_Window_Type *orig, + unsigned int nlines, unsigned int ncols, + unsigned int begin_y, unsigned int begin_x) +{ + SLcurses_Window_Type *sw; + int r, c; + unsigned int i; + + if (orig == NULL) + return NULL; + + sw = (SLcurses_Window_Type *) SLmalloc (sizeof (SLcurses_Window_Type)); + if (sw == NULL) + return NULL; + + SLMEMSET ((char *)sw, 0, sizeof (SLcurses_Window_Type)); +#if 1 + r = begin_y - orig->_begy; +#else + r = 1 + ((int)orig->nrows - (int)nlines) / 2; +#endif + if (r < 0) r = 0; + if (r + nlines > orig->nrows) nlines = orig->nrows - r; + + c = ((int)orig->ncols - (int)ncols) / 2; + if (c < 0) c = 0; + if (c + ncols > orig->ncols) ncols = orig->ncols - c; + + sw->scroll_min = 0; + sw->scroll_max = sw->nrows = nlines; + sw->ncols = ncols; + sw->_begy = begin_y; + sw->_begx = begin_x; + sw->_maxx = (begin_x + ncols) - 1; + sw->_maxy = (begin_y + nlines) - 1; + + sw->lines = (SLsmg_Char_Type **) SLmalloc (nlines * sizeof (SLsmg_Char_Type *)); + if (sw->lines == NULL) + { + SLcurses_delwin (sw); + return NULL; + } + + for (i = 0; i < nlines; i++) + { + sw->lines [i] = orig->lines [r + i] + c; + } + + sw->is_subwin = 1; + return sw; +} + +int SLcurses_wclear (SLcurses_Window_Type *w) +{ + unsigned int i; + + if (w != NULL) w->modified = 1; + for (i=0; i < w->nrows; i++) + blank_line (w->lines[i], w->ncols, w->color); + return 0; +} + +int SLcurses_wdelch (SLcurses_Window_Type *w) +{ + SLsmg_Char_Type *p, *p1, *pmax; + + p = w->lines[w->_cury]; + pmax = p + w->ncols; + p += w->_curx; + p1 = p + 1; + + while (p1 < pmax) + { + *p = *p1; + p = p1; + p1++; + } + + if (p < pmax) + *p = SLSMG_BUILD_CHAR(' ',w->color); + + w->modified = 1; + return 0; +} + +int SLcurses_winsch (SLcurses_Window_Type *w, int ch) +{ + SLsmg_Char_Type *p, *p1, *pmax; + + p = w->lines[w->_cury]; + pmax = p + w->ncols; + p += w->_curx; + p1 = pmax - 1; + + while (pmax > p) + { + *pmax = *p1; + pmax = p1; + p1--; + } + + if (p < pmax) + *p = SLSMG_BUILD_CHAR(ch, w->color); + + w->modified = 1; + return 0; +} + +int SLcurses_endwin (void) +{ + SLcurses_Is_Endwin = 1; + SLsmg_suspend_smg (); + SLang_reset_tty (); + return 0; +} + +#if 0 +int SLcurses_mvwscanw (SLcurses_Window_Type *w, unsigned int r, unsigned int c, + char *fmt, ...) +{ +#if HAVE_VFSCANF + int ret; + va_list ap; + + SLcurses_wmove (w, r, c); + SLcurses_wrefresh (w); + + va_start(ap, fmt); + ret = vfscanf (stdin, fmt, ap); + va_end(ap); + return ret; +#else + return 0; +#endif +} + +int SLcurses_wscanw (SLcurses_Window_Type *w, char *fmt, ...) +{ +#if HAVE_VFSCANF + va_list ap; + int ret; + + SLcurses_wrefresh (w); + + va_start(ap, fmt); + ret = vfscanf (stdin, fmt, ap); + va_end(ap); + + return ret; +#else + return 0; +#endif +} + +int SLcurses_scanw (char *fmt, ...) +{ +#ifdef HAVE_VFSCANF + va_list ap; + int ret; + + SLcurses_wrefresh (SLcurses_Stdscr); + + va_start(ap, fmt); + ret = vfscanf (stdin, fmt, ap); + va_end(ap); + + return ret; +#else + return 0; +#endif +} +#endif + +int SLcurses_clearok (SLcurses_Window_Type *w, int bf) +{ + if (bf) + { + SLsmg_cls (); + w->modified = 1; + } + return 0; +} |