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 }