HOME

Mini Shell 1.0
DIR:/usr/share/doc/ncurses-devel-5.9/test/
Current File : //usr/share/doc/ncurses-devel-5.9/test/xmas.c
/******************************************************************************/
/* asciixmas                                                                  */
/* December 1989             Larry Bartz           Indianapolis, IN           */
/*                                                                            */
/*                                                                            */
/* I'm dreaming of an ascii character-based monochrome Christmas,             */
/* Just like the one's I used to know!                                        */
/* Via a full duplex communications channel,                                  */
/* At 9600 bits per second,                                                   */
/* Even though it's kinda slow.                                               */
/*                                                                            */
/* I'm dreaming of an ascii character-based monochrome Christmas,             */
/* With ev'ry C program I write!                                              */
/* May your screen be merry and bright!                                       */
/* And may all your Christmases be amber or green,                            */
/* (for reduced eyestrain and improved visibility)!                           */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/* IMPLEMENTATION                                                             */
/*                                                                            */
/* Feel free to modify the defined string FROMWHO to reflect you, your        */
/* organization, your site, whatever.                                         */
/*                                                                            */
/* This really looks a lot better if you can turn off your cursor before      */
/* execution. I wanted to do that here but very few termcap entries or        */
/* terminfo definitions have the appropriate string defined. If you know      */
/* the string(s) for the terminal(s) you use or which your site supports,     */
/* you could call asciixmas from within a shell in which you issue the        */
/* string to the terminal. The cursor is distracting but it doesn't really    */
/* ruin the show.                                                             */
/*                                                                            */
/* At our site, we invoke this for our users just after login and the         */
/* determination of terminal type.                                            */
/*                                                                            */
/*                                                                            */
/* PORTABILITY                                                                */
/*                                                                            */
/* I wrote this using only the very simplest curses functions so that it      */
/* might be the most portable. I was personally able to test on five          */
/* different cpu/UNIX combinations.                                           */
/*                                                                            */
/*                                                                            */
/* COMPILE                                                                    */
/*                                                                            */
/* usually this:                                                              */
/*                                                                            */
/* cc -O asciixmas.c -lcurses -o asciixmas -s                                 */
/*                                                                            */
/*                                                                            */
/* Zilog S8000 models 11, 21, 31, etc with ZEUS variant of SYSTEM III         */
/* maybe other SYSTEM III also:                                               */
/*                                                                            */
/* cc asciixmas.c -lcurses -ltermlib -o asciixmas -s                          */
/*                                                                            */
/* as above with optional "peephole optimizer" installed:                     */
/*                                                                            */
/* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
/*                                                                            */
/*                                                                            */
/* Zilog S8000 models 32, 130 with WE32100 chip and SYS V, REL2               */
/* maybe 3B2 also?                                                            */
/*                                                                            */
/* cc -f -O -K sd asciixmas.c -lcurses -o asciixmas -s                        */
/*                                                                            */
/*                                                                            */
/* Pyramid, Sequent, any other "dual universe" types compile and execute      */
/* under either universe. The compile line for the ucb universe (as you       */
/* might expect) is the same as for SYS III UNIX:                             */
/*                                                                            */
/* cc -O asciixmas.c -lcurses -ltermlib -o asciixmas -s                       */
/*                                                                            */
/* The above compile will also hold true for other BSD systems. (I hope)      */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/* For the Scrooges out there among you who don't want this thing to loop     */
/* forever (or until the user hits a key), insert this into your compile      */
/* line just after "cc" :                                                     */
/*                                                                            */
/* -DNOLOOP                                                                   */
/*                                                                            */
/* like so:                                                                   */
/*                                                                            */
/* cc -DNOLOOP -O asciixmas.c -lcurses -o asciixmas -s                        */
/*                                                                            */
/*                                                                            */
/*                                                                            */
/******************************************************************************/

/*
 * $Id: xmas.c,v 1.28 2013/04/27 19:46:53 tom Exp $
 */
#include <test.priv.h>

#define FROMWHO "Mark Hessling - (M.Hessling@gu.edu.au)"

static int my_bg = COLOR_BLACK;
static int y_pos, x_pos;

static WINDOW *treescrn;
static WINDOW *treescrn2;
static WINDOW *treescrn3;
static WINDOW *treescrn4;
static WINDOW *treescrn5;
static WINDOW *treescrn6;
static WINDOW *treescrn7;
static WINDOW *treescrn8;
static WINDOW *dotdeer0;
static WINDOW *stardeer0;
static WINDOW *lildeer0;
static WINDOW *lildeer1;
static WINDOW *lildeer2;
static WINDOW *lildeer3;
static WINDOW *middeer0;
static WINDOW *middeer1;
static WINDOW *middeer2;
static WINDOW *middeer3;
static WINDOW *bigdeer0;
static WINDOW *bigdeer1;
static WINDOW *bigdeer2;
static WINDOW *bigdeer3;
static WINDOW *bigdeer4;
static WINDOW *lookdeer0;
static WINDOW *lookdeer1;
static WINDOW *lookdeer2;
static WINDOW *lookdeer3;
static WINDOW *lookdeer4;
static WINDOW *w_holiday;
static WINDOW *w_del_msg;
static bool *my_pairs;

static int boxit(void);
static int seas(void);
static int greet(void);
static int fromwho(void);
static int tree(void);
static int balls(void);
static int star(void);
static int strng1(void);
static int strng2(void);
static int strng3(void);
static int strng4(void);
static int strng5(void);
static int reindeer(void);
static int blinkit(void);

static void done(int sig) GCC_NORETURN;

