c1ffb3c71614d9de5529a10f338190c363c87216
[ncurses.git] / test / xmas.c
1 /******************************************************************************/
2 /* asciixmas                                                                  */
3 /* December 1989             Larry Bartz           Indianapolis, IN           */
4 /*                                                                            */
5 /*                                                                            */
6 /* I'm dreaming of an ascii character-based monochrome Christmas,             */
7 /* Just like the one's I used to know!                                        */
8 /* Via a full duplex communications channel,                                  */
9 /* At 9600 bits per second,                                                   */
10 /* Even though it's kinda slow.                                               */
11 /*                                                                            */
12 /* I'm dreaming of an ascii character-based monochrome Christmas,             */
13 /* With ev'ry C program I write!                                              */
14 /* May your screen be merry and bright!                                       */
15 /* And may all your Christmases be amber or green,                            */
16 /* (for reduced eyestrain and improved visibility)!                           */
17 /*                                                                            */
18 /*                                                                            */
19 /*                                                                            */
20 /*                                                                            */
21 /*                                                                            */
22 /* IMPLEMENTATION                                                             */
23 /*                                                                            */
24 /* Feel free to modify the defined string FROMWHO to reflect you, your        */
25 /* organization, your site, whatever.                                         */
26 /*                                                                            */
27 /* This really looks a lot better if you can turn off your cursor before      */
28 /* execution. I wanted to do that here but very few termcap entries or        */
29 /* terminfo definitions have the appropriate string defined. If you know      */
30 /* the string(s) for the terminal(s) you use or which your site supports,     */
31 /* you could call asciixmas from within a shell in which you issue the        */
32 /* string to the terminal. The cursor is distracting but it doesn't really    */
33 /* ruin the show.                                                             */
34 /*                                                                            */
35 /* At our site, we invoke this for our users just after login and the         */
36 /* determination of terminal type.                                            */
37 /*                                                                            */
38 /*                                                                            */
39 /* PORTABILITY                                                                */
40 /*                                                                            */
41 /* I wrote this using only the very simplest curses functions so that it      */
42 /* might be the most portable. I was personally able to test on five          */
43 /* different cpu/UNIX combinations.                                           */
44 /*                                                                            */
45 /*                                                                            */
46 /* COMPILE                                                                    */
47 /*                                                                            */
48 /* usually this:                                                              */
49 /*                                                                            */
50 /* cc -O asciixmas.c -lcurses -o asciixmas -s                                 */
51 /*                                                                            */
52 /*                                                                            */
53 /* Zilog S8000 models 11, 21, 31, etc with ZEUS variant of SYSTEM III         */
54 /* maybe other SYSTEM III also:                                               */
55 /*                                                                            */
56 /* cc asciixmas.c -lcurses -ltermlib -o asciixmas -s                          */
57 /*                                                                            */
58 /* as above with optional "peephole optimizer" installed:                     */
59 /*                                                                            */
60 /* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
61 /*                                                                            */
62 /*                                                                            */
63 /* Zilog S8000 models 32, 130 with WE32100 chip and SYS V, REL2               */
64 /* maybe 3B2 also?                                                            */
65 /*                                                                            */
66 /* cc -f -O -K sd asciixmas.c -lcurses -o asciixmas -s                        */
67 /*                                                                            */
68 /*                                                                            */
69 /* Pyramid, Sequent, any other "dual universe" types compile and execute      */
70 /* under either universe. The compile line for the ucb universe (as you       */
71 /* might expect) is the same as for SYS III UNIX:                             */
72 /*                                                                            */
73 /* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
74 /*                                                                            */
75 /* The above compile will also hold true for other BSD systems. (I hope)      */
76 /*                                                                            */
77 /*                                                                            */
78 /*                                                                            */
79 /*                                                                            */
80 /* For the Scrooges out there among you who don't want this thing to loop     */
81 /* forever (or until the user hits a key), insert this into your compile      */
82 /* line just after "cc" :                                                     */
83 /*                                                                            */
84 /* -DNOLOOP                                                                   */
85 /*                                                                            */
86 /* like so:                                                                   */
87 /*                                                                            */
88 /* cc -DNOLOOP -O asciixmas.c -lcurses -o asciixmas -s                        */
89 /*                                                                            */
90 /*                                                                            */
91 /*                                                                            */
92 /******************************************************************************/
93
94 /*
95  * $Id: xmas.c,v 1.26 2010/05/01 18:29:50 tom Exp $
96  */
97 #include <test.priv.h>
98
99 #define FROMWHO "Mark Hessling - (M.Hessling@gu.edu.au)"
100
101 static int my_bg = COLOR_BLACK;
102 static int y_pos, x_pos;
103
104 static WINDOW *treescrn;
105 static WINDOW *treescrn2;
106 static WINDOW *treescrn3;
107 static WINDOW *treescrn4;
108 static WINDOW *treescrn5;
109 static WINDOW *treescrn6;
110 static WINDOW *treescrn7;
111 static WINDOW *treescrn8;
112 static WINDOW *dotdeer0;
113 static WINDOW *stardeer0;
114 static WINDOW *lildeer0;
115 static WINDOW *lildeer1;
116 static WINDOW *lildeer2;
117 static WINDOW *lildeer3;
118 static WINDOW *middeer0;
119 static WINDOW *middeer1;
120 static WINDOW *middeer2;
121 static WINDOW *middeer3;
122 static WINDOW *bigdeer0;
123 static WINDOW *bigdeer1;
124 static WINDOW *bigdeer2;
125 static WINDOW *bigdeer3;
126 static WINDOW *bigdeer4;
127 static WINDOW *lookdeer0;
128 static WINDOW *lookdeer1;
129 static WINDOW *lookdeer2;
130 static WINDOW *lookdeer3;
131 static WINDOW *lookdeer4;
132 static WINDOW *w_holiday;
133 static WINDOW *w_del_msg;
134 static bool *my_pairs;
135
136 static int boxit(void);
137 static int seas(void);
138 static int greet(void);
139 static int fromwho(void);
140 static int tree(void);
141 static int balls(void);
142 static int star(void);
143 static int strng1(void);
144 static int strng2(void);
145 static int strng3(void);
146 static int strng4(void);
147 static int strng5(void);
148 static int reindeer(void);
149 static int blinkit(void);
150
151 static RETSIGTYPE done(int sig) GCC_NORETURN;
152
153 static void
154 set_color(WINDOW *win, chtype color)
155 {
156     if (has_colors()) {
157         int n = (color + 1);
158         if (my_pairs == 0)
159             my_pairs = typeCalloc(bool, COLORS + 1);
160         if (!my_pairs[n]) {
161             init_pair(n, color, my_bg);
162             my_pairs[n] = TRUE;
163         }
164         wattroff(win, A_COLOR);
165         wattron(win, COLOR_PAIR(n));
166     }
167 }
168
169 static void
170 unset_color(WINDOW *win)
171 {
172     if (has_colors())
173         (void) wattrset(win, COLOR_PAIR(0));
174 }
175
176 static void
177 look_out(int msecs)
178 {
179     napms(msecs);
180     if (getch() != ERR) {
181         beep();
182         done(0);
183     }
184 }
185
186 int
187 main(int argc GCC_UNUSED, char **argv GCC_UNUSED)
188 {
189     int loopy;
190
191     setlocale(LC_ALL, "");
192
193     initscr();
194     noecho();
195     nonl();
196     refresh();
197
198     CATCHALL(done);
199
200     if (has_colors()) {
201         start_color();
202 #if HAVE_USE_DEFAULT_COLORS
203         if (use_default_colors() == OK)
204             my_bg = -1;
205 #endif
206     }
207     curs_set(0);
208
209     if ((treescrn = newwin(16, 27, 3, 53)) == 0 ||
210         (treescrn2 = newwin(16, 27, 3, 53)) == 0 ||
211         (treescrn3 = newwin(16, 27, 3, 53)) == 0 ||
212         (treescrn4 = newwin(16, 27, 3, 53)) == 0 ||
213         (treescrn5 = newwin(16, 27, 3, 53)) == 0 ||
214         (treescrn6 = newwin(16, 27, 3, 53)) == 0 ||
215         (treescrn7 = newwin(16, 27, 3, 53)) == 0 ||
216         (treescrn8 = newwin(16, 27, 3, 53)) == 0 ||
217
218         (dotdeer0 = newwin(3, 71, 0, 8)) == 0 ||
219
220         (stardeer0 = newwin(4, 56, 0, 8)) == 0 ||
221
222         (lildeer0 = newwin(7, 53, 0, 8)) == 0 ||
223         (lildeer1 = newwin(2, 4, 0, 0)) == 0 ||
224         (lildeer2 = newwin(2, 4, 0, 0)) == 0 ||
225         (lildeer3 = newwin(2, 4, 0, 0)) == 0 ||
226
227         (middeer0 = newwin(15, 42, 0, 8)) == 0 ||
228         (middeer1 = newwin(3, 7, 0, 0)) == 0 ||
229         (middeer2 = newwin(3, 7, 0, 0)) == 0 ||
230         (middeer3 = newwin(3, 7, 0, 0)) == 0 ||
231
232         (bigdeer0 = newwin(10, 23, 0, 0)) == 0 ||
233         (bigdeer1 = newwin(10, 23, 0, 0)) == 0 ||
234         (bigdeer2 = newwin(10, 23, 0, 0)) == 0 ||
235         (bigdeer3 = newwin(10, 23, 0, 0)) == 0 ||
236         (bigdeer4 = newwin(10, 23, 0, 0)) == 0 ||
237
238         (lookdeer0 = newwin(10, 25, 0, 0)) == 0 ||
239         (lookdeer1 = newwin(10, 25, 0, 0)) == 0 ||
240         (lookdeer2 = newwin(10, 25, 0, 0)) == 0 ||
241         (lookdeer3 = newwin(10, 25, 0, 0)) == 0 ||
242         (lookdeer4 = newwin(10, 25, 0, 0)) == 0 ||
243
244         (w_holiday = newwin(1, 26, 3, 27)) == 0 ||
245
246         (w_del_msg = newwin(1, 19, 23, 60)) == 0) {
247         endwin();
248         fprintf(stderr, "Cannot create windows - screen too small\n");
249         ExitProgram(EXIT_FAILURE);
250     }
251
252     MvWAddStr(w_del_msg, 0, 0, "Hit any key to quit");
253
254     MvWAddStr(w_holiday, 0, 0, "H A P P Y  H O L I D A Y S");
255
256     /* set up the windows for our various reindeer */
257
258     /* lildeer1 */
259     MvWAddCh(lildeer1, 0, 0, (chtype) 'V');
260     MvWAddCh(lildeer1, 1, 0, (chtype) '@');
261     MvWAddCh(lildeer1, 1, 1, (chtype) '<');
262     MvWAddCh(lildeer1, 1, 2, (chtype) '>');
263     MvWAddCh(lildeer1, 1, 3, (chtype) '~');
264
265     /* lildeer2 */
266     MvWAddCh(lildeer2, 0, 0, (chtype) 'V');
267     MvWAddCh(lildeer2, 1, 0, (chtype) '@');
268     MvWAddCh(lildeer2, 1, 1, (chtype) '|');
269     MvWAddCh(lildeer2, 1, 2, (chtype) '|');
270     MvWAddCh(lildeer2, 1, 3, (chtype) '~');
271
272     /* lildeer3 */
273     MvWAddCh(lildeer3, 0, 0, (chtype) 'V');
274     MvWAddCh(lildeer3, 1, 0, (chtype) '@');
275     MvWAddCh(lildeer3, 1, 1, (chtype) '>');
276     MvWAddCh(lildeer3, 1, 2, (chtype) '<');
277     MvWAddCh(lildeer2, 1, 3, (chtype) '~');
278
279     /* middeer1 */
280     MvWAddCh(middeer1, 0, 2, (chtype) 'y');
281     MvWAddCh(middeer1, 0, 3, (chtype) 'y');
282     MvWAddCh(middeer1, 1, 2, (chtype) '0');
283     MvWAddCh(middeer1, 1, 3, (chtype) '(');
284     MvWAddCh(middeer1, 1, 4, (chtype) '=');
285     MvWAddCh(middeer1, 1, 5, (chtype) ')');
286     MvWAddCh(middeer1, 1, 6, (chtype) '~');
287     MvWAddCh(middeer1, 2, 3, (chtype) '\\');
288     MvWAddCh(middeer1, 2, 4, (chtype) '/');
289
290     /* middeer2 */
291     MvWAddCh(middeer2, 0, 2, (chtype) 'y');
292     MvWAddCh(middeer2, 0, 3, (chtype) 'y');
293     MvWAddCh(middeer2, 1, 2, (chtype) '0');
294     MvWAddCh(middeer2, 1, 3, (chtype) '(');
295     MvWAddCh(middeer2, 1, 4, (chtype) '=');
296     MvWAddCh(middeer2, 1, 5, (chtype) ')');
297     MvWAddCh(middeer2, 1, 6, (chtype) '~');
298     MvWAddCh(middeer2, 2, 3, (chtype) '|');
299     MvWAddCh(middeer2, 2, 5, (chtype) '|');
300
301     /* middeer3 */
302     MvWAddCh(middeer3, 0, 2, (chtype) 'y');
303     MvWAddCh(middeer3, 0, 3, (chtype) 'y');
304     MvWAddCh(middeer3, 1, 2, (chtype) '0');
305     MvWAddCh(middeer3, 1, 3, (chtype) '(');
306     MvWAddCh(middeer3, 1, 4, (chtype) '=');
307     MvWAddCh(middeer3, 1, 5, (chtype) ')');
308     MvWAddCh(middeer3, 1, 6, (chtype) '~');
309     MvWAddCh(middeer3, 2, 2, (chtype) '/');
310     MvWAddCh(middeer3, 2, 6, (chtype) '\\');
311
312     /* bigdeer1 */
313     MvWAddCh(bigdeer1, 0, 17, (chtype) '\\');
314     MvWAddCh(bigdeer1, 0, 18, (chtype) '/');
315     MvWAddCh(bigdeer1, 0, 20, (chtype) '\\');
316     MvWAddCh(bigdeer1, 0, 21, (chtype) '/');
317     MvWAddCh(bigdeer1, 1, 18, (chtype) '\\');
318     MvWAddCh(bigdeer1, 1, 20, (chtype) '/');
319     MvWAddCh(bigdeer1, 2, 19, (chtype) '|');
320     MvWAddCh(bigdeer1, 2, 20, (chtype) '_');
321     MvWAddCh(bigdeer1, 3, 18, (chtype) '/');
322     MvWAddCh(bigdeer1, 3, 19, (chtype) '^');
323     MvWAddCh(bigdeer1, 3, 20, (chtype) '0');
324     MvWAddCh(bigdeer1, 3, 21, (chtype) '\\');
325     MvWAddCh(bigdeer1, 4, 17, (chtype) '/');
326     MvWAddCh(bigdeer1, 4, 18, (chtype) '/');
327     MvWAddCh(bigdeer1, 4, 19, (chtype) '\\');
328     MvWAddCh(bigdeer1, 4, 22, (chtype) '\\');
329     MvWAddStr(bigdeer1, 5, 7, "^~~~~~~~~//  ~~U");
330     MvWAddStr(bigdeer1, 6, 7, "( \\_____( /");
331     MvWAddStr(bigdeer1, 7, 8, "( )    /");
332     MvWAddStr(bigdeer1, 8, 9, "\\\\   /");
333     MvWAddStr(bigdeer1, 9, 11, "\\>/>");
334
335     /* bigdeer2 */
336     MvWAddCh(bigdeer2, 0, 17, (chtype) '\\');
337     MvWAddCh(bigdeer2, 0, 18, (chtype) '/');
338     MvWAddCh(bigdeer2, 0, 20, (chtype) '\\');
339     MvWAddCh(bigdeer2, 0, 21, (chtype) '/');
340     MvWAddCh(bigdeer2, 1, 18, (chtype) '\\');
341     MvWAddCh(bigdeer2, 1, 20, (chtype) '/');
342     MvWAddCh(bigdeer2, 2, 19, (chtype) '|');
343     MvWAddCh(bigdeer2, 2, 20, (chtype) '_');
344     MvWAddCh(bigdeer2, 3, 18, (chtype) '/');
345     MvWAddCh(bigdeer2, 3, 19, (chtype) '^');
346     MvWAddCh(bigdeer2, 3, 20, (chtype) '0');
347     MvWAddCh(bigdeer2, 3, 21, (chtype) '\\');
348     MvWAddCh(bigdeer2, 4, 17, (chtype) '/');
349     MvWAddCh(bigdeer2, 4, 18, (chtype) '/');
350     MvWAddCh(bigdeer2, 4, 19, (chtype) '\\');
351     MvWAddCh(bigdeer2, 4, 22, (chtype) '\\');
352     MvWAddStr(bigdeer2, 5, 7, "^~~~~~~~~//  ~~U");
353     MvWAddStr(bigdeer2, 6, 7, "(( )____( /");
354     MvWAddStr(bigdeer2, 7, 7, "( /      |");
355     MvWAddStr(bigdeer2, 8, 8, "\\/      |");
356     MvWAddStr(bigdeer2, 9, 9, "|>     |>");
357
358     /* bigdeer3 */
359     MvWAddCh(bigdeer3, 0, 17, (chtype) '\\');
360     MvWAddCh(bigdeer3, 0, 18, (chtype) '/');
361     MvWAddCh(bigdeer3, 0, 20, (chtype) '\\');
362     MvWAddCh(bigdeer3, 0, 21, (chtype) '/');
363     MvWAddCh(bigdeer3, 1, 18, (chtype) '\\');
364     MvWAddCh(bigdeer3, 1, 20, (chtype) '/');
365     MvWAddCh(bigdeer3, 2, 19, (chtype) '|');
366     MvWAddCh(bigdeer3, 2, 20, (chtype) '_');
367     MvWAddCh(bigdeer3, 3, 18, (chtype) '/');
368     MvWAddCh(bigdeer3, 3, 19, (chtype) '^');
369     MvWAddCh(bigdeer3, 3, 20, (chtype) '0');
370     MvWAddCh(bigdeer3, 3, 21, (chtype) '\\');
371     MvWAddCh(bigdeer3, 4, 17, (chtype) '/');
372     MvWAddCh(bigdeer3, 4, 18, (chtype) '/');
373     MvWAddCh(bigdeer3, 4, 19, (chtype) '\\');
374     MvWAddCh(bigdeer3, 4, 22, (chtype) '\\');
375     MvWAddStr(bigdeer3, 5, 7, "^~~~~~~~~//  ~~U");
376     MvWAddStr(bigdeer3, 6, 6, "( ()_____( /");
377     MvWAddStr(bigdeer3, 7, 6, "/ /       /");
378     MvWAddStr(bigdeer3, 8, 5, "|/          \\");
379     MvWAddStr(bigdeer3, 9, 5, "/>           \\>");
380
381     /* bigdeer4 */
382     MvWAddCh(bigdeer4, 0, 17, (chtype) '\\');
383     MvWAddCh(bigdeer4, 0, 18, (chtype) '/');
384     MvWAddCh(bigdeer4, 0, 20, (chtype) '\\');
385     MvWAddCh(bigdeer4, 0, 21, (chtype) '/');
386     MvWAddCh(bigdeer4, 1, 18, (chtype) '\\');
387     MvWAddCh(bigdeer4, 1, 20, (chtype) '/');
388     MvWAddCh(bigdeer4, 2, 19, (chtype) '|');
389     MvWAddCh(bigdeer4, 2, 20, (chtype) '_');
390     MvWAddCh(bigdeer4, 3, 18, (chtype) '/');
391     MvWAddCh(bigdeer4, 3, 19, (chtype) '^');
392     MvWAddCh(bigdeer4, 3, 20, (chtype) '0');
393     MvWAddCh(bigdeer4, 3, 21, (chtype) '\\');
394     MvWAddCh(bigdeer4, 4, 17, (chtype) '/');
395     MvWAddCh(bigdeer4, 4, 18, (chtype) '/');
396     MvWAddCh(bigdeer4, 4, 19, (chtype) '\\');
397     MvWAddCh(bigdeer4, 4, 22, (chtype) '\\');
398     MvWAddStr(bigdeer4, 5, 7, "^~~~~~~~~//  ~~U");
399     MvWAddStr(bigdeer4, 6, 6, "( )______( /");
400     MvWAddStr(bigdeer4, 7, 5, "(/          \\");
401     MvWAddStr(bigdeer4, 8, 0, "v___=             ----^");
402
403     /* lookdeer1 */
404     MvWAddStr(lookdeer1, 0, 16, "\\/     \\/");
405     MvWAddStr(lookdeer1, 1, 17, "\\Y/ \\Y/");
406     MvWAddStr(lookdeer1, 2, 19, "\\=/");
407     MvWAddStr(lookdeer1, 3, 17, "^\\o o/^");
408     MvWAddStr(lookdeer1, 4, 17, "//( )");
409     MvWAddStr(lookdeer1, 5, 7, "^~~~~~~~~// \\O/");
410     MvWAddStr(lookdeer1, 6, 7, "( \\_____( /");
411     MvWAddStr(lookdeer1, 7, 8, "( )    /");
412     MvWAddStr(lookdeer1, 8, 9, "\\\\   /");
413     MvWAddStr(lookdeer1, 9, 11, "\\>/>");
414
415     /* lookdeer2 */
416     MvWAddStr(lookdeer2, 0, 16, "\\/     \\/");
417     MvWAddStr(lookdeer2, 1, 17, "\\Y/ \\Y/");
418     MvWAddStr(lookdeer2, 2, 19, "\\=/");
419     MvWAddStr(lookdeer2, 3, 17, "^\\o o/^");
420     MvWAddStr(lookdeer2, 4, 17, "//( )");
421     MvWAddStr(lookdeer2, 5, 7, "^~~~~~~~~// \\O/");
422     MvWAddStr(lookdeer2, 6, 7, "(( )____( /");
423     MvWAddStr(lookdeer2, 7, 7, "( /      |");
424     MvWAddStr(lookdeer2, 8, 8, "\\/      |");
425     MvWAddStr(lookdeer2, 9, 9, "|>     |>");
426
427     /* lookdeer3 */
428     MvWAddStr(lookdeer3, 0, 16, "\\/     \\/");
429     MvWAddStr(lookdeer3, 1, 17, "\\Y/ \\Y/");
430     MvWAddStr(lookdeer3, 2, 19, "\\=/");
431     MvWAddStr(lookdeer3, 3, 17, "^\\o o/^");
432     MvWAddStr(lookdeer3, 4, 17, "//( )");
433     MvWAddStr(lookdeer3, 5, 7, "^~~~~~~~~// \\O/");
434     MvWAddStr(lookdeer3, 6, 6, "( ()_____( /");
435     MvWAddStr(lookdeer3, 7, 6, "/ /       /");
436     MvWAddStr(lookdeer3, 8, 5, "|/          \\");
437     MvWAddStr(lookdeer3, 9, 5, "/>           \\>");
438
439     /* lookdeer4 */
440     MvWAddStr(lookdeer4, 0, 16, "\\/     \\/");
441     MvWAddStr(lookdeer4, 1, 17, "\\Y/ \\Y/");
442     MvWAddStr(lookdeer4, 2, 19, "\\=/");
443     MvWAddStr(lookdeer4, 3, 17, "^\\o o/^");
444     MvWAddStr(lookdeer4, 4, 17, "//( )");
445     MvWAddStr(lookdeer4, 5, 7, "^~~~~~~~~// \\O/");
446     MvWAddStr(lookdeer4, 6, 6, "( )______( /");
447     MvWAddStr(lookdeer4, 7, 5, "(/          \\");
448     MvWAddStr(lookdeer4, 8, 0, "v___=             ----^");
449
450         /***********************************************/
451     cbreak();
452     nodelay(stdscr, TRUE);
453     for (;;) {
454         clear();
455         werase(treescrn);
456         touchwin(w_del_msg);
457         touchwin(treescrn);
458         werase(treescrn2);
459         touchwin(treescrn2);
460         werase(treescrn8);
461         touchwin(treescrn8);
462         refresh();
463         look_out(150);
464         boxit();
465         refresh();
466         look_out(150);
467         seas();
468         refresh();
469         look_out(150);
470         greet();
471         refresh();
472         look_out(150);
473         fromwho();
474         refresh();
475         look_out(150);
476         tree();
477         look_out(150);
478         balls();
479         look_out(150);
480         star();
481         look_out(150);
482         strng1();
483         strng2();
484         strng3();
485         strng4();
486         strng5();
487
488         /* set up the windows for our blinking trees */
489         /* **************************************** */
490         /* treescrn3 */
491
492         overlay(treescrn, treescrn3);
493
494         /*balls */
495         MvWAddCh(treescrn3, 4, 18, ' ');
496         MvWAddCh(treescrn3, 7, 6, ' ');
497         MvWAddCh(treescrn3, 8, 19, ' ');
498         MvWAddCh(treescrn3, 11, 22, ' ');
499
500         /*star */
501         MvWAddCh(treescrn3, 0, 12, '*');
502
503         /*strng1 */
504         MvWAddCh(treescrn3, 3, 11, ' ');
505
506         /*strng2 */
507         MvWAddCh(treescrn3, 5, 13, ' ');
508         MvWAddCh(treescrn3, 6, 10, ' ');
509
510         /*strng3 */
511         MvWAddCh(treescrn3, 7, 16, ' ');
512         MvWAddCh(treescrn3, 7, 14, ' ');
513
514         /*strng4 */
515         MvWAddCh(treescrn3, 10, 13, ' ');
516         MvWAddCh(treescrn3, 10, 10, ' ');
517         MvWAddCh(treescrn3, 11, 8, ' ');
518
519         /*strng5 */
520         MvWAddCh(treescrn3, 11, 18, ' ');
521         MvWAddCh(treescrn3, 12, 13, ' ');
522
523         /* treescrn4 */
524
525         overlay(treescrn, treescrn4);
526
527         /*balls */
528         MvWAddCh(treescrn4, 3, 9, ' ');
529         MvWAddCh(treescrn4, 4, 16, ' ');
530         MvWAddCh(treescrn4, 7, 6, ' ');
531         MvWAddCh(treescrn4, 8, 19, ' ');
532         MvWAddCh(treescrn4, 11, 2, ' ');
533         MvWAddCh(treescrn4, 12, 23, ' ');
534
535         /*star */
536         (void) wstandout(treescrn4);
537         MvWAddCh(treescrn4, 0, 12, '*');
538         (void) wstandend(treescrn4);
539
540         /*strng1 */
541         MvWAddCh(treescrn4, 3, 13, ' ');
542
543         /*strng2 */
544
545         /*strng3 */
546         MvWAddCh(treescrn4, 7, 15, ' ');
547         MvWAddCh(treescrn4, 8, 11, ' ');
548
549         /*strng4 */
550         MvWAddCh(treescrn4, 9, 16, ' ');
551         MvWAddCh(treescrn4, 10, 12, ' ');
552         MvWAddCh(treescrn4, 11, 8, ' ');
553
554         /*strng5 */
555         MvWAddCh(treescrn4, 11, 18, ' ');
556         MvWAddCh(treescrn4, 12, 14, ' ');
557
558         /* treescrn5 */
559
560         overlay(treescrn, treescrn5);
561
562         /*balls */
563         MvWAddCh(treescrn5, 3, 15, ' ');
564         MvWAddCh(treescrn5, 10, 20, ' ');
565         MvWAddCh(treescrn5, 12, 1, ' ');
566
567         /*star */
568         MvWAddCh(treescrn5, 0, 12, '*');
569
570         /*strng1 */
571         MvWAddCh(treescrn5, 3, 11, ' ');
572
573         /*strng2 */
574         MvWAddCh(treescrn5, 5, 12, ' ');
575
576         /*strng3 */
577         MvWAddCh(treescrn5, 7, 14, ' ');
578         MvWAddCh(treescrn5, 8, 10, ' ');
579
580         /*strng4 */
581         MvWAddCh(treescrn5, 9, 15, ' ');
582         MvWAddCh(treescrn5, 10, 11, ' ');
583         MvWAddCh(treescrn5, 11, 7, ' ');
584
585         /*strng5 */
586         MvWAddCh(treescrn5, 11, 17, ' ');
587         MvWAddCh(treescrn5, 12, 13, ' ');
588
589         /* treescrn6 */
590
591         overlay(treescrn, treescrn6);
592
593         /*balls */
594         MvWAddCh(treescrn6, 6, 7, ' ');
595         MvWAddCh(treescrn6, 7, 18, ' ');
596         MvWAddCh(treescrn6, 10, 4, ' ');
597         MvWAddCh(treescrn6, 11, 23, ' ');
598
599         /*star */
600         (void) wstandout(treescrn6);
601         MvWAddCh(treescrn6, 0, 12, '*');
602         (void) wstandend(treescrn6);
603
604         /*strng1 */
605
606         /*strng2 */
607         MvWAddCh(treescrn6, 5, 11, ' ');
608
609         /*strng3 */
610         MvWAddCh(treescrn6, 7, 13, ' ');
611         MvWAddCh(treescrn6, 8, 9, ' ');
612
613         /*strng4 */
614         MvWAddCh(treescrn6, 9, 14, ' ');
615         MvWAddCh(treescrn6, 10, 10, ' ');
616         MvWAddCh(treescrn6, 11, 6, ' ');
617
618         /*strng5 */
619         MvWAddCh(treescrn6, 11, 16, ' ');
620         MvWAddCh(treescrn6, 12, 12, ' ');
621
622         /* treescrn7 */
623
624         overlay(treescrn, treescrn7);
625
626         /*balls */
627         MvWAddCh(treescrn7, 3, 15, ' ');
628         MvWAddCh(treescrn7, 6, 7, ' ');
629         MvWAddCh(treescrn7, 7, 18, ' ');
630         MvWAddCh(treescrn7, 10, 4, ' ');
631         MvWAddCh(treescrn7, 11, 22, ' ');
632
633         /*star */
634         MvWAddCh(treescrn7, 0, 12, '*');
635
636         /*strng1 */
637         MvWAddCh(treescrn7, 3, 12, ' ');
638
639         /*strng2 */
640         MvWAddCh(treescrn7, 5, 13, ' ');
641         MvWAddCh(treescrn7, 6, 9, ' ');
642
643         /*strng3 */
644         MvWAddCh(treescrn7, 7, 15, ' ');
645         MvWAddCh(treescrn7, 8, 11, ' ');
646
647         /*strng4 */
648         MvWAddCh(treescrn7, 9, 16, ' ');
649         MvWAddCh(treescrn7, 10, 12, ' ');
650         MvWAddCh(treescrn7, 11, 8, ' ');
651
652         /*strng5 */
653         MvWAddCh(treescrn7, 11, 18, ' ');
654         MvWAddCh(treescrn7, 12, 14, ' ');
655
656         look_out(150);
657         reindeer();
658
659         touchwin(w_holiday);
660         wrefresh(w_holiday);
661         wrefresh(w_del_msg);
662
663         look_out(500);
664         for (loopy = 0; loopy < 100; loopy++) {
665             blinkit();
666         }
667
668 #ifdef NOLOOP
669         done(0);
670 #endif
671     }
672     /*NOTREACHED */
673 }
674
675 static int
676 boxit(void)
677 {
678     int x = 0;
679
680     while (x < 20) {
681         MvAddCh(x, 7, '|');
682         ++x;
683     }
684
685     x = 8;
686
687     while (x < 80) {
688         MvAddCh(19, x, '_');
689         ++x;
690     }
691
692     x = 0;
693
694     while (x < 80) {
695         MvAddCh(22, x, '_');
696         ++x;
697     }
698
699     return (0);
700 }
701
702 static int
703 seas(void)
704 {
705     MvAddCh(4, 1, 'S');
706     MvAddCh(6, 1, 'E');
707     MvAddCh(8, 1, 'A');
708     MvAddCh(10, 1, 'S');
709     MvAddCh(12, 1, 'O');
710     MvAddCh(14, 1, 'N');
711     MvAddCh(16, 1, '`');
712     MvAddCh(18, 1, 'S');
713
714     return (0);
715 }
716
717 static int
718 greet(void)
719 {
720     MvAddCh(3, 5, 'G');
721     MvAddCh(5, 5, 'R');
722     MvAddCh(7, 5, 'E');
723     MvAddCh(9, 5, 'E');
724     MvAddCh(11, 5, 'T');
725     MvAddCh(13, 5, 'I');
726     MvAddCh(15, 5, 'N');
727     MvAddCh(17, 5, 'G');
728     MvAddCh(19, 5, 'S');
729
730     return (0);
731 }
732
733 static int
734 fromwho(void)
735 {
736     MvAddStr(21, 13, FROMWHO);
737     return (0);
738 }
739
740 static int
741 tree(void)
742 {
743     set_color(treescrn, COLOR_GREEN);
744     MvWAddCh(treescrn, 1, 11, (chtype) '/');
745     MvWAddCh(treescrn, 2, 11, (chtype) '/');
746     MvWAddCh(treescrn, 3, 10, (chtype) '/');
747     MvWAddCh(treescrn, 4, 9, (chtype) '/');
748     MvWAddCh(treescrn, 5, 9, (chtype) '/');
749     MvWAddCh(treescrn, 6, 8, (chtype) '/');
750     MvWAddCh(treescrn, 7, 7, (chtype) '/');
751     MvWAddCh(treescrn, 8, 6, (chtype) '/');
752     MvWAddCh(treescrn, 9, 6, (chtype) '/');
753     MvWAddCh(treescrn, 10, 5, (chtype) '/');
754     MvWAddCh(treescrn, 11, 3, (chtype) '/');
755     MvWAddCh(treescrn, 12, 2, (chtype) '/');
756
757     MvWAddCh(treescrn, 1, 13, (chtype) '\\');
758     MvWAddCh(treescrn, 2, 13, (chtype) '\\');
759     MvWAddCh(treescrn, 3, 14, (chtype) '\\');
760     MvWAddCh(treescrn, 4, 15, (chtype) '\\');
761     MvWAddCh(treescrn, 5, 15, (chtype) '\\');
762     MvWAddCh(treescrn, 6, 16, (chtype) '\\');
763     MvWAddCh(treescrn, 7, 17, (chtype) '\\');
764     MvWAddCh(treescrn, 8, 18, (chtype) '\\');
765     MvWAddCh(treescrn, 9, 18, (chtype) '\\');
766     MvWAddCh(treescrn, 10, 19, (chtype) '\\');
767     MvWAddCh(treescrn, 11, 21, (chtype) '\\');
768     MvWAddCh(treescrn, 12, 22, (chtype) '\\');
769
770     MvWAddCh(treescrn, 4, 10, (chtype) '_');
771     MvWAddCh(treescrn, 4, 14, (chtype) '_');
772     MvWAddCh(treescrn, 8, 7, (chtype) '_');
773     MvWAddCh(treescrn, 8, 17, (chtype) '_');
774
775     MvWAddStr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\");
776
777     MvWAddStr(treescrn, 14, 11, "| |");
778     MvWAddStr(treescrn, 15, 11, "|_|");
779
780     unset_color(treescrn);
781     wrefresh(treescrn);
782     wrefresh(w_del_msg);
783
784     return (0);
785 }
786
787 static int
788 balls(void)
789 {
790     overlay(treescrn, treescrn2);
791
792     set_color(treescrn2, COLOR_BLUE);
793     MvWAddCh(treescrn2, 3, 9, (chtype) '@');
794     MvWAddCh(treescrn2, 3, 15, (chtype) '@');
795     MvWAddCh(treescrn2, 4, 8, (chtype) '@');
796     MvWAddCh(treescrn2, 4, 16, (chtype) '@');
797     MvWAddCh(treescrn2, 5, 7, (chtype) '@');
798     MvWAddCh(treescrn2, 5, 17, (chtype) '@');
799     MvWAddCh(treescrn2, 7, 6, (chtype) '@');
800     MvWAddCh(treescrn2, 7, 18, (chtype) '@');
801     MvWAddCh(treescrn2, 8, 5, (chtype) '@');
802     MvWAddCh(treescrn2, 8, 19, (chtype) '@');
803     MvWAddCh(treescrn2, 10, 4, (chtype) '@');
804     MvWAddCh(treescrn2, 10, 20, (chtype) '@');
805     MvWAddCh(treescrn2, 11, 2, (chtype) '@');
806     MvWAddCh(treescrn2, 11, 22, (chtype) '@');
807     MvWAddCh(treescrn2, 12, 1, (chtype) '@');
808     MvWAddCh(treescrn2, 12, 23, (chtype) '@');
809
810     unset_color(treescrn2);
811     wrefresh(treescrn2);
812     wrefresh(w_del_msg);
813     return (0);
814 }
815
816 static int
817 star(void)
818 {
819     (void) wattrset(treescrn2, A_BOLD | A_BLINK);
820     set_color(treescrn2, COLOR_YELLOW);
821
822     MvWAddCh(treescrn2, 0, 12, (chtype) '*');
823     (void) wstandend(treescrn2);
824
825     unset_color(treescrn2);
826     wrefresh(treescrn2);
827     wrefresh(w_del_msg);
828     return (0);
829 }
830
831 static int
832 strng1(void)
833 {
834     (void) wattrset(treescrn2, A_BOLD | A_BLINK);
835     set_color(treescrn2, COLOR_WHITE);
836
837     MvWAddCh(treescrn2, 3, 13, (chtype) '\'');
838     MvWAddCh(treescrn2, 3, 12, (chtype) ':');
839     MvWAddCh(treescrn2, 3, 11, (chtype) '.');
840
841     wattroff(treescrn2, A_BOLD | A_BLINK);
842     unset_color(treescrn2);
843
844     wrefresh(treescrn2);
845     wrefresh(w_del_msg);
846     return (0);
847 }
848
849 static int
850 strng2(void)
851 {
852     (void) wattrset(treescrn2, A_BOLD | A_BLINK);
853     set_color(treescrn2, COLOR_WHITE);
854
855     MvWAddCh(treescrn2, 5, 14, (chtype) '\'');
856     MvWAddCh(treescrn2, 5, 13, (chtype) ':');
857     MvWAddCh(treescrn2, 5, 12, (chtype) '.');
858     MvWAddCh(treescrn2, 5, 11, (chtype) ',');
859     MvWAddCh(treescrn2, 6, 10, (chtype) '\'');
860     MvWAddCh(treescrn2, 6, 9, (chtype) ':');
861
862     wattroff(treescrn2, A_BOLD | A_BLINK);
863     unset_color(treescrn2);
864
865     wrefresh(treescrn2);
866     wrefresh(w_del_msg);
867     return (0);
868 }
869
870 static int
871 strng3(void)
872 {
873     (void) wattrset(treescrn2, A_BOLD | A_BLINK);
874     set_color(treescrn2, COLOR_WHITE);
875
876     MvWAddCh(treescrn2, 7, 16, (chtype) '\'');
877     MvWAddCh(treescrn2, 7, 15, (chtype) ':');
878     MvWAddCh(treescrn2, 7, 14, (chtype) '.');
879     MvWAddCh(treescrn2, 7, 13, (chtype) ',');
880     MvWAddCh(treescrn2, 8, 12, (chtype) '\'');
881     MvWAddCh(treescrn2, 8, 11, (chtype) ':');
882     MvWAddCh(treescrn2, 8, 10, (chtype) '.');
883     MvWAddCh(treescrn2, 8, 9, (chtype) ',');
884
885     wattroff(treescrn2, A_BOLD | A_BLINK);
886     unset_color(treescrn2);
887
888     wrefresh(treescrn2);
889     wrefresh(w_del_msg);
890     return (0);
891 }
892
893 static int
894 strng4(void)
895 {
896     (void) wattrset(treescrn2, A_BOLD | A_BLINK);
897     set_color(treescrn2, COLOR_WHITE);
898
899     MvWAddCh(treescrn2, 9, 17, (chtype) '\'');
900     MvWAddCh(treescrn2, 9, 16, (chtype) ':');
901     MvWAddCh(treescrn2, 9, 15, (chtype) '.');
902     MvWAddCh(treescrn2, 9, 14, (chtype) ',');
903     MvWAddCh(treescrn2, 10, 13, (chtype) '\'');
904     MvWAddCh(treescrn2, 10, 12, (chtype) ':');
905     MvWAddCh(treescrn2, 10, 11, (chtype) '.');
906     MvWAddCh(treescrn2, 10, 10, (chtype) ',');
907     MvWAddCh(treescrn2, 11, 9, (chtype) '\'');
908     MvWAddCh(treescrn2, 11, 8, (chtype) ':');
909     MvWAddCh(treescrn2, 11, 7, (chtype) '.');
910     MvWAddCh(treescrn2, 11, 6, (chtype) ',');
911     MvWAddCh(treescrn2, 12, 5, (chtype) '\'');
912
913     wattroff(treescrn2, A_BOLD | A_BLINK);
914     unset_color(treescrn2);
915
916     wrefresh(treescrn2);
917     wrefresh(w_del_msg);
918     return (0);
919 }
920
921 static int
922 strng5(void)
923 {
924     (void) wattrset(treescrn2, A_BOLD | A_BLINK);
925     set_color(treescrn2, COLOR_WHITE);
926
927     MvWAddCh(treescrn2, 11, 19, (chtype) '\'');
928     MvWAddCh(treescrn2, 11, 18, (chtype) ':');
929     MvWAddCh(treescrn2, 11, 17, (chtype) '.');
930     MvWAddCh(treescrn2, 11, 16, (chtype) ',');
931     MvWAddCh(treescrn2, 12, 15, (chtype) '\'');
932     MvWAddCh(treescrn2, 12, 14, (chtype) ':');
933     MvWAddCh(treescrn2, 12, 13, (chtype) '.');
934     MvWAddCh(treescrn2, 12, 12, (chtype) ',');
935
936     wattroff(treescrn2, A_BOLD | A_BLINK);
937     unset_color(treescrn2);
938
939     /* save a fully lit tree */
940     overlay(treescrn2, treescrn);
941
942     wrefresh(treescrn2);
943     wrefresh(w_del_msg);
944     return (0);
945 }
946
947 static int
948 blinkit(void)
949 {
950     static int cycle;
951
952     if (cycle > 4) {
953         cycle = 0;
954     }
955
956     touchwin(treescrn8);
957
958     switch (cycle) {
959     case 0:
960         overlay(treescrn3, treescrn8);
961         wrefresh(treescrn8);
962         wrefresh(w_del_msg);
963         break;
964     case 1:
965         overlay(treescrn4, treescrn8);
966         wrefresh(treescrn8);
967         wrefresh(w_del_msg);
968         break;
969     case 2:
970         overlay(treescrn5, treescrn8);
971         wrefresh(treescrn8);
972         wrefresh(w_del_msg);
973         break;
974     case 3:
975         overlay(treescrn6, treescrn8);
976         wrefresh(treescrn8);
977         wrefresh(w_del_msg);
978         break;
979     case 4:
980         overlay(treescrn7, treescrn8);
981         wrefresh(treescrn8);
982         wrefresh(w_del_msg);
983         break;
984     }
985     touchwin(treescrn8);
986
987     /*ALL ON************************************************** */
988
989     overlay(treescrn, treescrn8);
990     wrefresh(treescrn8);
991     wrefresh(w_del_msg);
992
993     ++cycle;
994     return (0);
995 }
996
997 static void
998 deer_step(WINDOW *win, int y, int x)
999 {
1000     mvwin(win, y, x);
1001     wrefresh(win);
1002     wrefresh(w_del_msg);
1003     look_out(5);
1004 }
1005
1006 static int
1007 reindeer(void)
1008 {
1009     int looper;
1010     y_pos = 0;
1011
1012     for (x_pos = 70; x_pos > 62; x_pos--) {
1013         if (x_pos < 62) {
1014             y_pos = 1;
1015         }
1016         for (looper = 0; looper < 4; looper++) {
1017             MvWAddCh(dotdeer0, y_pos, x_pos, (chtype) '.');
1018             wrefresh(dotdeer0);
1019             wrefresh(w_del_msg);
1020             werase(dotdeer0);
1021             wrefresh(dotdeer0);
1022             wrefresh(w_del_msg);
1023             look_out(50);
1024         }
1025     }
1026
1027     y_pos = 2;
1028
1029     for (; x_pos > 50; x_pos--) {
1030         for (looper = 0; looper < 4; looper++) {
1031
1032             if (x_pos < 56) {
1033                 y_pos = 3;
1034
1035                 MvWAddCh(stardeer0, y_pos, x_pos, (chtype) '*');
1036                 wrefresh(stardeer0);
1037                 wrefresh(w_del_msg);
1038                 werase(stardeer0);
1039                 wrefresh(stardeer0);
1040                 wrefresh(w_del_msg);
1041             } else {
1042                 MvWAddCh(dotdeer0, y_pos, x_pos, (chtype) '*');
1043                 wrefresh(dotdeer0);
1044                 wrefresh(w_del_msg);
1045                 werase(dotdeer0);
1046                 wrefresh(dotdeer0);
1047                 wrefresh(w_del_msg);
1048             }
1049         }
1050     }
1051
1052     x_pos = 58;
1053
1054     for (y_pos = 2; y_pos < 5; y_pos++) {
1055
1056         touchwin(lildeer0);
1057         wrefresh(lildeer0);
1058         wrefresh(w_del_msg);
1059
1060         for (looper = 0; looper < 4; looper++) {
1061             deer_step(lildeer3, y_pos, x_pos);
1062             deer_step(lildeer2, y_pos, x_pos);
1063             deer_step(lildeer1, y_pos, x_pos);
1064             deer_step(lildeer2, y_pos, x_pos);
1065             deer_step(lildeer3, y_pos, x_pos);
1066
1067             touchwin(lildeer0);
1068             wrefresh(lildeer0);
1069             wrefresh(w_del_msg);
1070
1071             x_pos -= 2;
1072         }
1073     }
1074
1075     x_pos = 35;
1076
1077     for (y_pos = 5; y_pos < 10; y_pos++) {
1078
1079         touchwin(middeer0);
1080         wrefresh(middeer0);
1081         wrefresh(w_del_msg);
1082
1083         for (looper = 0; looper < 2; looper++) {
1084             deer_step(middeer3, y_pos, x_pos);
1085             deer_step(middeer2, y_pos, x_pos);
1086             deer_step(middeer1, y_pos, x_pos);
1087             deer_step(middeer2, y_pos, x_pos);
1088             deer_step(middeer3, y_pos, x_pos);
1089
1090             touchwin(middeer0);
1091             wrefresh(middeer0);
1092             wrefresh(w_del_msg);
1093
1094             x_pos -= 3;
1095         }
1096     }
1097
1098     look_out(300);
1099
1100     y_pos = 1;
1101
1102     for (x_pos = 8; x_pos < 16; x_pos++) {
1103         deer_step(bigdeer4, y_pos, x_pos);
1104         deer_step(bigdeer3, y_pos, x_pos);
1105         deer_step(bigdeer2, y_pos, x_pos);
1106         deer_step(bigdeer1, y_pos, x_pos);
1107         deer_step(bigdeer2, y_pos, x_pos);
1108         deer_step(bigdeer3, y_pos, x_pos);
1109         deer_step(bigdeer4, y_pos, x_pos);
1110         deer_step(bigdeer0, y_pos, x_pos);
1111     }
1112
1113     --x_pos;
1114
1115     for (looper = 0; looper < 6; looper++) {
1116         deer_step(lookdeer4, y_pos, x_pos);
1117         deer_step(lookdeer3, y_pos, x_pos);
1118         deer_step(lookdeer2, y_pos, x_pos);
1119         deer_step(lookdeer1, y_pos, x_pos);
1120         deer_step(lookdeer2, y_pos, x_pos);
1121         deer_step(lookdeer3, y_pos, x_pos);
1122         deer_step(lookdeer4, y_pos, x_pos);
1123     }
1124
1125     deer_step(lookdeer0, y_pos, x_pos);
1126
1127     for (; y_pos < 10; y_pos++) {
1128         for (looper = 0; looper < 2; looper++) {
1129             deer_step(bigdeer4, y_pos, x_pos);
1130             deer_step(bigdeer3, y_pos, x_pos);
1131             deer_step(bigdeer2, y_pos, x_pos);
1132             deer_step(bigdeer1, y_pos, x_pos);
1133             deer_step(bigdeer2, y_pos, x_pos);
1134             deer_step(bigdeer3, y_pos, x_pos);
1135             deer_step(bigdeer4, y_pos, x_pos);
1136         }
1137         deer_step(bigdeer0, y_pos, x_pos);
1138     }
1139
1140     --y_pos;
1141
1142     deer_step(lookdeer3, y_pos, x_pos);
1143     return (0);
1144 }
1145
1146 static RETSIGTYPE
1147 done(int sig GCC_UNUSED)
1148 {
1149     CATCHALL(done);
1150
1151     move(LINES - 1, 0);
1152     refresh();
1153     endwin();
1154     curs_set(1);
1155
1156 #if NO_LEAKS
1157     if (my_pairs != 0)
1158         free(my_pairs);
1159 #endif
1160
1161     ExitProgram(EXIT_SUCCESS);
1162 }