c3571c02cb569b9171d81119839e573fdce2a4f0
[games.git] / games / grdc / grdc.c
1 /*
2  * Grand digital clock for curses compatible terminals
3  * Usage: grdc [-s] [-d msecs] [n]   -- run for n seconds (default infinity)
4  * Flags:       -s: scroll (default scroll duration 120msec)
5  *              -d msecs: specify scroll duration (implies -s)
6  *
7  * modified 10-18-89 for curses (jrl)
8  * 10-18-89 added signal handling
9  * 03-23-04 added centering, scroll delay (cap)
10  *
11  * $FreeBSD: src/games/grdc/grdc.c,v 1.8.2.1 2001/10/02 11:51:49 ru Exp $
12  * $DragonFly: src/games/grdc/grdc.c,v 1.6 2007/04/18 18:32:12 swildner Exp $
13  */
14
15 #include <err.h>
16 #include <time.h>
17 #include <signal.h>
18 #include <ncurses.h>
19 #include <stdlib.h>
20 #ifndef NONPOSIX
21 #include <unistd.h>
22 #endif
23 #include <time.h>
24
25 #define XLENGTH 58
26 #define YDEPTH  7
27
28 time_t now;
29 struct tm *tm;
30
31 short disp[11] = {
32         075557, 011111, 071747, 071717, 055711,
33         074717, 074757, 071111, 075757, 075717, 002020
34 };
35 long old[6], next[6], new[6], mask;
36
37 volatile sig_atomic_t sigtermed;
38
39 int hascolor = 0;
40 long int scroll_msecs = 120;
41 int xbase, ybase, xmax, ymax;
42
43 static void set(int, int);
44 static void standt(int);
45 static void sighndl(int);
46 static void usage(void);
47 static void draw_row(int, int);
48 static void snooze(long int);
49
50 void
51 sighndl(int signo)
52 {
53         sigtermed = signo;
54 }
55
56 int
57 main(int argc, char **argv)
58 {
59         int i, s, k;
60         int n;
61         int ch;
62         int scrol;
63         int forever;
64
65         n = scrol = 0;
66         forever = 1;
67
68         while ((ch = getopt(argc, argv, "d:s")) != -1)
69                 switch (ch) {
70                 case 'd':
71                         scroll_msecs = atol(optarg);
72                         if (scroll_msecs < 0)
73                                 errx(1, "scroll duration may not be negative");
74                         /* FALLTHROUGH */
75                 case 's':
76                         scrol = 1;
77                         break;
78                 case '?':
79                 default:
80                         usage();
81                         /* NOTREACHED */
82                 }
83         argc -= optind;
84         argv += optind;
85
86         if (argc > 1) {
87                 usage();
88                 /* NOTREACHED */
89         }
90
91         if (argc > 0) {
92                 n = atoi(*argv);
93                 forever = 0;
94         }
95
96         initscr();
97
98         getmaxyx(stdscr, ymax, xmax);
99         if (ymax < YDEPTH + 2 || xmax < XLENGTH + 4) {
100                 endwin();
101                 errx(1, "terminal too small");
102         }
103         xbase = (xmax - XLENGTH) / 2 + 2;
104         ybase = (ymax - YDEPTH) / 2 + 1;
105
106         signal(SIGINT, sighndl);
107         signal(SIGTERM, sighndl);
108         signal(SIGHUP, sighndl);
109
110         cbreak();
111         noecho();
112         curs_set(0);
113
114         hascolor = has_colors();
115
116         if (hascolor) {
117                 start_color();
118                 init_pair(1, COLOR_BLACK, COLOR_RED);
119                 init_pair(2, COLOR_RED, COLOR_BLACK);
120                 init_pair(3, COLOR_WHITE, COLOR_BLACK);
121                 attrset(COLOR_PAIR(2));
122         }
123
124         clear();
125         refresh();
126
127         if (hascolor) {
128                 attrset(COLOR_PAIR(3));
129
130                 mvaddch(ybase - 2, xbase - 3, ACS_ULCORNER);
131                 hline(ACS_HLINE, XLENGTH);
132                 mvaddch(ybase - 2, xbase - 2 + XLENGTH, ACS_URCORNER);
133
134                 mvaddch(ybase + YDEPTH - 1, xbase - 3, ACS_LLCORNER);
135                 hline(ACS_HLINE, XLENGTH);
136                 mvaddch(ybase + YDEPTH - 1, xbase - 2 + XLENGTH, ACS_LRCORNER);
137
138                 move(ybase - 1, xbase - 3);
139                 vline(ACS_VLINE, YDEPTH);
140
141                 move(ybase - 1, xbase - 2 + XLENGTH);
142                 vline(ACS_VLINE, YDEPTH);
143
144                 attrset(COLOR_PAIR(2));
145                 refresh();
146         }
147         do {
148                 mask = 0;
149                 time(&now);
150                 tm = localtime(&now);
151                 set(tm->tm_sec % 10, 0);
152                 set(tm->tm_sec / 10, 4);
153                 set(tm->tm_min % 10, 10);
154                 set(tm->tm_min / 10, 14);
155                 set(tm->tm_hour % 10, 20);
156                 set(tm->tm_hour / 10, 24);
157                 set(10, 7);
158                 set(10, 17);
159                 for(k = 0; k < 6; k++) {
160                         if (scrol) {
161                                 snooze(scroll_msecs / 6);
162                                 for(i = 0; i < 5; i++)
163                                         new[i] = (new[i] & ~mask) |
164                                                  (new[i+1] & mask);
165                                 new[5] = (new[5] & ~mask) | (next[k] & mask);
166                         } else
167                                 new[k] = (new[k] & ~mask) | (next[k] & mask);
168                         next[k] = 0;
169                         for (s = 1; s >= 0; s--) {
170                                 standt(s);
171                                 for (i = 0; i < 6; i++) {
172                                         draw_row(i, s);
173                                 }
174                                 if (!s) {
175                                         move(ybase, 0);
176                                         refresh();
177                                 }
178                         }
179                 }
180                 move(ybase, 0);
181                 refresh();
182                 snooze(1000 - (scrol ? scroll_msecs : 0));
183         } while (forever ? 1 : --n);
184         standend();
185         clear();
186         refresh();
187         endwin();
188         return(0);
189 }
190
191 void
192 snooze(long int msecs)
193 {
194         struct timespec ts;
195
196         ts.tv_sec = 0;
197         ts.tv_nsec = 1000000 * msecs;
198
199         nanosleep(&ts, NULL);
200
201         if (sigtermed) {
202                 standend();
203                 clear();
204                 refresh();
205                 endwin();
206                 errx(1, "terminated by signal %d", (int)sigtermed);
207         }
208 }
209
210 void
211 draw_row(int i, int s)
212 {
213         long a, t;
214         int j;
215
216         if ((a = (new[i] ^ old[i]) & (s ? new : old)[i]) != 0) {
217                 for (j = 0, t = 1 << 26; t; t >>= 1, j++) {
218                         if (a & t) {
219                                 if (!(a & (t << 1))) {
220                                         move(ybase + i, xbase + 2 * j);
221                                 }
222                                 addstr("  ");
223                         }
224                 }
225         }
226         if (!s) {
227                 old[i] = new[i];
228         }
229 }
230
231 void
232 set(int t, int n)
233 {
234         int i, m;
235
236         m = 7 << n;
237         for (i = 0; i < 5; i++) {
238                 next[i] |= ((disp[t] >> (4 - i) * 3) & 07) << n;
239                 mask |= (next[i] ^ old[i]) & m;
240         }
241         if (mask & m)
242                 mask |= m;
243 }
244
245 void
246 standt(int on)
247 {
248         if (on) {
249                 if (hascolor) {
250                         attron(COLOR_PAIR(1));
251                 } else {
252                         attron(A_STANDOUT);
253                 }
254         } else {
255                 if (hascolor) {
256                         attron(COLOR_PAIR(2));
257                 } else {
258                         attroff(A_STANDOUT);
259                 }
260         }
261 }
262
263 void
264 usage(void)
265 {
266         fprintf(stderr, "usage: grdc [-s] [-d msecs] [n]\n");
267         exit(1);
268 }