static void
set_color(WINDOW *win, chtype color)
{
    if (has_colors()) {
	int n = (int) (color + 1);
	if (my_pairs == 0)
	    my_pairs = typeCalloc(bool, (size_t) (COLORS + 1));
	if (!my_pairs[n]) {
	    init_pair((short) n, (short) color, (short) my_bg);
	    my_pairs[n] = TRUE;
	}
	wattroff(win, A_COLOR);
	wattron(win, COLOR_PAIR(n));
    }
}

static void
unset_color(WINDOW *win)
{
    if (has_colors())
	(void) wattrset(win, COLOR_PAIR(0));
}

static void
look_out(int msecs)
{
    napms(msecs);
    if (getch() != ERR) {
	beep();
	done(0);
    }
}

int
main(int argc GCC_UNUSED, char **argv GCC_UNUSED)
{
    int loopy;

    setlocale(LC_ALL, "");

    initscr();
    noecho();
    nonl();
    refresh();

    CATCHALL(done);

    if (has_colors()) {
	start_color();
#if HAVE_USE_DEFAULT_COLORS
	if (use_default_colors() == OK)
	    my_bg = -1;
#endif
    }
    curs_set(0);

    if ((treescrn = newwin(16, 27, 3, 53)) == 0 ||
	(treescrn2 = newwin(16, 27, 3, 53)) == 0 ||
	(treescrn3 = newwin(16, 27, 3, 53)) == 0 ||
	(treescrn4 = newwin(16, 27, 3, 53)) == 0 ||
	(treescrn5 = newwin(16, 27, 3, 53)) == 0 ||
	(treescrn6 = newwin(16, 27, 3, 53)) == 0 ||
	(treescrn7 = newwin(16, 27, 3, 53)) == 0 ||
	(treescrn8 = newwin(16, 27, 3, 53)) == 0 ||

	(dotdeer0 = newwin(3, 71, 0, 8)) == 0 ||

	(stardeer0 = newwin(4, 56, 0, 8)) == 0 ||

	(lildeer0 = newwin(7, 53, 0, 8)) == 0 ||
	(lildeer1 = newwin(2, 4, 0, 0)) == 0 ||
	(lildeer2 = newwin(2, 4, 0, 0)) == 0 ||
	(lildeer3 = newwin(2, 4, 0, 0)) == 0 ||

	(middeer0 = newwin(15, 42, 0, 8)) == 0 ||
	(middeer1 = newwin(3, 7, 0, 0)) == 0 ||
	(middeer2 = newwin(3, 7, 0, 0)) == 0 ||
	(middeer3 = newwin(3, 7, 0, 0)) == 0 ||

	(bigdeer0 = newwin(10, 23, 0, 0)) == 0 ||
	(bigdeer1 = newwin(10, 23, 0, 0)) == 0 ||
	(bigdeer2 = newwin(10, 23, 0, 0)) == 0 ||
	(bigdeer3 = newwin(10, 23, 0, 0)) == 0 ||
	(bigdeer4 = newwin(10, 23, 0, 0)) == 0 ||

	(lookdeer0 = newwin(10, 25, 0, 0)) == 0 ||
	(lookdeer1 = newwin(10, 25, 0, 0)) == 0 ||
	(lookdeer2 = newwin(10, 25, 0, 0)) == 0 ||
	(lookdeer3 = newwin(10, 25, 0, 0)) == 0 ||
	(lookdeer4 = newwin(10, 25, 0, 0)) == 0 ||

	(w_holiday = newwin(1, 26, 3, 27)) == 0 ||

	(w_del_msg = newwin(1, 19, 23, 60)) == 0) {
	endwin();
	fprintf(stderr, "Cannot create windows - screen too small\n");
	ExitProgram(EXIT_FAILURE);
    }

    MvWAddStr(w_del_msg, 0, 0, "Hit any key to quit");

    MvWAddStr(w_holiday, 0, 0, "H A P P Y  H O L I D A Y S");

    /* set up the windows for our various reindeer */

    /* lildeer1 */
    MvWAddCh(lildeer1, 0, 0, (chtype) 'V');
    MvWAddCh(lildeer1, 1, 0, (chtype) '@');
    MvWAddCh(lildeer1, 1, 1, (chtype) '<');
    MvWAddCh(lildeer1, 1, 2, (chtype) '>');
    MvWAddCh(lildeer1, 1, 3, (chtype) '~');

    /* lildeer2 */
    MvWAddCh(lildeer2, 0, 0, (chtype) 'V');
    MvWAddCh(lildeer2, 1, 0, (chtype) '@');
    MvWAddCh(lildeer2, 1, 1, (chtype) '|');
    MvWAddCh(lildeer2, 1, 2, (chtype) '|');
    MvWAddCh(lildeer2, 1, 3, (chtype) '~');

    /* lildeer3 */
    MvWAddCh(lildeer3, 0, 0, (chtype) 'V');
    MvWAddCh(lildeer3, 1, 0, (chtype) '@');
    MvWAddCh(lildeer3, 1, 1, (chtype) '>');
    MvWAddCh(lildeer3, 1, 2, (chtype) '<');
    MvWAddCh(lildeer2, 1, 3, (chtype) '~');

    /* middeer1 */
    MvWAddCh(middeer1, 0, 2, (chtype) 'y');
    MvWAddCh(middeer1, 0, 3, (chtype) 'y');
    MvWAddCh(middeer1, 1, 2, (chtype) '0');
    MvWAddCh(middeer1, 1, 3, (chtype) '(');
    MvWAddCh(middeer1, 1, 4, (chtype) '=');
    MvWAddCh(middeer1, 1, 5, (chtype) ')');
    MvWAddCh(middeer1, 1, 6, (chtype) '~');
    MvWAddCh(middeer1, 2, 3, (chtype) '\\');
    MvWAddCh(middeer1, 2, 4, (chtype) '/');

    /* middeer2 */
    MvWAddCh(middeer2, 0, 2, (chtype) 'y');
    MvWAddCh(middeer2, 0, 3, (chtype) 'y');
    MvWAddCh(middeer2, 1, 2, (chtype) '0');
    MvWAddCh(middeer2, 1, 3, (chtype) '(');
    MvWAddCh(middeer2, 1, 4, (chtype) '=');
    MvWAddCh(middeer2, 1, 5, (chtype) ')');
    MvWAddCh(middeer2, 1, 6, (chtype) '~');
    MvWAddCh(middeer2, 2, 3, (chtype) '|');
    MvWAddCh(middeer2, 2, 5, (chtype) '|');

    /* middeer3 */
    MvWAddCh(middeer3, 0, 2, (chtype) 'y');
    MvWAddCh(middeer3, 0, 3, (chtype) 'y');
    MvWAddCh(middeer3, 1, 2, (chtype) '0');
    MvWAddCh(middeer3, 1, 3, (chtype) '(');
    MvWAddCh(middeer3, 1, 4, (chtype) '=');
    MvWAddCh(middeer3, 1, 5, (chtype) ')');
    MvWAddCh(middeer3, 1, 6, (chtype) '~');
    MvWAddCh(middeer3, 2, 2, (chtype) '/');
    MvWAddCh(middeer3, 2, 6, (chtype) '\\');

    /* bigdeer1 */
    MvWAddCh(bigdeer1, 0, 17, (chtype) '\\');
    MvWAddCh(bigdeer1, 0, 18, (chtype) '/');
    MvWAddCh(bigdeer1, 0, 20, (chtype) '\\');
    MvWAddCh(bigdeer1, 0, 21, (chtype) '/');
    MvWAddCh(bigdeer1, 1, 18, (chtype) '\\');
    MvWAddCh(bigdeer1, 1, 20, (chtype) '/');
    MvWAddCh(bigdeer1, 2, 19, (chtype) '|');
    MvWAddCh(bigdeer1, 2, 20, (chtype) '_');
    MvWAddCh(bigdeer1, 3, 18, (chtype) '/');
    MvWAddCh(bigdeer1, 3, 19, (chtype) '^');
    MvWAddCh(bigdeer1, 3, 20, (chtype) '0');
    MvWAddCh(bigdeer1, 3, 21, (chtype) '\\');
    MvWAddCh(bigdeer1, 4, 17, (chtype) '/');
    MvWAddCh(bigdeer1, 4, 18, (chtype) '/');
    MvWAddCh(bigdeer1, 4, 19, (chtype) '\\');
    MvWAddCh(bigdeer1, 4, 22, (chtype) '\\');
    MvWAddStr(bigdeer1, 5, 7, "^~~~~~~~~//  ~~U");
    MvWAddStr(bigdeer1, 6, 7, "( \\_____( /");
    MvWAddStr(bigdeer1, 7, 8, "( )    /");
    MvWAddStr(bigdeer1, 8, 9, "\\\\   /");
    MvWAddStr(bigdeer1, 9, 11, "\\>/>");

    /* bigdeer2 */
    MvWAddCh(bigdeer2, 0, 17, (chtype) '\\');
    MvWAddCh(bigdeer2, 0, 18, (chtype) '/');
    MvWAddCh(bigdeer2, 0, 20, (chtype) '\\');
    MvWAddCh(bigdeer2, 0, 21, (chtype) '/');
    MvWAddCh(bigdeer2, 1, 18, (chtype) '\\');
    MvWAddCh(bigdeer2, 1, 20, (chtype) '/');
    MvWAddCh(bigdeer2, 2, 19, (chtype) '|');
    MvWAddCh(bigdeer2, 2, 20, (chtype) '_');
    MvWAddCh(bigdeer2, 3, 18, (chtype) '/');
    MvWAddCh(bigdeer2, 3, 19, (chtype) '^');
    MvWAddCh(bigdeer2, 3, 20, (chtype) '0');
    MvWAddCh(bigdeer2, 3, 21, (chtype) '\\');
    MvWAddCh(bigdeer2, 4, 17, (chtype) '/');
    MvWAddCh(bigdeer2, 4, 18, (chtype) '/');
    MvWAddCh(bigdeer2, 4, 19, (chtype) '\\');
    MvWAddCh(bigdeer2, 4, 22, (chtype) '\\');
    MvWAddStr(bigdeer2, 5, 7, "^~~~~~~~~//  ~~U");
    MvWAddStr(bigdeer2, 6, 7, "(( )____( /");
    MvWAddStr(bigdeer2, 7, 7, "( /      |");
    MvWAddStr(bigdeer2, 8, 8, "\\/      |");
    MvWAddStr(bigdeer2, 9, 9, "|>     |>");

    /* bigdeer3 */
    MvWAddCh(bigdeer3, 0, 17, (chtype) '\\');
    MvWAddCh(bigdeer3, 0, 18, (chtype) '/');
    MvWAddCh(bigdeer3, 0, 20, (chtype) '\\');
    MvWAddCh(bigdeer3, 0, 21, (chtype) '/');
    MvWAddCh(bigdeer3, 1, 18, (chtype) '\\');
    MvWAddCh(bigdeer3, 1, 20, (chtype) '/');
    MvWAddCh(bigdeer3, 2, 19, (chtype) '|');
    MvWAddCh(bigdeer3, 2, 20, (chtype) '_');
    MvWAddCh(bigdeer3, 3, 18, (chtype) '/');
    MvWAddCh(bigdeer3, 3, 19, (chtype) '^');
    MvWAddCh(bigdeer3, 3, 20, (chtype) '0');
    MvWAddCh(bigdeer3, 3, 21, (chtype) '\\');
    MvWAddCh(bigdeer3, 4, 17, (chtype) '/');
    MvWAddCh(bigdeer3, 4, 18, (chtype) '/');
    MvWAddCh(bigdeer3, 4, 19, (chtype) '\\');
    MvWAddCh(bigdeer3, 4, 22, (chtype) '\\');
    MvWAddStr(bigdeer3, 5, 7, "^~~~~~~~~//  ~~U");
    MvWAddStr(bigdeer3, 6, 6, "( ()_____( /");
    MvWAddStr(bigdeer3, 7, 6, "/ /       /");
    MvWAddStr(bigdeer3, 8, 5, "|/          \\");
    MvWAddStr(bigdeer3, 9, 5, "/>           \\>");

    /* bigdeer4 */
    MvWAddCh(bigdeer4, 0, 17, (chtype) '\\');
    MvWAddCh(bigdeer4, 0, 18, (chtype) '/');
    MvWAddCh(bigdeer4, 0, 20, (chtype) '\\');
    MvWAddCh(bigdeer4, 0, 21, (chtype) '/');
    MvWAddCh(bigdeer4, 1, 18, (chtype) '\\');
    MvWAddCh(bigdeer4, 1, 20, (chtype) '/');
    MvWAddCh(bigdeer4, 2, 19, (chtype) '|');
    MvWAddCh(bigdeer4, 2, 20, (chtype) '_');
    MvWAddCh(bigdeer4, 3, 18, (chtype) '/');
    MvWAddCh(bigdeer4, 3, 19, (chtype) '^');
    MvWAddCh(bigdeer4, 3, 20, (chtype) '0');
    MvWAddCh(bigdeer4, 3, 21, (chtype) '\\');
    MvWAddCh(bigdeer4, 4, 17, (chtype) '/');
    MvWAddCh(bigdeer4, 4, 18, (chtype) '/');
    MvWAddCh(bigdeer4, 4, 19, (chtype) '\\');
    MvWAddCh(bigdeer4, 4, 22, (chtype) '\\');
    MvWAddStr(bigdeer4, 5, 7, "^~~~~~~~~//  ~~U");
    MvWAddStr(bigdeer4, 6, 6, "( )______( /");
    MvWAddStr(bigdeer4, 7, 5, "(/          \\");
    MvWAddStr(bigdeer4, 8, 0, "v___=             ----^");

    /* lookdeer1 */
    MvWAddStr(lookdeer1, 0, 16, "\\/     \\/");
    MvWAddStr(lookdeer1, 1, 17, "\\Y/ \\Y/");
    MvWAddStr(lookdeer1, 2, 19, "\\=/");
    MvWAddStr(lookdeer1, 3, 17, "^\\o o/^");
    MvWAddStr(lookdeer1, 4, 17, "//( )");
    MvWAddStr(lookdeer1, 5, 7, "^~~~~~~~~// \\O/");
    MvWAddStr(lookdeer1, 6, 7, "( \\_____( /");
    MvWAddStr(lookdeer1, 7, 8, "( )    /");
    MvWAddStr(lookdeer1, 8, 9, "\\\\   /");
    MvWAddStr(lookdeer1, 9, 11, "\\>/>");

    /* lookdeer2 */
    MvWAddStr(lookdeer2, 0, 16, "\\/     \\/");
    MvWAddStr(lookdeer2, 1, 17, "\\Y/ \\Y/");
    MvWAddStr(lookdeer2, 2, 19, "\\=/");
    MvWAddStr(lookdeer2, 3, 17, "^\\o o/^");
    MvWAddStr(lookdeer2, 4, 17, "//( )");
    MvWAddStr(lookdeer2, 5, 7, "^~~~~~~~~// \\O/");
    MvWAddStr(lookdeer2, 6, 7, "(( )____( /");
    MvWAddStr(lookdeer2, 7, 7, "( /      |");
    MvWAddStr(lookdeer2, 8, 8, "\\/      |");
    MvWAddStr(lookdeer2, 9, 9, "|>     |>");

    /* lookdeer3 */
    MvWAddStr(lookdeer3, 0, 16, "\\/     \\/");
    MvWAddStr(lookdeer3, 1, 17, "\\Y/ \\Y/");
    MvWAddStr(lookdeer3, 2, 19, "\\=/");
    MvWAddStr(lookdeer3, 3, 17, "^\\o o/^");
    MvWAddStr(lookdeer3, 4, 17, "//( )");
    MvWAddStr(lookdeer3, 5, 7, "^~~~~~~~~// \\O/");
    MvWAddStr(lookdeer3, 6, 6, "( ()_____( /");
    MvWAddStr(lookdeer3, 7, 6, "/ /       /");
    MvWAddStr(lookdeer3, 8, 5, "|/          \\");
    MvWAddStr(lookdeer3, 9, 5, "/>           \\>");

    /* lookdeer4 */
    MvWAddStr(lookdeer4, 0, 16, "\\/     \\/");
    MvWAddStr(lookdeer4, 1, 17, "\\Y/ \\Y/");
    MvWAddStr(lookdeer4, 2, 19, "\\=/");
    MvWAddStr(lookdeer4, 3, 17, "^\\o o/^");
    MvWAddStr(lookdeer4, 4, 17, "//( )");
    MvWAddStr(lookdeer4, 5, 7, "^~~~~~~~~// \\O/");
    MvWAddStr(lookdeer4, 6, 6, "( )______( /");
    MvWAddStr(lookdeer4, 7, 5, "(/          \\");
    MvWAddStr(lookdeer4, 8, 0, "v___=             ----^");

	/***********************************************/
    cbreak();
    nodelay(stdscr, TRUE);
    for (;;) {
	clear();
	werase(treescrn);
	touchwin(w_del_msg);
	touchwin(treescrn);
	werase(treescrn2);
	touchwin(treescrn2);
	werase(treescrn8);
	touchwin(treescrn8);
	refresh();
	look_out(150);
	boxit();
	refresh();
	look_out(150);
	seas();
	refresh();
	look_out(150);
	greet();
	refresh();
	look_out(150);
	fromwho();
	refresh();
	look_out(150);
	tree();
	look_out(150);
	balls();
	look_out(150);
	star();
	look_out(150);
	strng1();
	strng2();
	strng3();
	strng4();
	strng5();

	/* set up the windows for our blinking trees */
	/* **************************************** */
	/* treescrn3 */

	overlay(treescrn, treescrn3);

	/*balls */
	MvWAddCh(treescrn3, 4, 18, ' ');
	MvWAddCh(treescrn3, 7, 6, ' ');
	MvWAddCh(treescrn3, 8, 19, ' ');
	MvWAddCh(treescrn3, 11, 22, ' ');

	/*star */
	MvWAddCh(treescrn3, 0, 12, '*');

	/*strng1 */
	MvWAddCh(treescrn3, 3, 11, ' ');

	/*strng2 */
	MvWAddCh(treescrn3, 5, 13, ' ');
	MvWAddCh(treescrn3, 6, 10, ' ');

	/*strng3 */
	MvWAddCh(treescrn3, 7, 16, ' ');
	MvWAddCh(treescrn3, 7, 14, ' ');

	/*strng4 */
	MvWAddCh(treescrn3, 10, 13, ' ');
	MvWAddCh(treescrn3, 10, 10, ' ');
	MvWAddCh(treescrn3, 11, 8, ' ');

	/*strng5 */
	MvWAddCh(treescrn3, 11, 18, ' ');
	MvWAddCh(treescrn3, 12, 13, ' ');

	/* treescrn4 */

	overlay(treescrn, treescrn4);

	/*balls */
	MvWAddCh(treescrn4, 3, 9, ' ');
	MvWAddCh(treescrn4, 4, 16, ' ');
	MvWAddCh(treescrn4, 7, 6, ' ');
	MvWAddCh(treescrn4, 8, 19, ' ');
	MvWAddCh(treescrn4, 11, 2, ' ');
	MvWAddCh(treescrn4, 12, 23, ' ');

	/*star */
	(void) wstandout(treescrn4);
	MvWAddCh(treescrn4, 0, 12, '*');
	(void) wstandend(treescrn4);

	/*strng1 */
	MvWAddCh(treescrn4, 3, 13, ' ');

	/*strng2 */

	/*strng3 */
	MvWAddCh(treescrn4, 7, 15, ' ');
	MvWAddCh(treescrn4, 8, 11, ' ');

	/*strng4 */
	MvWAddCh(treescrn4, 9, 16, ' ');
	MvWAddCh(treescrn4, 10, 12, ' ');
	MvWAddCh(treescrn4, 11, 8, ' ');

	/*strng5 */
	MvWAddCh(treescrn4, 11, 18, ' ');
	MvWAddCh(treescrn4, 12, 14, ' ');

	/* treescrn5 */

	overlay(treescrn, treescrn5);

	/*balls */
	MvWAddCh(treescrn5, 3, 15, ' ');
	MvWAddCh(treescrn5, 10, 20, ' ');
	MvWAddCh(treescrn5, 12, 1, ' ');

	/*star */
	MvWAddCh(treescrn5, 0, 12, '*');

	/*strng1 */
	MvWAddCh(treescrn5, 3, 11, ' ');

	/*strng2 */
	MvWAddCh(treescrn5, 5, 12, ' ');

	/*strng3 */
	MvWAddCh(treescrn5, 7, 14, ' ');
	MvWAddCh(treescrn5, 8, 10, ' ');

	/*strng4 */
	MvWAddCh(treescrn5, 9, 15, ' ');
	MvWAddCh(treescrn5, 10, 11, ' ');
	MvWAddCh(treescrn5, 11, 7, ' ');

	/*strng5 */
	MvWAddCh(treescrn5, 11, 17, ' ');
	MvWAddCh(treescrn5, 12, 13, ' ');

	/* treescrn6 */

	overlay(treescrn, treescrn6);

	/*balls */
	MvWAddCh(treescrn6, 6, 7, ' ');
	MvWAddCh(treescrn6, 7, 18, ' ');
	MvWAddCh(treescrn6, 10, 4, ' ');
	MvWAddCh(treescrn6, 11, 23, ' ');

	/*star */
	(void) wstandout(treescrn6);
	MvWAddCh(treescrn6, 0, 12, '*');
	(void) wstandend(treescrn6);

	/*strng1 */

	/*strng2 */
	MvWAddCh(treescrn6, 5, 11, ' ');

	/*strng3 */
	MvWAddCh(treescrn6, 7, 13, ' ');
	MvWAddCh(treescrn6, 8, 9, ' ');

	/*strng4 */
	MvWAddCh(treescrn6, 9, 14, ' ');
	MvWAddCh(treescrn6, 10, 10, ' ');
	MvWAddCh(treescrn6, 11, 6, ' ');

	/*strng5 */
	MvWAddCh(treescrn6, 11, 16, ' ');
	MvWAddCh(treescrn6, 12, 12, ' ');

	/* treescrn7 */

	overlay(treescrn, treescrn7);

	/*balls */
	MvWAddCh(treescrn7, 3, 15, ' ');
	MvWAddCh(treescrn7, 6, 7, ' ');
	MvWAddCh(treescrn7, 7, 18, ' ');
	MvWAddCh(treescrn7, 10, 4, ' ');
	MvWAddCh(treescrn7, 11, 22, ' ');

	/*star */
	MvWAddCh(treescrn7, 0, 12, '*');

	/*strng1 */
	MvWAddCh(treescrn7, 3, 12, ' ');

	/*strng2 */
	MvWAddCh(treescrn7, 5, 13, ' ');
	MvWAddCh(treescrn7, 6, 9, ' ');

	/*strng3 */
	MvWAddCh(treescrn7, 7, 15, ' ');
	MvWAddCh(treescrn7, 8, 11, ' ');

	/*strng4 */
	MvWAddCh(treescrn7, 9, 16, ' ');
	MvWAddCh(treescrn7, 10, 12, ' ');
	MvWAddCh(treescrn7, 11, 8, ' ');

	/*strng5 */
	MvWAddCh(treescrn7, 11, 18, ' ');
	MvWAddCh(treescrn7, 12, 14, ' ');

	look_out(150);
	reindeer();

	touchwin(w_holiday);
	wrefresh(w_holiday);
	wrefresh(w_del_msg);

	look_out(500);
	for (loopy = 0; loopy < 100; loopy++) {
	    blinkit();
	}

#ifdef NOLOOP
	done(0);
#endif
    }
    /*NOTREACHED */
}

