ncurses 6.0 - patch 20160416
[ncurses.git] / test / filter.c
1 /****************************************************************************
2  * Copyright (c) 1998-2014,2016 Free Software Foundation, Inc.              *
3  *                                                                          *
4  * Permission is hereby granted, free of charge, to any person obtaining a  *
5  * copy of this software and associated documentation files (the            *
6  * "Software"), to deal in the Software without restriction, including      *
7  * without limitation the rights to use, copy, modify, merge, publish,      *
8  * distribute, distribute with modifications, sublicense, and/or sell       *
9  * copies of the Software, and to permit persons to whom the Software is    *
10  * furnished to do so, subject to the following conditions:                 *
11  *                                                                          *
12  * The above copyright notice and this permission notice shall be included  *
13  * in all copies or substantial portions of the Software.                   *
14  *                                                                          *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22  *                                                                          *
23  * Except as contained in this notice, the name(s) of the above copyright   *
24  * holders shall not be used in advertising or otherwise to promote the     *
25  * sale, use or other dealings in this Software without prior written       *
26  * authorization.                                                           *
27  ****************************************************************************/
28
29 /*
30  * Author:  Thomas E. Dickey 1998
31  *
32  * $Id: filter.c,v 1.24 2016/04/16 22:11:03 tom Exp $
33  *
34  * An example of the 'filter()' function in ncurses, this program prompts
35  * for commands and executes them (like a command shell).  It illustrates
36  * how ncurses can be used to implement programs that are not full-screen.
37  *
38  * Ncurses differs slightly from SVr4 curses.  The latter does not flush its
39  * state when exiting program mode, so the attributes on the command lines of
40  * this program 'bleed' onto the executed commands.  Rather than use the
41  * reset_shell_mode() and reset_prog_mode() functions, we could invoke endwin()
42  * and refresh(), but that does not work any better.
43  */
44 #include <test.priv.h>
45
46 #if HAVE_FILTER
47
48 #include <time.h>
49
50 static int
51 show_prompt(int underline, bool clocked)
52 {
53     int limit = COLS;
54
55     move(0, 0);
56     attrset(A_NORMAL);
57     clrtoeol();
58     attrset(A_BOLD);
59     addstr("Command: ");
60
61     limit -= getcurx(stdscr);
62
63     if (clocked) {
64         if (limit >= 3) {
65             time_t now = time((time_t *) 0);
66             struct tm *my = localtime(&now);
67             char buffer[80];
68             int skip, y, x;
69             int margin;
70
71             sprintf(buffer, "%02d:%02d:%02d",
72                     my->tm_hour,
73                     my->tm_min,
74                     my->tm_sec);
75
76             if (limit > 9) {
77                 skip = 0;
78             } else if (limit > 6) {
79                 skip = 3;
80             } else {
81                 skip = 6;
82             }
83             /*
84              * Write the clock message on the right-margin so we can show the
85              * results of resizing the screen.
86              */
87             getyx(stdscr, y, x);
88             margin = (int) strlen(buffer) - skip;
89             limit -= margin;
90             move(0, COLS - margin);
91             addstr(buffer);
92             move(y, x);
93         }
94     }
95     attron(underline);
96     return limit;
97 }
98
99 static int
100 new_command(char *buffer, int length, int underline, bool clocked, bool polled)
101 {
102     int code = OK;
103     int limit;
104
105     if (polled) {
106         bool done = FALSE;
107         bool first = TRUE;
108         int y, x;
109         int n;
110         int mark = 0;
111         int used = 0;
112         const int gap = 2;
113
114         timeout(20);            /* no one types 50CPS... */
115         while (!done) {
116             int ch = getch();
117
118             buffer[used] = '\0';
119
120             limit = show_prompt(underline, clocked);
121             if (first) {
122                 getyx(stdscr, y, x);
123                 first = FALSE;
124             } else {
125                 int left = 0;
126
127                 /*
128                  * if the screen is too narrow to show the whole buffer,
129                  * shift the editing point left/right as needed.
130                  */
131                 move(y, x);
132                 if ((used + gap) > limit) {
133                     while ((mark - left + gap) > limit) {
134                         left += limit / 2;
135                     }
136                 }
137                 printw("%.*s", limit, buffer + left);
138                 move(y, x + mark - left);
139             }
140
141             switch (ch) {
142             case ERR:
143                 continue;
144             case '\004':
145                 code = ERR;
146                 done = TRUE;
147                 break;
148             case KEY_ENTER:
149             case '\n':
150                 done = TRUE;
151                 break;
152             case KEY_BACKSPACE:
153             case '\b':
154                 if (used) {
155                     if (mark < used) {
156                         /* getnstr does not do this */
157                         if (mark > 0) {
158                             --mark;
159                             for (n = mark; n < used; ++n) {
160                                 buffer[n] = buffer[n + 1];
161                             }
162                         } else {
163                             flash();
164                         }
165                     } else {
166                         /* getnstr does this */
167                         mark = --used;
168                         buffer[used] = '\0';
169                     }
170                 } else {
171                     flash();
172                 }
173                 break;
174                 /*
175                  * Unlike getnstr, this function can move the cursor into the
176                  * middle of the buffer and insert/delete at that point.
177                  */
178             case KEY_HOME:
179                 mark = 0;
180                 break;
181             case KEY_END:
182                 mark = used;
183                 break;
184             case KEY_LEFT:
185                 if (mark > 0) {
186                     mark--;
187                 } else {
188                     flash();
189                 }
190                 break;
191             case KEY_RIGHT:
192                 if (mark < used) {
193                     mark++;
194                 } else {
195                     flash();
196                 }
197                 break;
198 #ifdef KEY_EVENT
199             case KEY_EVENT:
200                 continue;
201 #endif
202 #ifdef KEY_RESIZE
203             case KEY_RESIZE:
204                 /*
205                  * Unlike getnstr, this function "knows" what the whole screen
206                  * is supposed to look like, and can handle resize events.
207                  */
208                 continue;
209 #endif
210             case '\t':
211                 ch = ' ';
212                 /* FALLTHRU */
213             default:
214                 if (ch >= KEY_MIN) {
215                     flash();
216                     continue;
217                 }
218                 if (mark < used) {
219                     /* getnstr does not do this... */
220                     for (n = used + 1; n > mark; --n) {
221                         buffer[n] = buffer[n - 1];
222                     }
223                     buffer[mark] = (char) ch;
224                     used++;
225                     mark++;
226                 } else {
227                     /* getnstr does this part */
228                     buffer[used] = (char) ch;
229                     mark = ++used;
230                 }
231                 break;
232             }
233         }
234     } else {
235         show_prompt(underline, clocked);
236
237         code = getnstr(buffer, length);
238         /*
239          * If this returns anything except ERR/OK, it would be one of ncurses's
240          * extensions.  Fill the buffer with something harmless that the shell
241          * will execute as a comment.
242          */
243 #ifdef KEY_EVENT
244         if (code == KEY_EVENT)
245             strcpy(buffer, "# event!");
246 #endif
247 #ifdef KEY_RESIZE
248         if (code == KEY_RESIZE) {
249             strcpy(buffer, "# resize!");
250             getch();
251         }
252 #endif
253     }
254     attroff(underline);
255     attroff(A_BOLD);
256     printw("\n");
257
258     return code;
259 }
260
261 static void
262 usage(void)
263 {
264     static const char *msg[] =
265     {
266         "Usage: filter [options]"
267         ,""
268         ,"Options:"
269         ,"  -c   show current time on prompt line with \"Command\""
270         ,"  -i   use initscr() rather than newterm()"
271         ,"  -p   poll for individual characters rather than using getnstr"
272     };
273     unsigned n;
274     for (n = 0; n < SIZEOF(msg); n++)
275         fprintf(stderr, "%s\n", msg[n]);
276     ExitProgram(EXIT_FAILURE);
277 }
278
279 int
280 main(int argc, char *argv[])
281 {
282     int ch;
283     char buffer[80];
284     int underline;
285     bool c_option = FALSE;
286     bool i_option = FALSE;
287     bool p_option = FALSE;
288
289     setlocale(LC_ALL, "");
290
291     while ((ch = getopt(argc, argv, "cip")) != -1) {
292         switch (ch) {
293         case 'c':
294             c_option = TRUE;
295             break;
296         case 'i':
297             i_option = TRUE;
298             break;
299         case 'p':
300             p_option = TRUE;
301             break;
302         default:
303             usage();
304         }
305     }
306
307     printf("starting filter program using %s...\n",
308            i_option ? "initscr" : "newterm");
309     filter();
310     if (i_option) {
311         initscr();
312     } else {
313         (void) newterm((char *) 0, stdout, stdin);
314     }
315     cbreak();
316     keypad(stdscr, TRUE);
317
318     if (has_colors()) {
319         int background = COLOR_BLACK;
320         start_color();
321 #if HAVE_USE_DEFAULT_COLORS
322         if (use_default_colors() != ERR)
323             background = -1;
324 #endif
325         init_pair(1, COLOR_CYAN, (short) background);
326         underline = COLOR_PAIR(1);
327     } else {
328         underline = A_UNDERLINE;
329     }
330
331     for (;;) {
332         int code = new_command(buffer, sizeof(buffer) - 1,
333                                underline, c_option, p_option);
334         if (code == ERR || *buffer == '\0')
335             break;
336         reset_shell_mode();
337         printf("\n");
338         fflush(stdout);
339         IGNORE_RC(system(buffer));
340         reset_prog_mode();
341         touchwin(stdscr);
342         erase();
343         refresh();
344     }
345     printw("done");
346     refresh();
347     endwin();
348     ExitProgram(EXIT_SUCCESS);
349 }
350 #else
351 int
352 main(void)
353 {
354     printf("This program requires the filter function\n");
355     ExitProgram(EXIT_FAILURE);
356 }
357 #endif /* HAVE_FILTER */