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.22 2006/05/20 15:35:47 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 = (bool *) calloc((unsigned) (COLORS + 1), sizeof(bool));
 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         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     treescrn = newwin(16, 27, 3, 53);
 210     treescrn2 = newwin(16, 27, 3, 53);
 211     treescrn3 = newwin(16, 27, 3, 53);
 212     treescrn4 = newwin(16, 27, 3, 53);
 213     treescrn5 = newwin(16, 27, 3, 53);
 214     treescrn6 = newwin(16, 27, 3, 53);
 215     treescrn7 = newwin(16, 27, 3, 53);
 216     treescrn8 = newwin(16, 27, 3, 53);
 217
 218     dotdeer0 = newwin(3, 71, 0, 8);
 219
 220     stardeer0 = newwin(4, 56, 0, 8);
 221
 222     lildeer0 = newwin(7, 53, 0, 8);
 223     lildeer1 = newwin(2, 4, 0, 0);
 224     lildeer2 = newwin(2, 4, 0, 0);
 225     lildeer3 = newwin(2, 4, 0, 0);
 226
 227     middeer0 = newwin(15, 42, 0, 8);
 228     middeer1 = newwin(3, 7, 0, 0);
 229     middeer2 = newwin(3, 7, 0, 0);
 230     middeer3 = newwin(3, 7, 0, 0);
 231
 232     bigdeer0 = newwin(10, 23, 0, 0);
 233     bigdeer1 = newwin(10, 23, 0, 0);
 234     bigdeer2 = newwin(10, 23, 0, 0);
 235     bigdeer3 = newwin(10, 23, 0, 0);
 236     bigdeer4 = newwin(10, 23, 0, 0);
 237
 238     lookdeer0 = newwin(10, 25, 0, 0);
 239     lookdeer1 = newwin(10, 25, 0, 0);
 240     lookdeer2 = newwin(10, 25, 0, 0);
 241     lookdeer3 = newwin(10, 25, 0, 0);
 242     lookdeer4 = newwin(10, 25, 0, 0);
 243
 244     w_holiday = newwin(1, 26, 3, 27);
 245
 246     w_del_msg = newwin(1, 19, 23, 60);
 247
 248     mvwaddstr(w_del_msg, 0, 0, "Hit any key to quit");
 249
 250     mvwaddstr(w_holiday, 0, 0, "H A P P Y  H O L I D A Y S");
 251
 252     /* set up the windows for our various reindeer */
 253
 254     /* lildeer1 */
 255     mvwaddch(lildeer1, 0, 0, (chtype) 'V');
 256     mvwaddch(lildeer1, 1, 0, (chtype) '@');
 257     mvwaddch(lildeer1, 1, 1, (chtype) '<');
 258     mvwaddch(lildeer1, 1, 2, (chtype) '>');
 259     mvwaddch(lildeer1, 1, 3, (chtype) '~');
 260
 261     /* lildeer2 */
 262     mvwaddch(lildeer2, 0, 0, (chtype) 'V');
 263     mvwaddch(lildeer2, 1, 0, (chtype) '@');
 264     mvwaddch(lildeer2, 1, 1, (chtype) '|');
 265     mvwaddch(lildeer2, 1, 2, (chtype) '|');
 266     mvwaddch(lildeer2, 1, 3, (chtype) '~');
 267
 268     /* lildeer3 */
 269     mvwaddch(lildeer3, 0, 0, (chtype) 'V');
 270     mvwaddch(lildeer3, 1, 0, (chtype) '@');
 271     mvwaddch(lildeer3, 1, 1, (chtype) '>');
 272     mvwaddch(lildeer3, 1, 2, (chtype) '<');
 273     mvwaddch(lildeer2, 1, 3, (chtype) '~');
 274
 275     /* middeer1 */
 276     mvwaddch(middeer1, 0, 2, (chtype) 'y');
 277     mvwaddch(middeer1, 0, 3, (chtype) 'y');
 278     mvwaddch(middeer1, 1, 2, (chtype) '0');
 279     mvwaddch(middeer1, 1, 3, (chtype) '(');
 280     mvwaddch(middeer1, 1, 4, (chtype) '=');
 281     mvwaddch(middeer1, 1, 5, (chtype) ')');
 282     mvwaddch(middeer1, 1, 6, (chtype) '~');
 283     mvwaddch(middeer1, 2, 3, (chtype) '\\');
 284     mvwaddch(middeer1, 2, 4, (chtype) '/');
 285
 286     /* middeer2 */
 287     mvwaddch(middeer2, 0, 2, (chtype) 'y');
 288     mvwaddch(middeer2, 0, 3, (chtype) 'y');
 289     mvwaddch(middeer2, 1, 2, (chtype) '0');
 290     mvwaddch(middeer2, 1, 3, (chtype) '(');
 291     mvwaddch(middeer2, 1, 4, (chtype) '=');
 292     mvwaddch(middeer2, 1, 5, (chtype) ')');
 293     mvwaddch(middeer2, 1, 6, (chtype) '~');
 294     mvwaddch(middeer2, 2, 3, (chtype) '|');
 295     mvwaddch(middeer2, 2, 5, (chtype) '|');
 296
 297     /* middeer3 */
 298     mvwaddch(middeer3, 0, 2, (chtype) 'y');
 299     mvwaddch(middeer3, 0, 3, (chtype) 'y');
 300     mvwaddch(middeer3, 1, 2, (chtype) '0');
 301     mvwaddch(middeer3, 1, 3, (chtype) '(');
 302     mvwaddch(middeer3, 1, 4, (chtype) '=');
 303     mvwaddch(middeer3, 1, 5, (chtype) ')');
 304     mvwaddch(middeer3, 1, 6, (chtype) '~');
 305     mvwaddch(middeer3, 2, 2, (chtype) '/');
 306     mvwaddch(middeer3, 2, 6, (chtype) '\\');
 307
 308     /* bigdeer1 */
 309     mvwaddch(bigdeer1, 0, 17, (chtype) '\\');
 310     mvwaddch(bigdeer1, 0, 18, (chtype) '/');
 311     mvwaddch(bigdeer1, 0, 20, (chtype) '\\');
 312     mvwaddch(bigdeer1, 0, 21, (chtype) '/');
 313     mvwaddch(bigdeer1, 1, 18, (chtype) '\\');
 314     mvwaddch(bigdeer1, 1, 20, (chtype) '/');
 315     mvwaddch(bigdeer1, 2, 19, (chtype) '|');
 316     mvwaddch(bigdeer1, 2, 20, (chtype) '_');
 317     mvwaddch(bigdeer1, 3, 18, (chtype) '/');
 318     mvwaddch(bigdeer1, 3, 19, (chtype) '^');
 319     mvwaddch(bigdeer1, 3, 20, (chtype) '0');
 320     mvwaddch(bigdeer1, 3, 21, (chtype) '\\');
 321     mvwaddch(bigdeer1, 4, 17, (chtype) '/');
 322     mvwaddch(bigdeer1, 4, 18, (chtype) '/');
 323     mvwaddch(bigdeer1, 4, 19, (chtype) '\\');
 324     mvwaddch(bigdeer1, 4, 22, (chtype) '\\');
 325     mvwaddstr(bigdeer1, 5, 7, "^~~~~~~~~//  ~~U");
 326     mvwaddstr(bigdeer1, 6, 7, "( \\_____( /");
 327     mvwaddstr(bigdeer1, 7, 8, "( )    /");
 328     mvwaddstr(bigdeer1, 8, 9, "\\\\   /");
 329     mvwaddstr(bigdeer1, 9, 11, "\\>/>");
 330
 331     /* bigdeer2 */
 332     mvwaddch(bigdeer2, 0, 17, (chtype) '\\');
 333     mvwaddch(bigdeer2, 0, 18, (chtype) '/');
 334     mvwaddch(bigdeer2, 0, 20, (chtype) '\\');
 335     mvwaddch(bigdeer2, 0, 21, (chtype) '/');
 336     mvwaddch(bigdeer2, 1, 18, (chtype) '\\');
 337     mvwaddch(bigdeer2, 1, 20, (chtype) '/');
 338     mvwaddch(bigdeer2, 2, 19, (chtype) '|');
 339     mvwaddch(bigdeer2, 2, 20, (chtype) '_');
 340     mvwaddch(bigdeer2, 3, 18, (chtype) '/');
 341     mvwaddch(bigdeer2, 3, 19, (chtype) '^');
 342     mvwaddch(bigdeer2, 3, 20, (chtype) '0');
 343     mvwaddch(bigdeer2, 3, 21, (chtype) '\\');
 344     mvwaddch(bigdeer2, 4, 17, (chtype) '/');
 345     mvwaddch(bigdeer2, 4, 18, (chtype) '/');
 346     mvwaddch(bigdeer2, 4, 19, (chtype) '\\');
 347     mvwaddch(bigdeer2, 4, 22, (chtype) '\\');
 348     mvwaddstr(bigdeer2, 5, 7, "^~~~~~~~~//  ~~U");
 349     mvwaddstr(bigdeer2, 6, 7, "(( )____( /");
 350     mvwaddstr(bigdeer2, 7, 7, "( /      |");
 351     mvwaddstr(bigdeer2, 8, 8, "\\/      |");
 352     mvwaddstr(bigdeer2, 9, 9, "|>     |>");
 353
 354     /* bigdeer3 */
 355     mvwaddch(bigdeer3, 0, 17, (chtype) '\\');
 356     mvwaddch(bigdeer3, 0, 18, (chtype) '/');
 357     mvwaddch(bigdeer3, 0, 20, (chtype) '\\');
 358     mvwaddch(bigdeer3, 0, 21, (chtype) '/');
 359     mvwaddch(bigdeer3, 1, 18, (chtype) '\\');
 360     mvwaddch(bigdeer3, 1, 20, (chtype) '/');
 361     mvwaddch(bigdeer3, 2, 19, (chtype) '|');
 362     mvwaddch(bigdeer3, 2, 20, (chtype) '_');
 363     mvwaddch(bigdeer3, 3, 18, (chtype) '/');
 364     mvwaddch(bigdeer3, 3, 19, (chtype) '^');
 365     mvwaddch(bigdeer3, 3, 20, (chtype) '0');
 366     mvwaddch(bigdeer3, 3, 21, (chtype) '\\');
 367     mvwaddch(bigdeer3, 4, 17, (chtype) '/');
 368     mvwaddch(bigdeer3, 4, 18, (chtype) '/');
 369     mvwaddch(bigdeer3, 4, 19, (chtype) '\\');
 370     mvwaddch(bigdeer3, 4, 22, (chtype) '\\');
 371     mvwaddstr(bigdeer3, 5, 7, "^~~~~~~~~//  ~~U");
 372     mvwaddstr(bigdeer3, 6, 6, "( ()_____( /");
 373     mvwaddstr(bigdeer3, 7, 6, "/ /       /");
 374     mvwaddstr(bigdeer3, 8, 5, "|/          \\");
 375     mvwaddstr(bigdeer3, 9, 5, "/>           \\>");
 376
 377     /* bigdeer4 */
 378     mvwaddch(bigdeer4, 0, 17, (chtype) '\\');
 379     mvwaddch(bigdeer4, 0, 18, (chtype) '/');
 380     mvwaddch(bigdeer4, 0, 20, (chtype) '\\');
 381     mvwaddch(bigdeer4, 0, 21, (chtype) '/');
 382     mvwaddch(bigdeer4, 1, 18, (chtype) '\\');
 383     mvwaddch(bigdeer4, 1, 20, (chtype) '/');
 384     mvwaddch(bigdeer4, 2, 19, (chtype) '|');
 385     mvwaddch(bigdeer4, 2, 20, (chtype) '_');
 386     mvwaddch(bigdeer4, 3, 18, (chtype) '/');
 387     mvwaddch(bigdeer4, 3, 19, (chtype) '^');
 388     mvwaddch(bigdeer4, 3, 20, (chtype) '0');
 389     mvwaddch(bigdeer4, 3, 21, (chtype) '\\');
 390     mvwaddch(bigdeer4, 4, 17, (chtype) '/');
 391     mvwaddch(bigdeer4, 4, 18, (chtype) '/');
 392     mvwaddch(bigdeer4, 4, 19, (chtype) '\\');
 393     mvwaddch(bigdeer4, 4, 22, (chtype) '\\');
 394     mvwaddstr(bigdeer4, 5, 7, "^~~~~~~~~//  ~~U");
 395     mvwaddstr(bigdeer4, 6, 6, "( )______( /");
 396     mvwaddstr(bigdeer4, 7, 5, "(/          \\");
 397     mvwaddstr(bigdeer4, 8, 0, "v___=             ----^");
 398
 399     /* lookdeer1 */
 400     mvwaddstr(lookdeer1, 0, 16, "\\/     \\/");
 401     mvwaddstr(lookdeer1, 1, 17, "\\Y/ \\Y/");
 402     mvwaddstr(lookdeer1, 2, 19, "\\=/");
 403     mvwaddstr(lookdeer1, 3, 17, "^\\o o/^");
 404     mvwaddstr(lookdeer1, 4, 17, "//( )");
 405     mvwaddstr(lookdeer1, 5, 7, "^~~~~~~~~// \\O/");
 406     mvwaddstr(lookdeer1, 6, 7, "( \\_____( /");
 407     mvwaddstr(lookdeer1, 7, 8, "( )    /");
 408     mvwaddstr(lookdeer1, 8, 9, "\\\\   /");
 409     mvwaddstr(lookdeer1, 9, 11, "\\>/>");
 410
 411     /* lookdeer2 */
 412     mvwaddstr(lookdeer2, 0, 16, "\\/     \\/");
 413     mvwaddstr(lookdeer2, 1, 17, "\\Y/ \\Y/");
 414     mvwaddstr(lookdeer2, 2, 19, "\\=/");
 415     mvwaddstr(lookdeer2, 3, 17, "^\\o o/^");
 416     mvwaddstr(lookdeer2, 4, 17, "//( )");
 417     mvwaddstr(lookdeer2, 5, 7, "^~~~~~~~~// \\O/");
 418     mvwaddstr(lookdeer2, 6, 7, "(( )____( /");
 419     mvwaddstr(lookdeer2, 7, 7, "( /      |");
 420     mvwaddstr(lookdeer2, 8, 8, "\\/      |");
 421     mvwaddstr(lookdeer2, 9, 9, "|>     |>");
 422
 423     /* lookdeer3 */
 424     mvwaddstr(lookdeer3, 0, 16, "\\/     \\/");
 425     mvwaddstr(lookdeer3, 1, 17, "\\Y/ \\Y/");
 426     mvwaddstr(lookdeer3, 2, 19, "\\=/");
 427     mvwaddstr(lookdeer3, 3, 17, "^\\o o/^");
 428     mvwaddstr(lookdeer3, 4, 17, "//( )");
 429     mvwaddstr(lookdeer3, 5, 7, "^~~~~~~~~// \\O/");
 430     mvwaddstr(lookdeer3, 6, 6, "( ()_____( /");
 431     mvwaddstr(lookdeer3, 7, 6, "/ /       /");
 432     mvwaddstr(lookdeer3, 8, 5, "|/          \\");
 433     mvwaddstr(lookdeer3, 9, 5, "/>           \\>");
 434
 435     /* lookdeer4 */
 436     mvwaddstr(lookdeer4, 0, 16, "\\/     \\/");
 437     mvwaddstr(lookdeer4, 1, 17, "\\Y/ \\Y/");
 438     mvwaddstr(lookdeer4, 2, 19, "\\=/");
 439     mvwaddstr(lookdeer4, 3, 17, "^\\o o/^");
 440     mvwaddstr(lookdeer4, 4, 17, "//( )");
 441     mvwaddstr(lookdeer4, 5, 7, "^~~~~~~~~// \\O/");
 442     mvwaddstr(lookdeer4, 6, 6, "( )______( /");
 443     mvwaddstr(lookdeer4, 7, 5, "(/          \\");
 444     mvwaddstr(lookdeer4, 8, 0, "v___=             ----^");
 445
 446         /***********************************************/
 447     cbreak();
 448     nodelay(stdscr, TRUE);
 449     for (;;) {
 450         clear();
 451         werase(treescrn);
 452         touchwin(w_del_msg);
 453         touchwin(treescrn);
 454         werase(treescrn2);
 455         touchwin(treescrn2);
 456         werase(treescrn8);
 457         touchwin(treescrn8);
 458         refresh();
 459         look_out(150);
 460         boxit();
 461         refresh();
 462         look_out(150);
 463         seas();
 464         refresh();
 465         look_out(150);
 466         greet();
 467         refresh();
 468         look_out(150);
 469         fromwho();
 470         refresh();
 471         look_out(150);
 472         tree();
 473         look_out(150);
 474         balls();
 475         look_out(150);
 476         star();
 477         look_out(150);
 478         strng1();
 479         strng2();
 480         strng3();
 481         strng4();
 482         strng5();
 483
 484         /* set up the windows for our blinking trees */
 485         /* **************************************** */
 486         /* treescrn3 */
 487
 488         overlay(treescrn, treescrn3);
 489
 490         /*balls */
 491         mvwaddch(treescrn3, 4, 18, ' ');
 492         mvwaddch(treescrn3, 7, 6, ' ');
 493         mvwaddch(treescrn3, 8, 19, ' ');
 494         mvwaddch(treescrn3, 11, 22, ' ');
 495
 496         /*star */
 497         mvwaddch(treescrn3, 0, 12, '*');
 498
 499         /*strng1 */
 500         mvwaddch(treescrn3, 3, 11, ' ');
 501
 502         /*strng2 */
 503         mvwaddch(treescrn3, 5, 13, ' ');
 504         mvwaddch(treescrn3, 6, 10, ' ');
 505
 506         /*strng3 */
 507         mvwaddch(treescrn3, 7, 16, ' ');
 508         mvwaddch(treescrn3, 7, 14, ' ');
 509
 510         /*strng4 */
 511         mvwaddch(treescrn3, 10, 13, ' ');
 512         mvwaddch(treescrn3, 10, 10, ' ');
 513         mvwaddch(treescrn3, 11, 8, ' ');
 514
 515         /*strng5 */
 516         mvwaddch(treescrn3, 11, 18, ' ');
 517         mvwaddch(treescrn3, 12, 13, ' ');
 518
 519         /* treescrn4 */
 520
 521         overlay(treescrn, treescrn4);
 522
 523         /*balls */
 524         mvwaddch(treescrn4, 3, 9, ' ');
 525         mvwaddch(treescrn4, 4, 16, ' ');
 526         mvwaddch(treescrn4, 7, 6, ' ');
 527         mvwaddch(treescrn4, 8, 19, ' ');
 528         mvwaddch(treescrn4, 11, 2, ' ');
 529         mvwaddch(treescrn4, 12, 23, ' ');
 530
 531         /*star */
 532         wstandout(treescrn4);
 533         mvwaddch(treescrn4, 0, 12, '*');
 534         wstandend(treescrn4);
 535
 536         /*strng1 */
 537         mvwaddch(treescrn4, 3, 13, ' ');
 538
 539         /*strng2 */
 540
 541         /*strng3 */
 542         mvwaddch(treescrn4, 7, 15, ' ');
 543         mvwaddch(treescrn4, 8, 11, ' ');
 544
 545         /*strng4 */
 546         mvwaddch(treescrn4, 9, 16, ' ');
 547         mvwaddch(treescrn4, 10, 12, ' ');
 548         mvwaddch(treescrn4, 11, 8, ' ');
 549
 550         /*strng5 */
 551         mvwaddch(treescrn4, 11, 18, ' ');
 552         mvwaddch(treescrn4, 12, 14, ' ');
 553
 554         /* treescrn5 */
 555
 556         overlay(treescrn, treescrn5);
 557
 558         /*balls */
 559         mvwaddch(treescrn5, 3, 15, ' ');
 560         mvwaddch(treescrn5, 10, 20, ' ');
 561         mvwaddch(treescrn5, 12, 1, ' ');
 562
 563         /*star */
 564         mvwaddch(treescrn5, 0, 12, '*');
 565
 566         /*strng1 */
 567         mvwaddch(treescrn5, 3, 11, ' ');
 568
 569         /*strng2 */
 570         mvwaddch(treescrn5, 5, 12, ' ');
 571
 572         /*strng3 */
 573         mvwaddch(treescrn5, 7, 14, ' ');
 574         mvwaddch(treescrn5, 8, 10, ' ');
 575
 576         /*strng4 */
 577         mvwaddch(treescrn5, 9, 15, ' ');
 578         mvwaddch(treescrn5, 10, 11, ' ');
 579         mvwaddch(treescrn5, 11, 7, ' ');
 580
 581         /*strng5 */
 582         mvwaddch(treescrn5, 11, 17, ' ');
 583         mvwaddch(treescrn5, 12, 13, ' ');
 584
 585         /* treescrn6 */
 586
 587         overlay(treescrn, treescrn6);
 588
 589         /*balls */
 590         mvwaddch(treescrn6, 6, 7, ' ');
 591         mvwaddch(treescrn6, 7, 18, ' ');
 592         mvwaddch(treescrn6, 10, 4, ' ');
 593         mvwaddch(treescrn6, 11, 23, ' ');
 594
 595         /*star */
 596         wstandout(treescrn6);
 597         mvwaddch(treescrn6, 0, 12, '*');
 598         wstandend(treescrn6);
 599
 600         /*strng1 */
 601
 602         /*strng2 */
 603         mvwaddch(treescrn6, 5, 11, ' ');
 604
 605         /*strng3 */
 606         mvwaddch(treescrn6, 7, 13, ' ');
 607         mvwaddch(treescrn6, 8, 9, ' ');
 608
 609         /*strng4 */
 610         mvwaddch(treescrn6, 9, 14, ' ');
 611         mvwaddch(treescrn6, 10, 10, ' ');
 612         mvwaddch(treescrn6, 11, 6, ' ');
 613
 614         /*strng5 */
 615         mvwaddch(treescrn6, 11, 16, ' ');
 616         mvwaddch(treescrn6, 12, 12, ' ');
 617
 618         /* treescrn7 */
 619
 620         overlay(treescrn, treescrn7);
 621
 622         /*balls */
 623         mvwaddch(treescrn7, 3, 15, ' ');
 624         mvwaddch(treescrn7, 6, 7, ' ');
 625         mvwaddch(treescrn7, 7, 18, ' ');
 626         mvwaddch(treescrn7, 10, 4, ' ');
 627         mvwaddch(treescrn7, 11, 22, ' ');
 628
 629         /*star */
 630         mvwaddch(treescrn7, 0, 12, '*');
 631
 632         /*strng1 */
 633         mvwaddch(treescrn7, 3, 12, ' ');
 634
 635         /*strng2 */
 636         mvwaddch(treescrn7, 5, 13, ' ');
 637         mvwaddch(treescrn7, 6, 9, ' ');
 638
 639         /*strng3 */
 640         mvwaddch(treescrn7, 7, 15, ' ');
 641         mvwaddch(treescrn7, 8, 11, ' ');
 642
 643         /*strng4 */
 644         mvwaddch(treescrn7, 9, 16, ' ');
 645         mvwaddch(treescrn7, 10, 12, ' ');
 646         mvwaddch(treescrn7, 11, 8, ' ');
 647
 648         /*strng5 */
 649         mvwaddch(treescrn7, 11, 18, ' ');
 650         mvwaddch(treescrn7, 12, 14, ' ');
 651
 652         look_out(150);
 653         reindeer();
 654
 655         touchwin(w_holiday);
 656         wrefresh(w_holiday);
 657         wrefresh(w_del_msg);
 658
 659         look_out(500);
 660         for (loopy = 0; loopy < 100; loopy++) {
 661             blinkit();
 662         }
 663
 664 #ifdef NOLOOP
 665         done(0);
 666 #endif
 667     }
 668     /*NOTREACHED */
 669 }
 670
 671 static int
 672 boxit(void)
 673 {
 674     int x = 0;
 675
 676     while (x < 20) {
 677         mvaddch(x, 7, '|');
 678         ++x;
 679     }
 680
 681     x = 8;
 682
 683     while (x < 80) {
 684         mvaddch(19, x, '_');
 685         ++x;
 686     }
 687
 688     x = 0;
 689
 690     while (x < 80) {
 691         mvaddch(22, x, '_');
 692         ++x;
 693     }
 694
 695     return (0);
 696 }
 697
 698 static int
 699 seas(void)
 700 {
 701     mvaddch(4, 1, 'S');
 702     mvaddch(6, 1, 'E');
 703     mvaddch(8, 1, 'A');
 704     mvaddch(10, 1, 'S');
 705     mvaddch(12, 1, 'O');
 706     mvaddch(14, 1, 'N');
 707     mvaddch(16, 1, '`');
 708     mvaddch(18, 1, 'S');
 709
 710     return (0);
 711 }
 712
 713 static int
 714 greet(void)
 715 {
 716     mvaddch(3, 5, 'G');
 717     mvaddch(5, 5, 'R');
 718     mvaddch(7, 5, 'E');
 719     mvaddch(9, 5, 'E');
 720     mvaddch(11, 5, 'T');
 721     mvaddch(13, 5, 'I');
 722     mvaddch(15, 5, 'N');
 723     mvaddch(17, 5, 'G');
 724     mvaddch(19, 5, 'S');
 725
 726     return (0);
 727 }
 728
 729 static int
 730 fromwho(void)
 731 {
 732     mvaddstr(21, 13, FROMWHO);
 733     return (0);
 734 }
 735
 736 static int
 737 tree(void)
 738 {
 739     set_color(treescrn, COLOR_GREEN);
 740     mvwaddch(treescrn, 1, 11, (chtype) '/');
 741     mvwaddch(treescrn, 2, 11, (chtype) '/');
 742     mvwaddch(treescrn, 3, 10, (chtype) '/');
 743     mvwaddch(treescrn, 4, 9, (chtype) '/');
 744     mvwaddch(treescrn, 5, 9, (chtype) '/');
 745     mvwaddch(treescrn, 6, 8, (chtype) '/');
 746     mvwaddch(treescrn, 7, 7, (chtype) '/');
 747     mvwaddch(treescrn, 8, 6, (chtype) '/');
 748     mvwaddch(treescrn, 9, 6, (chtype) '/');
 749     mvwaddch(treescrn, 10, 5, (chtype) '/');
 750     mvwaddch(treescrn, 11, 3, (chtype) '/');
 751     mvwaddch(treescrn, 12, 2, (chtype) '/');
 752
 753     mvwaddch(treescrn, 1, 13, (chtype) '\\');
 754     mvwaddch(treescrn, 2, 13, (chtype) '\\');
 755     mvwaddch(treescrn, 3, 14, (chtype) '\\');
 756     mvwaddch(treescrn, 4, 15, (chtype) '\\');
 757     mvwaddch(treescrn, 5, 15, (chtype) '\\');
 758     mvwaddch(treescrn, 6, 16, (chtype) '\\');
 759     mvwaddch(treescrn, 7, 17, (chtype) '\\');
 760     mvwaddch(treescrn, 8, 18, (chtype) '\\');
 761     mvwaddch(treescrn, 9, 18, (chtype) '\\');
 762     mvwaddch(treescrn, 10, 19, (chtype) '\\');
 763     mvwaddch(treescrn, 11, 21, (chtype) '\\');
 764     mvwaddch(treescrn, 12, 22, (chtype) '\\');
 765
 766     mvwaddch(treescrn, 4, 10, (chtype) '_');
 767     mvwaddch(treescrn, 4, 14, (chtype) '_');
 768     mvwaddch(treescrn, 8, 7, (chtype) '_');
 769     mvwaddch(treescrn, 8, 17, (chtype) '_');
 770
 771     mvwaddstr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\");
 772
 773     mvwaddstr(treescrn, 14, 11, "| |");
 774     mvwaddstr(treescrn, 15, 11, "|_|");
 775
 776     unset_color(treescrn);
 777     wrefresh(treescrn);
 778     wrefresh(w_del_msg);
 779
 780     return (0);
 781 }
 782
 783 static int
 784 balls(void)
 785 {
 786     overlay(treescrn, treescrn2);
 787
 788     set_color(treescrn2, COLOR_BLUE);
 789     mvwaddch(treescrn2, 3, 9, (chtype) '@');
 790     mvwaddch(treescrn2, 3, 15, (chtype) '@');
 791     mvwaddch(treescrn2, 4, 8, (chtype) '@');
 792     mvwaddch(treescrn2, 4, 16, (chtype) '@');
 793     mvwaddch(treescrn2, 5, 7, (chtype) '@');
 794     mvwaddch(treescrn2, 5, 17, (chtype) '@');
 795     mvwaddch(treescrn2, 7, 6, (chtype) '@');
 796     mvwaddch(treescrn2, 7, 18, (chtype) '@');
 797     mvwaddch(treescrn2, 8, 5, (chtype) '@');
 798     mvwaddch(treescrn2, 8, 19, (chtype) '@');
 799     mvwaddch(treescrn2, 10, 4, (chtype) '@');
 800     mvwaddch(treescrn2, 10, 20, (chtype) '@');
 801     mvwaddch(treescrn2, 11, 2, (chtype) '@');
 802     mvwaddch(treescrn2, 11, 22, (chtype) '@');
 803     mvwaddch(treescrn2, 12, 1, (chtype) '@');
 804     mvwaddch(treescrn2, 12, 23, (chtype) '@');
 805
 806     unset_color(treescrn2);
 807     wrefresh(treescrn2);
 808     wrefresh(w_del_msg);
 809     return (0);
 810 }
 811
 812 static int
 813 star(void)
 814 {
 815     wattrset(treescrn2, A_BOLD | A_BLINK);
 816     set_color(treescrn2, COLOR_YELLOW);
 817
 818     mvwaddch(treescrn2, 0, 12, (chtype) '*');
 819     wstandend(treescrn2);
 820
 821     unset_color(treescrn2);
 822     wrefresh(treescrn2);
 823     wrefresh(w_del_msg);
 824     return (0);
 825 }
 826
 827 static int
 828 strng1(void)
 829 {
 830     wattrset(treescrn2, A_BOLD | A_BLINK);
 831     set_color(treescrn2, COLOR_WHITE);
 832
 833     mvwaddch(treescrn2, 3, 13, (chtype) '\'');
 834     mvwaddch(treescrn2, 3, 12, (chtype) ':');
 835     mvwaddch(treescrn2, 3, 11, (chtype) '.');
 836
 837     wattroff(treescrn2, A_BOLD | A_BLINK);
 838     unset_color(treescrn2);
 839
 840     wrefresh(treescrn2);
 841     wrefresh(w_del_msg);
 842     return (0);
 843 }
 844
 845 static int
 846 strng2(void)
 847 {
 848     wattrset(treescrn2, A_BOLD | A_BLINK);
 849     set_color(treescrn2, COLOR_WHITE);
 850
 851     mvwaddch(treescrn2, 5, 14, (chtype) '\'');
 852     mvwaddch(treescrn2, 5, 13, (chtype) ':');
 853     mvwaddch(treescrn2, 5, 12, (chtype) '.');
 854     mvwaddch(treescrn2, 5, 11, (chtype) ',');
 855     mvwaddch(treescrn2, 6, 10, (chtype) '\'');
 856     mvwaddch(treescrn2, 6, 9, (chtype) ':');
 857
 858     wattroff(treescrn2, A_BOLD | A_BLINK);
 859     unset_color(treescrn2);
 860
 861     wrefresh(treescrn2);
 862     wrefresh(w_del_msg);
 863     return (0);
 864 }
 865
 866 static int
 867 strng3(void)
 868 {
 869     wattrset(treescrn2, A_BOLD | A_BLINK);
 870     set_color(treescrn2, COLOR_WHITE);
 871
 872     mvwaddch(treescrn2, 7, 16, (chtype) '\'');
 873     mvwaddch(treescrn2, 7, 15, (chtype) ':');
 874     mvwaddch(treescrn2, 7, 14, (chtype) '.');
 875     mvwaddch(treescrn2, 7, 13, (chtype) ',');
 876     mvwaddch(treescrn2, 8, 12, (chtype) '\'');
 877     mvwaddch(treescrn2, 8, 11, (chtype) ':');
 878     mvwaddch(treescrn2, 8, 10, (chtype) '.');
 879     mvwaddch(treescrn2, 8, 9, (chtype) ',');
 880
 881     wattroff(treescrn2, A_BOLD | A_BLINK);
 882     unset_color(treescrn2);
 883
 884     wrefresh(treescrn2);
 885     wrefresh(w_del_msg);
 886     return (0);
 887 }
 888
 889 static int
 890 strng4(void)
 891 {
 892     wattrset(treescrn2, A_BOLD | A_BLINK);
 893     set_color(treescrn2, COLOR_WHITE);
 894
 895     mvwaddch(treescrn2, 9, 17, (chtype) '\'');
 896     mvwaddch(treescrn2, 9, 16, (chtype) ':');
 897     mvwaddch(treescrn2, 9, 15, (chtype) '.');
 898     mvwaddch(treescrn2, 9, 14, (chtype) ',');
 899     mvwaddch(treescrn2, 10, 13, (chtype) '\'');
 900     mvwaddch(treescrn2, 10, 12, (chtype) ':');
 901     mvwaddch(treescrn2, 10, 11, (chtype) '.');
 902     mvwaddch(treescrn2, 10, 10, (chtype) ',');
 903     mvwaddch(treescrn2, 11, 9, (chtype) '\'');
 904     mvwaddch(treescrn2, 11, 8, (chtype) ':');
 905     mvwaddch(treescrn2, 11, 7, (chtype) '.');
 906     mvwaddch(treescrn2, 11, 6, (chtype) ',');
 907     mvwaddch(treescrn2, 12, 5, (chtype) '\'');
 908
 909     wattroff(treescrn2, A_BOLD | A_BLINK);
 910     unset_color(treescrn2);
 911
 912     wrefresh(treescrn2);
 913     wrefresh(w_del_msg);
 914     return (0);
 915 }
 916
 917 static int
 918 strng5(void)
 919 {
 920     wattrset(treescrn2, A_BOLD | A_BLINK);
 921     set_color(treescrn2, COLOR_WHITE);
 922
 923     mvwaddch(treescrn2, 11, 19, (chtype) '\'');
 924     mvwaddch(treescrn2, 11, 18, (chtype) ':');
 925     mvwaddch(treescrn2, 11, 17, (chtype) '.');
 926     mvwaddch(treescrn2, 11, 16, (chtype) ',');
 927     mvwaddch(treescrn2, 12, 15, (chtype) '\'');
 928     mvwaddch(treescrn2, 12, 14, (chtype) ':');
 929     mvwaddch(treescrn2, 12, 13, (chtype) '.');
 930     mvwaddch(treescrn2, 12, 12, (chtype) ',');
 931
 932     wattroff(treescrn2, A_BOLD | A_BLINK);
 933     unset_color(treescrn2);
 934
 935     /* save a fully lit tree */
 936     overlay(treescrn2, treescrn);
 937
 938     wrefresh(treescrn2);
 939     wrefresh(w_del_msg);
 940     return (0);
 941 }
 942
 943 static int
 944 blinkit(void)
 945 {
 946     static int cycle;
 947
 948     if (cycle > 4) {
 949         cycle = 0;
 950     }
 951
 952     touchwin(treescrn8);
 953
 954     switch (cycle) {
 955     case 0:
 956         overlay(treescrn3, treescrn8);
 957         wrefresh(treescrn8);
 958         wrefresh(w_del_msg);
 959         break;
 960     case 1:
 961         overlay(treescrn4, treescrn8);
 962         wrefresh(treescrn8);
 963         wrefresh(w_del_msg);
 964         break;
 965     case 2:
 966         overlay(treescrn5, treescrn8);
 967         wrefresh(treescrn8);
 968         wrefresh(w_del_msg);
 969         break;
 970     case 3:
 971         overlay(treescrn6, treescrn8);
 972         wrefresh(treescrn8);
 973         wrefresh(w_del_msg);
 974         break;
 975     case 4:
 976         overlay(treescrn7, treescrn8);
 977         wrefresh(treescrn8);
 978         wrefresh(w_del_msg);
 979         break;
 980     }
 981     touchwin(treescrn8);
 982
 983     /*ALL ON************************************************** */
 984
 985     overlay(treescrn, treescrn8);
 986     wrefresh(treescrn8);
 987     wrefresh(w_del_msg);
 988
 989     ++cycle;
 990     return (0);
 991 }
 992
 993 static void
 994 deer_step(WINDOW *win, int y, int x)
 995 {
 996     mvwin(win, y, x);
 997     wrefresh(win);
 998     wrefresh(w_del_msg);
 999     look_out(5);
1000 }
1001
1002 static int
1003 reindeer(void)
1004 {
1005     int looper;
1006     y_pos = 0;
1007
1008     for (x_pos = 70; x_pos > 62; x_pos--) {
1009         if (x_pos < 62) {
1010             y_pos = 1;
1011         }
1012         for (looper = 0; looper < 4; looper++) {
1013             mvwaddch(dotdeer0, y_pos, x_pos, (chtype) '.');
1014             wrefresh(dotdeer0);
1015             wrefresh(w_del_msg);
1016             werase(dotdeer0);
1017             wrefresh(dotdeer0);
1018             wrefresh(w_del_msg);
1019             look_out(50);
1020         }
1021     }
1022
1023     y_pos = 2;
1024
1025     for (; x_pos > 50; x_pos--) {
1026         for (looper = 0; looper < 4; looper++) {
1027
1028             if (x_pos < 56) {
1029                 y_pos = 3;
1030
1031                 mvwaddch(stardeer0, y_pos, x_pos, (chtype) '*');
1032                 wrefresh(stardeer0);
1033                 wrefresh(w_del_msg);
1034                 werase(stardeer0);
1035                 wrefresh(stardeer0);
1036                 wrefresh(w_del_msg);
1037             } else {
1038                 mvwaddch(dotdeer0, y_pos, x_pos, (chtype) '*');
1039                 wrefresh(dotdeer0);
1040                 wrefresh(w_del_msg);
1041                 werase(dotdeer0);
1042                 wrefresh(dotdeer0);
1043                 wrefresh(w_del_msg);
1044             }
1045         }
1046     }
1047
1048     x_pos = 58;
1049
1050     for (y_pos = 2; y_pos < 5; y_pos++) {
1051
1052         touchwin(lildeer0);
1053         wrefresh(lildeer0);
1054         wrefresh(w_del_msg);
1055
1056         for (looper = 0; looper < 4; looper++) {
1057             deer_step(lildeer3, y_pos, x_pos);
1058             deer_step(lildeer2, y_pos, x_pos);
1059             deer_step(lildeer1, y_pos, x_pos);
1060             deer_step(lildeer2, y_pos, x_pos);
1061             deer_step(lildeer3, y_pos, x_pos);
1062
1063             touchwin(lildeer0);
1064             wrefresh(lildeer0);
1065             wrefresh(w_del_msg);
1066
1067             x_pos -= 2;
1068         }
1069     }
1070
1071     x_pos = 35;
1072
1073     for (y_pos = 5; y_pos < 10; y_pos++) {
1074
1075         touchwin(middeer0);
1076         wrefresh(middeer0);
1077         wrefresh(w_del_msg);
1078
1079         for (looper = 0; looper < 2; looper++) {
1080             deer_step(middeer3, y_pos, x_pos);
1081             deer_step(middeer2, y_pos, x_pos);
1082             deer_step(middeer1, y_pos, x_pos);
1083             deer_step(middeer2, y_pos, x_pos);
1084             deer_step(middeer3, y_pos, x_pos);
1085
1086             touchwin(middeer0);
1087             wrefresh(middeer0);
1088             wrefresh(w_del_msg);
1089
1090             x_pos -= 3;
1091         }
1092     }
1093
1094     look_out(300);
1095
1096     y_pos = 1;
1097
1098     for (x_pos = 8; x_pos < 16; x_pos++) {
1099         deer_step(bigdeer4, y_pos, x_pos);
1100         deer_step(bigdeer3, y_pos, x_pos);
1101         deer_step(bigdeer2, y_pos, x_pos);
1102         deer_step(bigdeer1, y_pos, x_pos);
1103         deer_step(bigdeer2, y_pos, x_pos);
1104         deer_step(bigdeer3, y_pos, x_pos);
1105         deer_step(bigdeer4, y_pos, x_pos);
1106         deer_step(bigdeer0, y_pos, x_pos);
1107     }
1108
1109     --x_pos;
1110
1111     for (looper = 0; looper < 6; looper++) {
1112         deer_step(lookdeer4, y_pos, x_pos);
1113         deer_step(lookdeer3, y_pos, x_pos);
1114         deer_step(lookdeer2, y_pos, x_pos);
1115         deer_step(lookdeer1, y_pos, x_pos);
1116         deer_step(lookdeer2, y_pos, x_pos);
1117         deer_step(lookdeer3, y_pos, x_pos);
1118         deer_step(lookdeer4, y_pos, x_pos);
1119     }
1120
1121     deer_step(lookdeer0, y_pos, x_pos);
1122
1123     for (; y_pos < 10; y_pos++) {
1124         for (looper = 0; looper < 2; looper++) {
1125             deer_step(bigdeer4, y_pos, x_pos);
1126             deer_step(bigdeer3, y_pos, x_pos);
1127             deer_step(bigdeer2, y_pos, x_pos);
1128             deer_step(bigdeer1, y_pos, x_pos);
1129             deer_step(bigdeer2, y_pos, x_pos);
1130             deer_step(bigdeer3, y_pos, x_pos);
1131             deer_step(bigdeer4, y_pos, x_pos);
1132         }
1133         deer_step(bigdeer0, y_pos, x_pos);
1134     }
1135
1136     --y_pos;
1137
1138     deer_step(lookdeer3, y_pos, x_pos);
1139     return (0);
1140 }
1141
1142 static RETSIGTYPE
1143 done(int sig GCC_UNUSED)
1144 {
1145     CATCHALL(done);
1146
1147     move(LINES - 1, 0);
1148     refresh();
1149     endwin();
1150     curs_set(1);
1151
1152 #if NO_LEAKS
1153     if (my_pairs != 0)
1154         free(my_pairs);
1155 #endif
1156
1157     ExitProgram(EXIT_SUCCESS);
1158 }