static int
boxit(void)
{
    int x = 0;

    while (x < 20) {
	MvAddCh(x, 7, '|');
	++x;
    }

    x = 8;

    while (x < 80) {
	MvAddCh(19, x, '_');
	++x;
    }

    x = 0;

    while (x < 80) {
	MvAddCh(22, x, '_');
	++x;
    }

    return (0);
}

static int
seas(void)
{
    MvAddCh(4, 1, 'S');
    MvAddCh(6, 1, 'E');
    MvAddCh(8, 1, 'A');
    MvAddCh(10, 1, 'S');
    MvAddCh(12, 1, 'O');
    MvAddCh(14, 1, 'N');
    MvAddCh(16, 1, '`');
    MvAddCh(18, 1, 'S');

    return (0);
}

static int
greet(void)
{
    MvAddCh(3, 5, 'G');
    MvAddCh(5, 5, 'R');
    MvAddCh(7, 5, 'E');
    MvAddCh(9, 5, 'E');
    MvAddCh(11, 5, 'T');
    MvAddCh(13, 5, 'I');
    MvAddCh(15, 5, 'N');
    MvAddCh(17, 5, 'G');
    MvAddCh(19, 5, 'S');

    return (0);
}

static int
fromwho(void)
{
    MvAddStr(21, 13, FROMWHO);
    return (0);
}

