ncurses 5.6 - patch 20070602
[ncurses.git] / test / view.c
1 /****************************************************************************
2  * Copyright (c) 1998-2005,2006 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  * view.c -- a silly little viewer program
30  *
31  * written by Eric S. Raymond <esr@snark.thyrsus.com> December 1994
32  * to test the scrolling code in ncurses.
33  *
34  * modified by Thomas Dickey <dickey@clark.net> July 1995 to demonstrate
35  * the use of 'resizeterm()', and May 2000 to illustrate wide-character
36  * handling.
37  *
38  * Takes a filename argument.  It's a simple file-viewer with various
39  * scroll-up and scroll-down commands.
40  *
41  * n    -- scroll one line forward
42  * p    -- scroll one line back
43  *
44  * Either command accepts a numeric prefix interpreted as a repeat count.
45  * Thus, typing `5n' should scroll forward 5 lines in the file.
46  *
47  * The way you can tell this is working OK is that, in the trace file,
48  * there should be one scroll operation plus a small number of line
49  * updates, as opposed to a whole-page update.  This means the physical
50  * scroll operation worked, and the refresh() code only had to do a
51  * partial repaint.
52  *
53  * $Id: view.c,v 1.64 2006/05/20 15:37:03 tom Exp $
54  */
55
56 #include <test.priv.h>
57
58 #include <time.h>
59
60 #undef CTRL                     /* conflict on AIX 5.2 with <sys/ioctl.h> */
61
62 #if HAVE_TERMIOS_H
63 # include <termios.h>
64 #else
65 # include <sgtty.h>
66 #endif
67
68 #if !defined(sun) || !HAVE_TERMIOS_H
69 # if HAVE_SYS_IOCTL_H
70 #  include <sys/ioctl.h>
71 # endif
72 #endif
73
74 #define my_pair 1
75
76 /* This is needed to compile 'struct winsize' */
77 #if NEED_PTEM_H
78 #include <sys/stream.h>
79 #include <sys/ptem.h>
80 #endif
81
82 static RETSIGTYPE finish(int sig) GCC_NORETURN;
83 static void show_all(const char *tag);
84
85 #if defined(SIGWINCH) && defined(TIOCGWINSZ) && HAVE_RESIZE_TERM
86 #define CAN_RESIZE 1
87 #else
88 #define CAN_RESIZE 0
89 #endif
90
91 #if CAN_RESIZE
92 static RETSIGTYPE adjust(int sig);
93 static int interrupted;
94 #endif
95
96 static bool waiting = FALSE;
97 static int shift = 0;
98 static bool try_color = FALSE;
99
100 static char *fname;
101 static NCURSES_CH_T **vec_lines;
102 static NCURSES_CH_T **lptr;
103 static int num_lines;
104
105 static void
106 usage(void)
107 {
108     static const char *msg[] =
109     {
110         "Usage: view [options] file"
111         ,""
112         ,"Options:"
113         ," -c       use color if terminal supports it"
114         ," -i       ignore INT, QUIT, TERM signals"
115         ," -n NUM   specify maximum number of lines (default 1000)"
116 #if defined(KEY_RESIZE)
117         ," -r       use old-style sigwinch handler rather than KEY_RESIZE"
118 #endif
119 #ifdef TRACE
120         ," -t       trace screen updates"
121         ," -T NUM   specify trace mask"
122 #endif
123     };
124     size_t n;
125     for (n = 0; n < SIZEOF(msg); n++)
126         fprintf(stderr, "%s\n", msg[n]);
127     ExitProgram(EXIT_FAILURE);
128 }
129
130 static int
131 ch_len(NCURSES_CH_T * src)
132 {
133     int result = 0;
134 #if USE_WIDEC_SUPPORT
135 #endif
136
137 #if USE_WIDEC_SUPPORT
138     while (getcchar(src++, NULL, NULL, NULL, NULL) > 0)
139         result++;
140 #else
141     while (*src++)
142         result++;
143 #endif
144     return result;
145 }
146
147 /*
148  * Allocate a string into an array of chtype's.  If UTF-8 mode is
149  * active, translate the string accordingly.
150  */
151 static NCURSES_CH_T *
152 ch_dup(char *src)
153 {
154     unsigned len = strlen(src);
155     NCURSES_CH_T *dst = typeMalloc(NCURSES_CH_T, len + 1);
156     unsigned j, k;
157 #if USE_WIDEC_SUPPORT
158     wchar_t wstr[CCHARW_MAX + 1];
159     wchar_t wch;
160     int l = 0;
161     mbstate_t state;
162     size_t rc;
163     int width;
164 #endif
165
166 #if USE_WIDEC_SUPPORT
167     memset(&state, 0, sizeof(state));
168 #endif
169     for (j = k = 0; j < len; j++) {
170 #if USE_WIDEC_SUPPORT
171         rc = mbrtowc(&wch, src + j, len - j, &state);
172         if (rc == (size_t) -1 || rc == (size_t) -2)
173             break;
174         j += rc - 1;
175         if ((width = wcwidth(wch)) < 0)
176             break;
177         if ((width > 0 && l > 0) || l == CCHARW_MAX) {
178             wstr[l] = L'\0';
179             l = 0;
180             if (setcchar(dst + k, wstr, 0, 0, NULL) != OK)
181                 break;
182             ++k;
183         }
184         if (width == 0 && l == 0)
185             wstr[l++] = L' ';
186         wstr[l++] = wch;
187 #else
188         dst[k++] = src[j];
189 #endif
190     }
191 #if USE_WIDEC_SUPPORT
192     if (l > 0) {
193         wstr[l] = L'\0';
194         if (setcchar(dst + k, wstr, 0, 0, NULL) == OK)
195             ++k;
196     }
197     wstr[0] = L'\0';
198     setcchar(dst + k, wstr, 0, 0, NULL);
199 #else
200     dst[k] = 0;
201 #endif
202     return dst;
203 }
204
205 int
206 main(int argc, char *argv[])
207 {
208     int MAXLINES = 1000;
209     FILE *fp;
210     char buf[BUFSIZ];
211     int i;
212     int my_delay = 0;
213     NCURSES_CH_T **olptr;
214     int value = 0;
215     bool done = FALSE;
216     bool got_number = FALSE;
217 #if CAN_RESIZE
218     bool nonposix_resize = FALSE;
219 #endif
220     const char *my_label = "Input";
221
222     setlocale(LC_ALL, "");
223
224 #ifndef NCURSES_VERSION
225     /*
226      * We know ncurses will catch SIGINT if we don't establish our own handler.
227      * Other versions of curses may/may not catch it.
228      */
229     (void) signal(SIGINT, finish);      /* arrange interrupts to terminate */
230 #endif
231
232     while ((i = getopt(argc, argv, "cin:rtT:")) != EOF) {
233         switch (i) {
234         case 'c':
235             try_color = TRUE;
236             break;
237         case 'i':
238             CATCHALL(SIG_IGN);
239             break;
240         case 'n':
241             if ((MAXLINES = atoi(optarg)) < 1)
242                 usage();
243             break;
244 #if CAN_RESIZE
245         case 'r':
246             nonposix_resize = TRUE;
247             break;
248 #endif
249 #ifdef TRACE
250         case 'T':
251             trace((unsigned) atoi(optarg));
252             break;
253         case 't':
254             trace(TRACE_CALLS);
255             break;
256 #endif
257         default:
258             usage();
259         }
260     }
261     if (optind + 1 != argc)
262         usage();
263
264     if ((vec_lines = typeMalloc(NCURSES_CH_T *, MAXLINES + 2)) == 0)
265         usage();
266
267     fname = argv[optind];
268     if ((fp = fopen(fname, "r")) == 0) {
269         perror(fname);
270         ExitProgram(EXIT_FAILURE);
271     }
272 #if CAN_RESIZE
273     if (nonposix_resize)
274         (void) signal(SIGWINCH, adjust);        /* arrange interrupts to resize */
275 #endif
276
277     /* slurp the file */
278     for (lptr = &vec_lines[0]; (lptr - vec_lines) < MAXLINES; lptr++) {
279         char temp[BUFSIZ], *s, *d;
280         int col;
281
282         if (fgets(buf, sizeof(buf), fp) == 0)
283             break;
284
285         /* convert tabs so that shift will work properly */
286         for (s = buf, d = temp, col = 0; (*d = *s) != '\0'; s++) {
287             if (*d == '\n') {
288                 *d = '\0';
289                 break;
290             } else if (*d == '\t') {
291                 col = (col | 7) + 1;
292                 while ((d - temp) != col)
293                     *d++ = ' ';
294             } else
295 #if USE_WIDEC_SUPPORT
296                 col++, d++;
297 #else
298             if (isprint(UChar(*d))) {
299                 col++;
300                 d++;
301             } else {
302                 sprintf(d, "\\%03o", UChar(*s));
303                 d += strlen(d);
304                 col = (d - temp);
305             }
306 #endif
307         }
308         *lptr = ch_dup(temp);
309     }
310     (void) fclose(fp);
311     num_lines = lptr - vec_lines;
312
313     (void) initscr();           /* initialize the curses library */
314     keypad(stdscr, TRUE);       /* enable keyboard mapping */
315     (void) nonl();              /* tell curses not to do NL->CR/NL on output */
316     (void) cbreak();            /* take input chars one at a time, no wait for \n */
317     (void) noecho();            /* don't echo input */
318     nodelay(stdscr, TRUE);
319     idlok(stdscr, TRUE);        /* allow use of insert/delete line */
320
321     if (try_color) {
322         if (has_colors()) {
323             start_color();
324             init_pair(my_pair, COLOR_WHITE, COLOR_BLUE);
325             bkgd(COLOR_PAIR(my_pair));
326         } else {
327             try_color = FALSE;
328         }
329     }
330
331     lptr = vec_lines;
332     while (!done) {
333         int n, c;
334
335         if (!got_number)
336             show_all(my_label);
337
338         n = 0;
339         for (;;) {
340 #if CAN_RESIZE
341             if (interrupted) {
342                 adjust(0);
343                 my_label = "interrupt";
344             }
345 #endif
346             waiting = TRUE;
347             c = getch();
348             waiting = FALSE;
349             if ((c < 127) && isdigit(c)) {
350                 if (!got_number) {
351                     mvprintw(0, 0, "Count: ");
352                     clrtoeol();
353                 }
354                 addch(UChar(c));
355                 value = 10 * value + (c - '0');
356                 got_number = TRUE;
357             } else
358                 break;
359         }
360         if (got_number && value) {
361             n = value;
362         } else {
363             n = 1;
364         }
365
366         if (c != ERR)
367             my_label = keyname(c);
368         switch (c) {
369         case KEY_DOWN:
370         case 'n':
371             olptr = lptr;
372             for (i = 0; i < n; i++)
373                 if ((lptr - vec_lines) < (num_lines - LINES + 1))
374                     lptr++;
375                 else
376                     break;
377             wscrl(stdscr, lptr - olptr);
378             break;
379
380         case KEY_UP:
381         case 'p':
382             olptr = lptr;
383             for (i = 0; i < n; i++)
384                 if (lptr > vec_lines)
385                     lptr--;
386                 else
387                     break;
388             wscrl(stdscr, lptr - olptr);
389             break;
390
391         case 'h':
392         case KEY_HOME:
393             lptr = vec_lines;
394             break;
395
396         case 'e':
397         case KEY_END:
398             if (num_lines > LINES)
399                 lptr = vec_lines + num_lines - LINES + 1;
400             else
401                 lptr = vec_lines;
402             break;
403
404         case 'r':
405         case KEY_RIGHT:
406             shift += n;
407             break;
408
409         case 'l':
410         case KEY_LEFT:
411             shift -= n;
412             if (shift < 0) {
413                 shift = 0;
414                 beep();
415             }
416             break;
417
418         case 'q':
419             done = TRUE;
420             break;
421
422 #ifdef KEY_RESIZE
423         case KEY_RESIZE:        /* ignore this; ncurses will repaint */
424             break;
425 #endif
426         case 's':
427             if (got_number) {
428                 halfdelay(my_delay = n);
429             } else {
430                 nodelay(stdscr, FALSE);
431                 my_delay = -1;
432             }
433             break;
434         case ' ':
435             nodelay(stdscr, TRUE);
436             my_delay = 0;
437             break;
438         case ERR:
439             if (!my_delay)
440                 napms(50);
441             break;
442         default:
443             beep();
444             break;
445         }
446         if (c >= KEY_MIN || (c > 0 && !isdigit(c))) {
447             got_number = FALSE;
448             value = 0;
449         }
450     }
451
452     finish(0);                  /* we're done */
453 }
454
455 static RETSIGTYPE
456 finish(int sig)
457 {
458     endwin();
459 #if NO_LEAKS
460     if (vec_lines != 0) {
461         int n;
462         for (n = 0; n < num_lines; ++n) {
463             free(vec_lines[n]);
464         }
465         free(vec_lines);
466     }
467 #endif
468     ExitProgram(sig != 0 ? EXIT_FAILURE : EXIT_SUCCESS);
469 }
470
471 #if CAN_RESIZE
472 /*
473  * This uses functions that are "unsafe", but it seems to work on SunOS and
474  * Linux.  Usually:  the "unsafe" refers to the functions that POSIX lists
475  * which may be called from a signal handler.  Those do not include buffered
476  * I/O, which is used for instance in wrefresh().  To be really portable, you
477  * should use the KEY_RESIZE return (which relies on ncurses' sigwinch
478  * handler).
479  *
480  * The 'wrefresh(curscr)' is needed to force the refresh to start from the top
481  * of the screen -- some xterms mangle the bitmap while resizing.
482  */
483 static RETSIGTYPE
484 adjust(int sig)
485 {
486     if (waiting || sig == 0) {
487         struct winsize size;
488
489         if (ioctl(fileno(stdout), TIOCGWINSZ, &size) == 0) {
490             resize_term(size.ws_row, size.ws_col);
491             wrefresh(curscr);   /* Linux needs this */
492             show_all(sig ? "SIGWINCH" : "interrupt");
493         }
494         interrupted = FALSE;
495     } else {
496         interrupted = TRUE;
497     }
498     (void) signal(SIGWINCH, adjust);    /* some systems need this */
499 }
500 #endif /* CAN_RESIZE */
501
502 static void
503 show_all(const char *tag)
504 {
505     int i;
506     char temp[BUFSIZ];
507     NCURSES_CH_T *s;
508     time_t this_time;
509
510 #if CAN_RESIZE
511     sprintf(temp, "%s (%3dx%3d) col %d ", tag, LINES, COLS, shift);
512     i = strlen(temp);
513     sprintf(temp + i, "view %.*s", (int) (sizeof(temp) - 7 - i), fname);
514 #else
515     sprintf(temp, "view %.*s", (int) sizeof(temp) - 7, fname);
516 #endif
517     move(0, 0);
518     printw("%.*s", COLS, temp);
519     clrtoeol();
520     this_time = time((time_t *) 0);
521     strcpy(temp, ctime(&this_time));
522     if ((i = strlen(temp)) != 0) {
523         temp[--i] = 0;
524         if (move(0, COLS - i - 2) != ERR)
525             printw("  %s", temp);
526     }
527
528     scrollok(stdscr, FALSE);    /* prevent screen from moving */
529     for (i = 1; i < LINES; i++) {
530         move(i, 0);
531         printw("%3ld:", (long) (lptr + i - vec_lines));
532         clrtoeol();
533         if ((s = lptr[i - 1]) != 0) {
534             int len = ch_len(s);
535             if (len > shift) {
536 #if USE_WIDEC_SUPPORT
537                 add_wchstr(s + shift);
538 #else
539                 addchstr(s + shift);
540 #endif
541             }
542 #if defined(NCURSES_VERSION) || defined(HAVE_WCHGAT)
543             if (try_color)
544                 wchgat(stdscr, -1, A_NORMAL, my_pair, NULL);
545 #endif
546         }
547     }
548     setscrreg(1, LINES - 1);
549     scrollok(stdscr, TRUE);
550     refresh();
551 }