]> ncurses.scripts.mit.edu Git - ncurses.git/blob - test/gdc.c
ncurses 6.4 - patch 20230128
[ncurses.git] / test / gdc.c
1 /****************************************************************************
2  * Copyright 2019-2020,2022 Thomas E. Dickey                                *
3  * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
4  *                                                                          *
5  * Permission is hereby granted, free of charge, to any person obtaining a  *
6  * copy of this software and associated documentation files (the            *
7  * "Software"), to deal in the Software without restriction, including      *
8  * without limitation the rights to use, copy, modify, merge, publish,      *
9  * distribute, distribute with modifications, sublicense, and/or sell       *
10  * copies of the Software, and to permit persons to whom the Software is    *
11  * furnished to do so, subject to the following conditions:                 *
12  *                                                                          *
13  * The above copyright notice and this permission notice shall be included  *
14  * in all copies or substantial portions of the Software.                   *
15  *                                                                          *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
23  *                                                                          *
24  * Except as contained in this notice, the name(s) of the above copyright   *
25  * holders shall not be used in advertising or otherwise to promote the     *
26  * sale, use or other dealings in this Software without prior written       *
27  * authorization.                                                           *
28  ****************************************************************************/
29 /*
30  * Grand digital clock for curses compatible terminals
31  * Usage: gdc [-s] [-t hh:mm:ss] [n] -- run for n seconds (default infinity)
32  * Flags: -s: scroll
33  *
34  * modified 10-18-89 for curses (jrl)
35  * 10-18-89 added signal handling
36  *
37  * $Id: gdc.c,v 1.57 2022/12/04 00:40:11 tom Exp $
38  */
39
40 #include <test.priv.h>
41
42 #include <time.h>
43
44 #define YBASE   10
45 #define XBASE   10
46 #define XLENGTH 54
47 #define YDEPTH  5
48
49 #define PAIR_DIGITS 1
50 #define PAIR_OTHERS 2
51 #define PAIR_FRAMES 3
52
53 static short disp[11] =
54 {
55     075557, 011111, 071747, 071717, 055711,
56     074717, 074757, 071111, 075757, 075717, 002020
57 };
58 static long older[6], next[6], newer[6], mask;
59
60 static int sigtermed = 0;
61 static bool redirected = FALSE;
62 static bool hascolor = FALSE;
63
64 static void
65 sighndl(int signo)
66 {
67     signal(signo, sighndl);
68     sigtermed = signo;
69     if (redirected) {
70         stop_curses();
71         ExitProgram(EXIT_FAILURE);
72     }
73 }
74
75 static void
76 check_term(void)
77 {
78     if (sigtermed) {
79         (void) standend();
80         stop_curses();
81         fprintf(stderr, "gdc terminated by signal %d\n", sigtermed);
82         ExitProgram(EXIT_FAILURE);
83     }
84 }
85
86 static void
87 drawbox(bool scrolling)
88 {
89     chtype bottom[XLENGTH + 1];
90
91     if (hascolor)
92         (void) attrset(AttrArg(COLOR_PAIR(PAIR_FRAMES), 0));
93
94     MvAddCh(YBASE - 1, XBASE - 1, ACS_ULCORNER);
95     hline(ACS_HLINE, XLENGTH);
96     MvAddCh(YBASE - 1, XBASE + XLENGTH, ACS_URCORNER);
97
98     MvAddCh(YBASE + YDEPTH, XBASE - 1, ACS_LLCORNER);
99     if ((mvinchnstr(YBASE + YDEPTH, XBASE, bottom, XLENGTH)) != ERR) {
100         int n;
101         for (n = 0; n < XLENGTH; n++) {
102             if (!scrolling)
103                 bottom[n] &= ~A_COLOR;
104             bottom[n] = ACS_HLINE | (bottom[n] & (A_ATTRIBUTES | A_COLOR));
105         }
106         (void) mvaddchnstr(YBASE + YDEPTH, XBASE, bottom, XLENGTH);
107     }
108     MvAddCh(YBASE + YDEPTH, XBASE + XLENGTH, ACS_LRCORNER);
109
110     move(YBASE, XBASE - 1);
111     vline(ACS_VLINE, YDEPTH);
112
113     move(YBASE, XBASE + XLENGTH);
114     vline(ACS_VLINE, YDEPTH);
115
116     if (hascolor)
117         (void) attrset(AttrArg(COLOR_PAIR(PAIR_OTHERS), 0));
118 }
119
120 static void
121 standt(int on)
122 {
123     if (on) {
124         if (hascolor) {
125             attron(COLOR_PAIR(PAIR_DIGITS));
126         } else {
127             attron(A_STANDOUT);
128         }
129     } else {
130         if (hascolor) {
131             attron(COLOR_PAIR(PAIR_OTHERS));
132         } else {
133             attroff(A_STANDOUT);
134         }
135     }
136 }
137
138 static void
139 set(int t, int n)
140 {
141     int i, m;
142
143     m = 7 << n;
144     for (i = 0; i < 5; i++) {
145         next[i] |= ((disp[t] >> ((4 - i) * 3)) & 07) << n;
146         mask |= (next[i] ^ older[i]) & m;
147     }
148     if (mask & m)
149         mask |= m;
150 }
151
152 static void
153 usage(int ok)
154 {
155     static const char *msg[] =
156     {
157         "Usage: gdc [options] [count]"
158         ,""
159         ,USAGE_COMMON
160         ,"Options:"
161 #if HAVE_USE_DEFAULT_COLORS
162         ," -d       invoke use_default_colors"
163 #endif
164         ," -n       redirect input to /dev/null"
165         ," -s       scroll each number into place, rather than flipping"
166         ," -t TIME  specify starting time as hh:mm:ss (default is ``now'')"
167         ,""
168         ,"If you specify a count, gdc runs for that number of seconds"
169     };
170     unsigned j;
171     for (j = 0; j < SIZEOF(msg); j++)
172         fprintf(stderr, "%s\n", msg[j]);
173     ExitProgram(ok ? EXIT_SUCCESS : EXIT_FAILURE);
174 }
175
176 static time_t
177 parse_time(const char *value)
178 {
179     int hh, mm, ss;
180     int check;
181     time_t result;
182     char c;
183     struct tm *tm;
184
185     if (sscanf(value, "%d:%d:%d%c", &hh, &mm, &ss, &c) != 3) {
186         if (sscanf(value, "%02d%02d%02d%c", &hh, &mm, &ss, &c) != 3) {
187             usage(FALSE);
188         }
189     }
190
191     if ((hh < 0) || (hh >= 24) ||
192         (mm < 0) || (mm >= 60) ||
193         (ss < 0) || (ss >= 60)) {
194         usage(FALSE);
195     }
196
197     /* adjust so that the localtime in the main loop will give usable time */
198     result = (hh * 3600) + ((mm * 60) + ss);
199     for (check = 0; check < 24; ++check) {
200         tm = localtime(&result);
201         if (tm->tm_hour == hh)
202             break;
203         result += 3600;
204     }
205
206     if (tm->tm_hour != hh) {
207         fprintf(stderr, "Cannot find local time for %s!\n", value);
208         usage(FALSE);
209     }
210     return result;
211 }
212 /* *INDENT-OFF* */
213 VERSION_COMMON()
214 /* *INDENT-ON* */
215
216 int
217 main(int argc, char *argv[])
218 {
219     time_t now;
220     struct tm *tm;
221     long t, a;
222     int i, j, s, k, ch;
223     int count = 0;
224     FILE *ofp = stdout;
225     FILE *ifp = stdin;
226     bool smooth = FALSE;
227     bool stages = FALSE;
228     time_t starts = 0;
229 #if HAVE_USE_DEFAULT_COLORS
230     bool d_option = FALSE;
231 #endif
232
233     setlocale(LC_ALL, "");
234
235     while ((ch = getopt(argc, argv, OPTS_COMMON "dnst:")) != -1) {
236         switch (ch) {
237 #if HAVE_USE_DEFAULT_COLORS
238         case 'd':
239             d_option = TRUE;
240             break;
241 #endif
242         case 'n':
243             ifp = fopen("/dev/null", "r");
244             redirected = TRUE;
245             break;
246         case 's':
247             smooth = TRUE;
248             break;
249         case 't':
250             starts = parse_time(optarg);
251             break;
252         case OPTS_VERSION:
253             show_version(argv);
254             ExitProgram(EXIT_SUCCESS);
255         default:
256             usage(ch == OPTS_USAGE);
257             /* NOTREACHED */
258         }
259     }
260     if (optind < argc) {
261         count = atoi(argv[optind++]);
262         assert(count >= 0);
263         if (optind < argc)
264             usage(FALSE);
265     }
266
267     InitAndCatch({
268         if (redirected) {
269             char *name = getenv("TERM");
270             if (name == 0
271                 || newterm(name, ofp, ifp) == 0) {
272                 fprintf(stderr, "cannot open terminal\n");
273                 ExitProgram(EXIT_FAILURE);
274             }
275         } else {
276             initscr();
277         }
278     }
279     ,sighndl);
280
281     cbreak();
282     noecho();
283     nodelay(stdscr, 1);
284     curs_set(0);
285
286     hascolor = has_colors();
287
288     if (hascolor) {
289         short bg = COLOR_BLACK;
290         start_color();
291 #if HAVE_USE_DEFAULT_COLORS
292         if (d_option && (use_default_colors() == OK))
293             bg = -1;
294 #endif
295         init_pair(PAIR_DIGITS, COLOR_BLACK, COLOR_RED);
296         init_pair(PAIR_OTHERS, COLOR_RED, bg);
297         init_pair(PAIR_FRAMES, COLOR_WHITE, bg);
298         (void) attrset(AttrArg(COLOR_PAIR(PAIR_OTHERS), 0));
299     }
300
301   restart:
302     for (j = 0; j < 5; j++)
303         older[j] = newer[j] = next[j] = 0;
304
305     clear();
306     drawbox(FALSE);
307
308     do {
309         char buf[40];
310
311         if (starts != 0) {
312             now = ++starts;
313         } else {
314             time(&now);
315         }
316         tm = localtime(&now);
317
318         mask = 0;
319         set(tm->tm_sec % 10, 0);
320         set(tm->tm_sec / 10, 4);
321         set(tm->tm_min % 10, 10);
322         set(tm->tm_min / 10, 14);
323         set(tm->tm_hour % 10, 20);
324         set(tm->tm_hour / 10, 24);
325         set(10, 7);
326         set(10, 17);
327
328         for (k = 0; k < 6; k++) {
329             if (smooth) {
330                 for (i = 0; i < 5; i++)
331                     newer[i] = (newer[i] & ~mask) | (newer[i + 1] & mask);
332                 newer[5] = (newer[5] & ~mask) | (next[k] & mask);
333             } else {
334                 newer[k] = (newer[k] & ~mask) | (next[k] & mask);
335             }
336             next[k] = 0;
337             for (s = 1; s >= 0; s--) {
338                 standt(s);
339                 for (i = 0; i < 6; i++) {
340                     if ((a = (newer[i] ^ older[i]) & (s ? newer : older)[i])
341                         != 0) {
342                         for (j = 0, t = 1 << 26; t; t >>= 1, j++) {
343                             if (a & t) {
344                                 if (!(a & (t << 1))) {
345                                     move(YBASE + i, XBASE + 2 * j);
346                                 }
347                                 addstr("  ");
348                             }
349                         }
350                     }
351                     if (!s) {
352                         older[i] = newer[i];
353                     }
354                 }
355                 if (!s) {
356                     if (smooth)
357                         drawbox(TRUE);
358                     refresh();
359                     /*
360                      * If we're scrolling, space out the refreshes to fake
361                      * movement.  That's 7 frames, or 6 intervals, which would
362                      * be 166 msec if we spread it out over a second.  It looks
363                      * better (but will work on a slow terminal, e.g., less
364                      * than 9600bd) to squeeze that into a half-second, and use
365                      * half of 170 msec to ensure that the program doesn't eat
366                      * a lot of time when asking what time it is, at the top of
367                      * this loop -T.Dickey
368                      */
369                     if (smooth)
370                         napms(85);
371                     if (stages) {
372                         stages = FALSE;
373                         switch (wgetch(stdscr)) {
374                         case 'q':
375                             count = 1;
376                             break;
377                         case 'S':
378                             stages = TRUE;
379                             /* FALLTHRU */
380                         case 's':
381                             nodelay(stdscr, FALSE);
382                             break;
383                         case ' ':
384                             nodelay(stdscr, TRUE);
385                             break;
386 #ifdef KEY_RESIZE
387                         case KEY_RESIZE:
388 #endif
389                         case '?':
390                             goto restart;
391                         case ERR:
392                             check_term();
393                             /* FALLTHRU */
394                         default:
395                             continue;
396                         }
397                     }
398                 }
399             }
400         }
401
402         /* this depends on the detailed format of ctime(3) */
403         _nc_STRNCPY(buf, ctime(&now), (size_t) 30);
404         {
405             char *d2 = buf + 10;
406             char *s2 = buf + 19;
407             while ((*d2++ = *s2++) != '\0') ;
408         }
409         MvAddStr(16, 30, buf);
410
411         move(6, 0);
412         drawbox(FALSE);
413         refresh();
414
415         /*
416          * If we're not smooth-scrolling, wait 1000 msec (1 sec).  Use napms()
417          * rather than sleep() because the latter does odd things on some
418          * systems, e.g., suspending output as well.
419          */
420         if (smooth)
421             napms(500);
422         else
423             napms(1000);
424
425         /*
426          * This is a safe way to check if we're interrupted - making the signal
427          * handler set a flag that we can check.  Since we're running
428          * nodelay(), the wgetch() call returns immediately, and in particular
429          * will return an error if interrupted.  This works only if we can
430          * read from the input, of course.
431          */
432         stages = FALSE;
433         switch (wgetch(stdscr)) {
434         case 'q':
435             count = 1;
436             break;
437         case 'S':
438             stages = TRUE;
439             /* FALLTHRU */
440         case 's':
441             nodelay(stdscr, FALSE);
442             break;
443         case ' ':
444             nodelay(stdscr, TRUE);
445             break;
446 #ifdef KEY_RESIZE
447         case KEY_RESIZE:
448 #endif
449         case '?':
450             goto restart;
451         case ERR:
452             check_term();
453             /* FALLTHRU */
454         default:
455             continue;
456         }
457     } while (--count);
458     (void) standend();
459     stop_curses();
460     ExitProgram(EXIT_SUCCESS);
461 }