static int
tree(void)
{
    set_color(treescrn, COLOR_GREEN);
    MvWAddCh(treescrn, 1, 11, (chtype) '/');
    MvWAddCh(treescrn, 2, 11, (chtype) '/');
    MvWAddCh(treescrn, 3, 10, (chtype) '/');
    MvWAddCh(treescrn, 4, 9, (chtype) '/');
    MvWAddCh(treescrn, 5, 9, (chtype) '/');
    MvWAddCh(treescrn, 6, 8, (chtype) '/');
    MvWAddCh(treescrn, 7, 7, (chtype) '/');
    MvWAddCh(treescrn, 8, 6, (chtype) '/');
    MvWAddCh(treescrn, 9, 6, (chtype) '/');
    MvWAddCh(treescrn, 10, 5, (chtype) '/');
    MvWAddCh(treescrn, 11, 3, (chtype) '/');
    MvWAddCh(treescrn, 12, 2, (chtype) '/');

    MvWAddCh(treescrn, 1, 13, (chtype) '\\');
    MvWAddCh(treescrn, 2, 13, (chtype) '\\');
    MvWAddCh(treescrn, 3, 14, (chtype) '\\');
    MvWAddCh(treescrn, 4, 15, (chtype) '\\');
    MvWAddCh(treescrn, 5, 15, (chtype) '\\');
    MvWAddCh(treescrn, 6, 16, (chtype) '\\');
    MvWAddCh(treescrn, 7, 17, (chtype) '\\');
    MvWAddCh(treescrn, 8, 18, (chtype) '\\');
    MvWAddCh(treescrn, 9, 18, (chtype) '\\');
    MvWAddCh(treescrn, 10, 19, (chtype) '\\');
    MvWAddCh(treescrn, 11, 21, (chtype) '\\');
    MvWAddCh(treescrn, 12, 22, (chtype) '\\');

    MvWAddCh(treescrn, 4, 10, (chtype) '_');
    MvWAddCh(treescrn, 4, 14, (chtype) '_');
    MvWAddCh(treescrn, 8, 7, (chtype) '_');
    MvWAddCh(treescrn, 8, 17, (chtype) '_');

    MvWAddStr(treescrn, 13, 0, "//////////// \\\\\\\\\\\\\\\\\\\\\\\\");

    MvWAddStr(treescrn, 14, 11, "| |");
    MvWAddStr(treescrn, 15, 11, "|_|");

    unset_color(treescrn);
    wrefresh(treescrn);
    wrefresh(w_del_msg);

    return (0);
}

