427 lines
10 KiB
C
427 lines
10 KiB
C
/****************************************************************************
|
|
* Copyright 2019,2020 Thomas E. Dickey *
|
|
* Copyright 1998-2016,2017 Free Software Foundation, Inc. *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a *
|
|
* copy of this software and associated documentation files (the *
|
|
* "Software"), to deal in the Software without restriction, including *
|
|
* without limitation the rights to use, copy, modify, merge, publish, *
|
|
* distribute, distribute with modifications, sublicense, and/or sell *
|
|
* copies of the Software, and to permit persons to whom the Software is *
|
|
* furnished to do so, subject to the following conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included *
|
|
* in all copies or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS *
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF *
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. *
|
|
* IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR *
|
|
* THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
* *
|
|
* Except as contained in this notice, the name(s) of the above copyright *
|
|
* holders shall not be used in advertising or otherwise to promote the *
|
|
* sale, use or other dealings in this Software without prior written *
|
|
* authorization. *
|
|
****************************************************************************/
|
|
|
|
/*
|
|
* Author: Thomas E. Dickey 1998
|
|
*
|
|
* $Id: filter.c,v 1.34 2020/02/02 23:34:34 tom Exp $
|
|
*
|
|
* An example of the 'filter()' function in ncurses, this program prompts
|
|
* for commands and executes them (like a command shell). It illustrates
|
|
* how ncurses can be used to implement programs that are not full-screen.
|
|
*
|
|
* Ncurses differs slightly from SVr4 curses. The latter does not flush its
|
|
* state when exiting program mode, so the attributes on the command lines of
|
|
* this program 'bleed' onto the executed commands. Rather than use the
|
|
* reset_shell_mode() and reset_prog_mode() functions, we could invoke endwin()
|
|
* and refresh(), but that does not work any better.
|
|
*/
|
|
#include <test.priv.h>
|
|
|
|
#if HAVE_FILTER
|
|
|
|
#include <time.h>
|
|
|
|
static int
|
|
show_prompt(int underline, bool clocked)
|
|
{
|
|
int limit = COLS;
|
|
|
|
move(0, 0);
|
|
attrset(A_NORMAL);
|
|
clrtoeol();
|
|
attrset(A_BOLD);
|
|
addstr("Command: ");
|
|
|
|
limit -= getcurx(stdscr);
|
|
|
|
if (clocked) {
|
|
if (limit >= 3) {
|
|
time_t now = time((time_t *) 0);
|
|
struct tm *my = localtime(&now);
|
|
char buffer[80];
|
|
int skip, y, x;
|
|
int margin;
|
|
|
|
_nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer)) "%02d:%02d:%02d",
|
|
my->tm_hour,
|
|
my->tm_min,
|
|
my->tm_sec);
|
|
|
|
if (limit > 9) {
|
|
skip = 0;
|
|
} else if (limit > 6) {
|
|
skip = 3;
|
|
} else {
|
|
skip = 6;
|
|
}
|
|
/*
|
|
* Write the clock message on the right-margin so we can show the
|
|
* results of resizing the screen.
|
|
*/
|
|
getyx(stdscr, y, x);
|
|
margin = (int) strlen(buffer) - skip;
|
|
limit -= margin;
|
|
move(0, COLS - margin);
|
|
addstr(buffer);
|
|
move(y, x);
|
|
}
|
|
}
|
|
attron(underline);
|
|
return limit;
|
|
}
|
|
|
|
static int
|
|
new_command(char *buffer, int length, int underline, bool clocked, bool polled)
|
|
{
|
|
int code = OK;
|
|
|
|
if (polled) {
|
|
bool done = FALSE;
|
|
bool first = TRUE;
|
|
int y = 0, x = 0;
|
|
int n;
|
|
int mark = 0;
|
|
int used = 0;
|
|
const int gap = 2;
|
|
|
|
timeout(20); /* no one types 50CPS... */
|
|
while (!done) {
|
|
int limit;
|
|
int ch = getch();
|
|
|
|
buffer[used] = '\0';
|
|
|
|
limit = show_prompt(underline, clocked);
|
|
if (first) {
|
|
getyx(stdscr, y, x);
|
|
first = FALSE;
|
|
} else {
|
|
int left = 0;
|
|
|
|
/*
|
|
* if the screen is too narrow to show the whole buffer,
|
|
* shift the editing point left/right as needed.
|
|
*/
|
|
move(y, x);
|
|
if ((used + gap) > limit) {
|
|
while ((mark - left + gap) > limit) {
|
|
left += limit / 2;
|
|
}
|
|
}
|
|
printw("%.*s", limit, buffer + left);
|
|
move(y, x + mark - left);
|
|
}
|
|
|
|
switch (ch) {
|
|
case ERR:
|
|
continue;
|
|
case '\004':
|
|
code = ERR;
|
|
done = TRUE;
|
|
break;
|
|
case KEY_ENTER:
|
|
case '\n':
|
|
done = TRUE;
|
|
break;
|
|
case KEY_BACKSPACE:
|
|
case '\b':
|
|
if (used) {
|
|
if (mark < used) {
|
|
/* getnstr does not do this */
|
|
if (mark > 0) {
|
|
--mark;
|
|
for (n = mark; n < used; ++n) {
|
|
buffer[n] = buffer[n + 1];
|
|
}
|
|
} else {
|
|
flash();
|
|
}
|
|
} else {
|
|
/* getnstr does this */
|
|
mark = --used;
|
|
buffer[used] = '\0';
|
|
}
|
|
} else {
|
|
flash();
|
|
}
|
|
break;
|
|
/*
|
|
* Unlike getnstr, this function can move the cursor into the
|
|
* middle of the buffer and insert/delete at that point.
|
|
*/
|
|
case KEY_HOME:
|
|
mark = 0;
|
|
break;
|
|
case KEY_END:
|
|
mark = used;
|
|
break;
|
|
case KEY_LEFT:
|
|
if (mark > 0) {
|
|
mark--;
|
|
} else {
|
|
flash();
|
|
}
|
|
break;
|
|
case KEY_RIGHT:
|
|
if (mark < used) {
|
|
mark++;
|
|
} else {
|
|
flash();
|
|
}
|
|
break;
|
|
#ifdef KEY_EVENT
|
|
case KEY_EVENT:
|
|
continue;
|
|
#endif
|
|
#ifdef KEY_RESIZE
|
|
case KEY_RESIZE:
|
|
/*
|
|
* Unlike getnstr, this function "knows" what the whole screen
|
|
* is supposed to look like, and can handle resize events.
|
|
*/
|
|
continue;
|
|
#endif
|
|
case '\t':
|
|
ch = ' ';
|
|
/* FALLTHRU */
|
|
default:
|
|
if (ch >= KEY_MIN) {
|
|
flash();
|
|
continue;
|
|
}
|
|
if (mark < used) {
|
|
/* getnstr does not do this... */
|
|
for (n = used + 1; n > mark; --n) {
|
|
buffer[n] = buffer[n - 1];
|
|
}
|
|
buffer[mark] = (char) ch;
|
|
used++;
|
|
mark++;
|
|
} else {
|
|
/* getnstr does this part */
|
|
buffer[used] = (char) ch;
|
|
mark = ++used;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
show_prompt(underline, clocked);
|
|
|
|
code = getnstr(buffer, length);
|
|
/*
|
|
* If this returns anything except ERR/OK, it would be one of ncurses's
|
|
* extensions. Fill the buffer with something harmless that the shell
|
|
* will execute as a comment.
|
|
*/
|
|
#ifdef KEY_EVENT
|
|
if (code == KEY_EVENT)
|
|
_nc_STRCPY(buffer, "# event!", length);
|
|
#endif
|
|
#ifdef KEY_RESIZE
|
|
if (code == KEY_RESIZE) {
|
|
_nc_STRCPY(buffer, "# resize!", length);
|
|
getch();
|
|
}
|
|
#endif
|
|
}
|
|
attroff(underline);
|
|
attroff(A_BOLD);
|
|
refresh();
|
|
|
|
return code;
|
|
}
|
|
|
|
#ifdef NCURSES_VERSION
|
|
/*
|
|
* Cancel xterm's alternate-screen mode (from dialog -TD)
|
|
*/
|
|
#define isprivate(s) ((s) != 0 && strstr(s, "\033[?") != 0)
|
|
static void
|
|
cancel_altscreen(void)
|
|
{
|
|
if (isatty(fileno(stdout))
|
|
&& key_mouse != 0 /* xterm and kindred */
|
|
&& isprivate(enter_ca_mode)
|
|
&& isprivate(exit_ca_mode)) {
|
|
/*
|
|
* initscr() or newterm() already wrote enter_ca_mode as a side effect
|
|
* of initializing the screen. It would be nice to not even do that,
|
|
* but we do not really have access to the correct copy of the
|
|
* terminfo description until those functions have been invoked.
|
|
*/
|
|
(void) refresh();
|
|
(void) putp(exit_ca_mode);
|
|
(void) fflush(stdout);
|
|
/*
|
|
* Prevent ncurses from switching "back" to the normal screen when
|
|
* exiting from this program. That would move the cursor to the
|
|
* original location saved in xterm. Normally curses sets the cursor
|
|
* position to the first line after the display, but the alternate
|
|
* screen switching is done after that point.
|
|
*
|
|
* Cancelling the strings altogether also works around the buggy
|
|
* implementation of alternate-screen in rxvt, etc., which clear more
|
|
* of the display than they should.
|
|
*/
|
|
enter_ca_mode = 0;
|
|
exit_ca_mode = 0;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
usage(void)
|
|
{
|
|
static const char *msg[] =
|
|
{
|
|
"Usage: filter [options]"
|
|
,""
|
|
,"Options:"
|
|
#ifdef NCURSES_VERSION
|
|
," -a suppress xterm alternate-screen by amending smcup/rmcup"
|
|
#endif
|
|
," -c show current time on prompt line with \"Command\""
|
|
#if HAVE_USE_DEFAULT_COLORS
|
|
," -d invoke use_default_colors"
|
|
#endif
|
|
," -i use initscr() rather than newterm()"
|
|
," -p poll for individual characters rather than using getnstr"
|
|
};
|
|
unsigned n;
|
|
for (n = 0; n < SIZEOF(msg); n++)
|
|
fprintf(stderr, "%s\n", msg[n]);
|
|
ExitProgram(EXIT_FAILURE);
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
int ch;
|
|
char buffer[80];
|
|
int underline;
|
|
#ifdef NCURSES_VERSION
|
|
bool a_option = FALSE;
|
|
#endif
|
|
bool c_option = FALSE;
|
|
#if HAVE_USE_DEFAULT_COLORS
|
|
bool d_option = FALSE;
|
|
#endif
|
|
bool i_option = FALSE;
|
|
bool p_option = FALSE;
|
|
|
|
setlocale(LC_ALL, "");
|
|
|
|
while ((ch = getopt(argc, argv, "adcip")) != -1) {
|
|
switch (ch) {
|
|
#ifdef NCURSES_VERSION
|
|
case 'a':
|
|
a_option = TRUE;
|
|
break;
|
|
#endif
|
|
case 'c':
|
|
c_option = TRUE;
|
|
break;
|
|
#if HAVE_USE_DEFAULT_COLORS
|
|
case 'd':
|
|
d_option = TRUE;
|
|
break;
|
|
#endif
|
|
case 'i':
|
|
i_option = TRUE;
|
|
break;
|
|
case 'p':
|
|
p_option = TRUE;
|
|
break;
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
|
|
printf("starting filter program using %s...\n",
|
|
i_option ? "initscr" : "newterm");
|
|
filter();
|
|
if (i_option) {
|
|
initscr();
|
|
} else {
|
|
if (newterm((char *) 0, stdout, stdin) == 0) {
|
|
fprintf(stderr, "cannot initialize terminal\n");
|
|
ExitProgram(EXIT_FAILURE);
|
|
}
|
|
}
|
|
#ifdef NCURSES_VERSION
|
|
if (a_option) {
|
|
cancel_altscreen();
|
|
}
|
|
#endif
|
|
cbreak();
|
|
keypad(stdscr, TRUE);
|
|
|
|
if (has_colors()) {
|
|
int background = COLOR_BLACK;
|
|
start_color();
|
|
#if HAVE_USE_DEFAULT_COLORS
|
|
if (d_option && (use_default_colors() != ERR))
|
|
background = -1;
|
|
#endif
|
|
init_pair(1, COLOR_CYAN, (short) background);
|
|
underline = COLOR_PAIR(1);
|
|
} else {
|
|
underline = A_UNDERLINE;
|
|
}
|
|
|
|
for (;;) {
|
|
int code = new_command(buffer, sizeof(buffer) - 1,
|
|
underline, c_option, p_option);
|
|
if (code == ERR || *buffer == '\0')
|
|
break;
|
|
reset_shell_mode();
|
|
printf("\n");
|
|
fflush(stdout);
|
|
IGNORE_RC(system(buffer));
|
|
reset_prog_mode();
|
|
touchwin(stdscr);
|
|
erase();
|
|
refresh();
|
|
}
|
|
clear();
|
|
refresh();
|
|
endwin();
|
|
ExitProgram(EXIT_SUCCESS);
|
|
}
|
|
#else
|
|
int
|
|
main(void)
|
|
{
|
|
printf("This program requires the filter function\n");
|
|
ExitProgram(EXIT_FAILURE);
|
|
}
|
|
#endif /* HAVE_FILTER */
|