static int
balls(void)
{
    overlay(treescrn, treescrn2);

    set_color(treescrn2, COLOR_BLUE);
    MvWAddCh(treescrn2, 3, 9, (chtype) '@');
    MvWAddCh(treescrn2, 3, 15, (chtype) '@');
    MvWAddCh(treescrn2, 4, 8, (chtype) '@');
    MvWAddCh(treescrn2, 4, 16, (chtype) '@');
    MvWAddCh(treescrn2, 5, 7, (chtype) '@');
    MvWAddCh(treescrn2, 5, 17, (chtype) '@');
    MvWAddCh(treescrn2, 7, 6, (chtype) '@');
    MvWAddCh(treescrn2, 7, 18, (chtype) '@');
    MvWAddCh(treescrn2, 8, 5, (chtype) '@');
    MvWAddCh(treescrn2, 8, 19, (chtype) '@');
    MvWAddCh(treescrn2, 10, 4, (chtype) '@');
    MvWAddCh(treescrn2, 10, 20, (chtype) '@');
    MvWAddCh(treescrn2, 11, 2, (chtype) '@');
    MvWAddCh(treescrn2, 11, 22, (chtype) '@');
    MvWAddCh(treescrn2, 12, 1, (chtype) '@');
    MvWAddCh(treescrn2, 12, 23, (chtype) '@');

    unset_color(treescrn2);
    wrefresh(treescrn2);
    wrefresh(w_del_msg);
    return (0);
}

static int
star(void)
{
    (void) wattrset(treescrn2, A_BOLD | A_BLINK);
    set_color(treescrn2, COLOR_YELLOW);

    MvWAddCh(treescrn2, 0, 12, (chtype) '*');
    (void) wstandend(treescrn2);

    unset_color(treescrn2);
    wrefresh(treescrn2);
    wrefresh(w_del_msg);
    return (0);
}

static int
strng1(void)
{
    (void) wattrset(treescrn2, A_BOLD | A_BLINK);
    set_color(treescrn2, COLOR_WHITE);

    MvWAddCh(treescrn2, 3, 13, (chtype) '\'');
    MvWAddCh(treescrn2, 3, 12, (chtype) ':');
    MvWAddCh(treescrn2, 3, 11, (chtype) '.');

    wattroff(treescrn2, A_BOLD | A_BLINK);
    unset_color(treescrn2);

    wrefresh(treescrn2);
    wrefresh(w_del_msg);
    return (0);
}

static int
strng2(void)
{
    (void) wattrset(treescrn2, A_BOLD | A_BLINK);
    set_color(treescrn2, COLOR_WHITE);

    MvWAddCh(treescrn2, 5, 14, (chtype) '\'');
    MvWAddCh(treescrn2, 5, 13, (chtype) ':');
    MvWAddCh(treescrn2, 5, 12, (chtype) '.');
    MvWAddCh(treescrn2, 5, 11, (chtype) ',');
    MvWAddCh(treescrn2, 6, 10, (chtype) '\'');
    MvWAddCh(treescrn2, 6, 9, (chtype) ':');

    wattroff(treescrn2, A_BOLD | A_BLINK);
    unset_color(treescrn2);

    wrefresh(treescrn2);
    wrefresh(w_del_msg);
    return (0);
}

static int
strng3(void)
{
    (void) wattrset(treescrn2, A_BOLD | A_BLINK);
    set_color(treescrn2, COLOR_WHITE);

    MvWAddCh(treescrn2, 7, 16, (chtype) '\'');
    MvWAddCh(treescrn2, 7, 15, (chtype) ':');
    MvWAddCh(treescrn2, 7, 14, (chtype) '.');
    MvWAddCh(treescrn2, 7, 13, (chtype) ',');
    MvWAddCh(treescrn2, 8, 12, (chtype) '\'');
    MvWAddCh(treescrn2, 8, 11, (chtype) ':');
    MvWAddCh(treescrn2, 8, 10, (chtype) '.');
    MvWAddCh(treescrn2, 8, 9, (chtype) ',');

    wattroff(treescrn2, A_BOLD | A_BLINK);
    unset_color(treescrn2);

    wrefresh(treescrn2);
    wrefresh(w_del_msg);
    return (0);
}

static int
strng4(void)
{
    (void) wattrset(treescrn2, A_BOLD | A_BLINK);
    set_color(treescrn2, COLOR_WHITE);

    MvWAddCh(treescrn2, 9, 17, (chtype) '\'');
    MvWAddCh(treescrn2, 9, 16, (chtype) ':');
    MvWAddCh(treescrn2, 9, 15, (chtype) '.');
    MvWAddCh(treescrn2, 9, 14, (chtype) ',');
    MvWAddCh(treescrn2, 10, 13, (chtype) '\'');
    MvWAddCh(treescrn2, 10, 12, (chtype) ':');
    MvWAddCh(treescrn2, 10, 11, (chtype) '.');
    MvWAddCh(treescrn2, 10, 10, (chtype) ',');
    MvWAddCh(treescrn2, 11, 9, (chtype) '\'');
    MvWAddCh(treescrn2, 11, 8, (chtype) ':');
    MvWAddCh(treescrn2, 11, 7, (chtype) '.');
    MvWAddCh(treescrn2, 11, 6, (chtype) ',');
    MvWAddCh(treescrn2, 12, 5, (chtype) '\'');

    wattroff(treescrn2, A_BOLD | A_BLINK);
    unset_color(treescrn2);

    wrefresh(treescrn2);
    wrefresh(w_del_msg);
    return (0);
}

static int
strng5(void)
{
    (void) wattrset(treescrn2, A_BOLD | A_BLINK);
    set_color(treescrn2, COLOR_WHITE);

    MvWAddCh(treescrn2, 11, 19, (chtype) '\'');
    MvWAddCh(treescrn2, 11, 18, (chtype) ':');
    MvWAddCh(treescrn2, 11, 17, (chtype) '.');
    MvWAddCh(treescrn2, 11, 16, (chtype) ',');
    MvWAddCh(treescrn2, 12, 15, (chtype) '\'');
    MvWAddCh(treescrn2, 12, 14, (chtype) ':');
    MvWAddCh(treescrn2, 12, 13, (chtype) '.');
    MvWAddCh(treescrn2, 12, 12, (chtype) ',');

    wattroff(treescrn2, A_BOLD | A_BLINK);
    unset_color(treescrn2);

    /* save a fully lit tree */
    overlay(treescrn2, treescrn);

    wrefresh(treescrn2);
    wrefresh(w_del_msg);
    return (0);
}

static int
blinkit(void)
{
    static int cycle;

    if (cycle > 4) {
	cycle = 0;
    }

    touchwin(treescrn8);

    switch (cycle) {
    case 0:
	overlay(treescrn3, treescrn8);
	wrefresh(treescrn8);
	wrefresh(w_del_msg);
	break;
    case 1:
	overlay(treescrn4, treescrn8);
	wrefresh(treescrn8);
	wrefresh(w_del_msg);
	break;
    case 2:
	overlay(treescrn5, treescrn8);
	wrefresh(treescrn8);
	wrefresh(w_del_msg);
	break;
    case 3:
	overlay(treescrn6, treescrn8);
	wrefresh(treescrn8);
	wrefresh(w_del_msg);
	break;
    case 4:
	overlay(treescrn7, treescrn8);
	wrefresh(treescrn8);
	wrefresh(w_del_msg);
	break;
    }
    touchwin(treescrn8);

    /*ALL ON************************************************** */

    overlay(treescrn, treescrn8);
    wrefresh(treescrn8);
    wrefresh(w_del_msg);

    ++cycle;
    return (0);
}

static void
deer_step(WINDOW *win, int y, int x)
{
    mvwin(win, y, x);
    wrefresh(win);
    wrefresh(w_del_msg);
    look_out(5);
}

static int
reindeer(void)
{
    int looper;
    y_pos = 0;

    for (x_pos = 70; x_pos > 62; x_pos--) {
	if (x_pos < 62) {
	    y_pos = 1;
	}
	for (looper = 0; looper < 4; looper++) {
	    MvWAddCh(dotdeer0, y_pos, x_pos, (chtype) '.');
	    wrefresh(dotdeer0);
	    wrefresh(w_del_msg);
	    werase(dotdeer0);
	    wrefresh(dotdeer0);
	    wrefresh(w_del_msg);
	    look_out(50);
	}
    }

    y_pos = 2;

    for (; x_pos > 50; x_pos--) {
	for (looper = 0; looper < 4; looper++) {

	    if (x_pos < 56) {
		y_pos = 3;

		MvWAddCh(stardeer0, y_pos, x_pos, (chtype) '*');
		wrefresh(stardeer0);
		wrefresh(w_del_msg);
		werase(stardeer0);
		wrefresh(stardeer0);
		wrefresh(w_del_msg);
	    } else {
		MvWAddCh(dotdeer0, y_pos, x_pos, (chtype) '*');
		wrefresh(dotdeer0);
		wrefresh(w_del_msg);
		werase(dotdeer0);
		wrefresh(dotdeer0);
		wrefresh(w_del_msg);
	    }
	}
    }

    x_pos = 58;

    for (y_pos = 2; y_pos < 5; y_pos++) {

	touchwin(lildeer0);
	wrefresh(lildeer0);
	wrefresh(w_del_msg);

	for (looper = 0; looper < 4; looper++) {
	    deer_step(lildeer3, y_pos, x_pos);
	    deer_step(lildeer2, y_pos, x_pos);
	    deer_step(lildeer1, y_pos, x_pos);
	    deer_step(lildeer2, y_pos, x_pos);
	    deer_step(lildeer3, y_pos, x_pos);

	    touchwin(lildeer0);
	    wrefresh(lildeer0);
	    wrefresh(w_del_msg);

	    x_pos -= 2;
	}
    }

    x_pos = 35;

    for (y_pos = 5; y_pos < 10; y_pos++) {

	touchwin(middeer0);
	wrefresh(middeer0);
	wrefresh(w_del_msg);

	for (looper = 0; looper < 2; looper++) {
	    deer_step(middeer3, y_pos, x_pos);
	    deer_step(middeer2, y_pos, x_pos);
	    deer_step(middeer1, y_pos, x_pos);
	    deer_step(middeer2, y_pos, x_pos);
	    deer_step(middeer3, y_pos, x_pos);

	    touchwin(middeer0);
	    wrefresh(middeer0);
	    wrefresh(w_del_msg);

	    x_pos -= 3;
	}
    }

    look_out(300);

    y_pos = 1;

    for (x_pos = 8; x_pos < 16; x_pos++) {
	deer_step(bigdeer4, y_pos, x_pos);
	deer_step(bigdeer3, y_pos, x_pos);
	deer_step(bigdeer2, y_pos, x_pos);
	deer_step(bigdeer1, y_pos, x_pos);
	deer_step(bigdeer2, y_pos, x_pos);
	deer_step(bigdeer3, y_pos, x_pos);
	deer_step(bigdeer4, y_pos, x_pos);
	deer_step(bigdeer0, y_pos, x_pos);
    }

    --x_pos;

    for (looper = 0; looper < 6; looper++) {
	deer_step(lookdeer4, y_pos, x_pos);
	deer_step(lookdeer3, y_pos, x_pos);
	deer_step(lookdeer2, y_pos, x_pos);
	deer_step(lookdeer1, y_pos, x_pos);
	deer_step(lookdeer2, y_pos, x_pos);
	deer_step(lookdeer3, y_pos, x_pos);
	deer_step(lookdeer4, y_pos, x_pos);
    }

    deer_step(lookdeer0, y_pos, x_pos);

    for (; y_pos < 10; y_pos++) {
	for (looper = 0; looper < 2; looper++) {
	    deer_step(bigdeer4, y_pos, x_pos);
	    deer_step(bigdeer3, y_pos, x_pos);
	    deer_step(bigdeer2, y_pos, x_pos);
	    deer_step(bigdeer1, y_pos, x_pos);
	    deer_step(bigdeer2, y_pos, x_pos);
	    deer_step(bigdeer3, y_pos, x_pos);
	    deer_step(bigdeer4, y_pos, x_pos);
	}
	deer_step(bigdeer0, y_pos, x_pos);
    }

    --y_pos;

    deer_step(lookdeer3, y_pos, x_pos);
    return (0);
}

static void
done(int sig GCC_UNUSED)
{
    CATCHALL(done);

    move(LINES - 1, 0);
    refresh();
    endwin();
    curs_set(1);

#if NO_LEAKS
    if (my_pairs != 0)
	free(my_pairs);
#endif

    ExitProgram(EXIT_SUCCESS);
}