/*
 * Copyright (c)  1984, 1988, 1990, 1993-1995 by Rick Jansen,
 *                all rights reserved.
 * Copyright (c) 1995 by Jan Andersson, Torpa Konsult AB.
 *
 * Permission to use, copy, and distribute this software for
 * NON-COMMERCIAL purposes and without fee is hereby granted
 * provided that this copyright notice appears in all copies.
 *
 * All rights of "look and feel" and bitmaps used are retained by
 * Rick Jansen. 
 *  
 * Original Xsnow Copyright text:
 *
 *   Xsnow is available freely and you may give it to other people as is, 
 *   but I retain all rights. Therefore it does not classify as 'Public 
 *   Domain' software.
 *
 */

import java.applet.*;
import java.awt.*;
import java.awt.image.*;
import java.util.*;

/**
 * ChristmasCard - Christmas Card Applet
 *
 * Inspired by Rick Jansen's Xsnow.
 *
 * @version 1.4, 12/07/95
 * @author  Jan Andersson (janne@torpa.se)
 * 
 */
public class ChristmasCard extends Applet implements Runnable 
{
   Thread    thread = null;	// animation thread
   boolean   suspended = false;	// animation thread suspended
   Vector snowFlakes = null;	// animated snow flakes
   int noOfFlakes;		// number of snow flakes
   Santa  santa = null;		// animated Santa
   MovingText text = null;	// animated text
   int lastWidth = 0;		// last know width
   int lastHeight = 0;		// last know height
   Frame  aboutFrame = null;	// About popup frame
   Button aboutButton = null;	// button to popup About frame
   boolean showAbout = true;	// true if About button to be used
   boolean restarted = true;	// true if re-started
				// default text lines
   String msg1 = "Merry Christmas";
   String msg2 = "And";
   String msg3 = "A Happy New Year!";
   String msg4 = "From Janne Andersson";
				// updates done "off-screen"
   private Image offScreenImage;
   private Graphics offScreenGraphics;
   private Dimension offScreenSize;
   
   public void init()
   {
      String par = getParameter("msg1");
      if (par != null)
	 msg1 = par;
      par = getParameter("msg2");
      if (par != null)
	 msg2 = par;
      par = getParameter("msg3");
      if (par != null)
	 msg3 = par;
      par = getParameter("msg4");
      if (par != null)
	 msg4 = par;

      par = getParameter("flakes");
      noOfFlakes = (par == null) ?
	 30 : Integer.valueOf(par).intValue();

      Color sky = readColor(getParameter("sky"), Color.blue);
      Color snow = readColor(getParameter("snow"), Color.white);
      // use sky as background as well and red as foreground
      setBackground(sky);
      setForeground(Color.red);
      
      // init statics for moving components
      SmallSnowFlake.initStatic(this, snow, sky);
      BigSnowFlake.initStatic(this, snow, sky);
      Santa.initStatic(this, sky);
      Font font = new Font("TimesRoman", Font.BOLD, 22);
      MovingText.initStatic(msg1, msg2, msg3, msg4,
			    font, Color.red);
      if (showAbout && aboutButton == null) {
	 // create "About" button
	 aboutButton = new Button("About...");
	 //aboutButton.setBackground(sky);
	 //aboutButton.setForeground(snow);
	 add(aboutButton);
      }
   }

   /**
    * Applet Info.
    */
   public String getAppletInfo() {
      return "ChristmasCard.java 1.4, by janne@torpa.se";
   }   

    /**
    * Parameter Info.
    */
   public String[][] getParameterInfo() {
      // More should be added...
      String[][] info = {
	 {"msg1",      "string",      "text 1 (Merry Christmas)"},
	 {"msg2",      "string",      "text 2 (And)"},
	 {"msg3",      "string",      "text 3 (A Happy New Year!)"},
	 {"msg4",      "string",      "text 4 (From Janne Andersson!)"},
	 {"snow",      "string",      "Snow Color (White)"},
	 {"sky",       "string",      "Sky Color (Blue)"},
	 {"flakes",    "int",         "Number of snow flakes (30)"},
      };
      return info;
   }

    /**
    * Convert a Hexadecimal String with RGB-Values to Color
    * Uses aDefault, if no or not enough RGB-Values
    */
   public Color readColor(String aColor, Color aDefault) {
      if ((aColor == null) ||
	  (aColor.charAt(0) != '#') ||
	  (aColor.length() != 7 )) {
	 return aDefault;
      }
      
      try {
	 Integer rgbValue = new Integer(0);
	 rgbValue = Integer.valueOf(aColor.substring(1, 7), 16);
	 return new Color(rgbValue.intValue());
      }
      catch (Exception e) {
	 return aDefault;
      }
   }
   
   /*
    * Create snow flakes
    */
   public void createSnowFlakes() 
   {
      if (snowFlakes == null)
	 snowFlakes = new Vector(noOfFlakes);
      else
	 snowFlakes.removeAllElements();
      
      for (int i=0; i<noOfFlakes/2; i++) {
	 snowFlakes.addElement(new SmallSnowFlake(lastWidth, lastHeight));
	 snowFlakes.addElement(new BigSnowFlake(lastWidth, lastHeight));
      }
   }

   /**
    * Paint the snow flakes
    */
   public void paintSnowFlakes(Graphics g)
   {
      int flakes = snowFlakes.size();
      for (int i=0; i<flakes; i++) {
	 SnowFlake snowFlake = (SnowFlake)snowFlakes.elementAt(i);
	 snowFlake.update(g, lastWidth, lastHeight);
      }
   }

   /**
    * Paint the graphics
    */
   public void paint(Graphics g) {
      if (lastWidth != size().width || lastHeight != size().height ||
	  restarted) {
	 restarted = false;
	 lastWidth = size().width;
	 lastHeight = size().height;
	 // (re) create snow flakes
	 createSnowFlakes();
	 if (santa == null)
	    // create santa
	    santa = new Santa(lastWidth, lastHeight);
	 if (text == null)
	    // create moving text
	    text = new MovingText(this, lastWidth, lastHeight);
	 if (aboutButton != null) {
	    Dimension d = aboutButton.size();
	    aboutButton.move(lastWidth-d.width, lastHeight-d.height);
	 }
      }
      text.update(g, lastWidth, lastHeight);
      santa.update(g, lastWidth, lastHeight);
      paintSnowFlakes(g);
   }
   
   /**
    * Update off-screen graphics
    *
    * From NoFlickerApplet, by Matthew Gray
    */
    public final synchronized void update (Graphics theG)
    {
      Dimension d = size();
      if((offScreenImage == null) || (d.width != offScreenSize.width) ||
	 (d.height != offScreenSize.height)) 
	{
	  offScreenImage = createImage(d.width, d.height);
	  offScreenSize = d;
	  offScreenGraphics = offScreenImage.getGraphics();
	  offScreenGraphics.setFont(getFont());
	}
      offScreenGraphics.setColor(getBackground());
      offScreenGraphics.fillRect(0,0,d.width, d.height);
      paint(offScreenGraphics);
      theG.drawImage(offScreenImage, 0, 0, null);
    }

   /**
    * Run the loop. This method is called by class Thread.
    */
   public void run() {
      Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
      while (thread != null) {
	 repaint();
	 try {Thread.sleep(100);}
	 catch (InterruptedException e){}
      }
   }
   
   /**
    * Start the applet by forking an animation thread.
    */
   public void start() {
      if (thread == null) {
	 thread = new Thread(this);
	 thread.start();
	 restarted = true;
      }
   }
   
   /**
    * Stop the applet. The thread will exit because run() exits.
    */
   public void stop() {
      thread = null;
      if (aboutFrame != null)
	 aboutFrame.hide();
   }
   
   /**
    * Suspend/Resume
    */
   public boolean mouseDown(Event evt, int x, int y) {
      // handle Suspend/Resume
      if (suspended) {
	 thread.resume();
      }
      else {
	 thread.suspend();
      }
      suspended = !suspended;
      // show version
      showStatus(getAppletInfo());
      return true;
   }

   /**
    * Handle action. I.e Button pressed...
    */
   public boolean action(Event evt, Object arg) {
      if (evt.target instanceof Button) {
	 if (aboutFrame == null)
	    aboutFrame = new AboutChristmasCardFrame(this);
	 aboutFrame.show();
      }
      return true;
   }
}

/**
 * MovingGraphComponent - abtract class for moving graphical components.
 */
abstract class MovingGraphComponent 
{
   protected int x;		// the x position
   protected int y;		// the y position
   protected int w;		// the width
   protected int h;		// the height
   protected boolean visible;	// True when the object is visible. 

   /**
    * Constructs a new MovingGraphComponent. Should not be instantiated
    * directly.
    */
   protected MovingGraphComponent()
   {
   }

   /**
    * Abstract methods, implemented by sub-classes.
    */
   abstract Image image();
   abstract void move(int width, int height);
   
   /**
    * Init x and y position as well as if component is visible
    */
   protected void initPos(int x, int y, boolean visible)
   {
      this.x = x;
      this.y = y;
      this.visible = visible;
   }

   /**
    * Init size of component.
    */
   protected void initSize(int w, int h)
   {
      this.w = w;
      this.h = h;
   }

   /**
    * Update component. I.e move and paint.
    */
   void update(Graphics g, int width, int height) 
   {
      move(width, height);
      paint(g);
   }

   
   /**
    * Paint component.
    */
   void paint(Graphics g)
   {
      if (visible)
	 g.drawImage(image(), x, y, null);
   }

}

/**
 * Moving Text
 */
class MovingText extends MovingGraphComponent
{
   static private String text[];
   static final int maxText = 4;
   static private Color fgColor;
   static private Font font;
   static final int TEXT_NORMAL = 0;
   static final int TEXT_NERVOUS = 1;
   static final int DELAY = 0;
   static final int NORMAL = 1;
   static final int DROPPING = 2;
   static final int EXPLODING = 3;
   static final int maxCount = 30;
   
   private int dx;
   private int dy;
   private char chars[];
   private int xPos[];
   private int yPos[];
   private FontMetrics fm;
   private int textIndex;
   private int textLength;
   private int state = DELAY;
   private int textState = TEXT_NORMAL;
   private boolean exploding = false;
   private int count = 0;
   
   /**
    * static initializer
    */
   static void initStatic(
      String line1, String line2, String line3, String line4,
      Font aFont, Color fg) 
   {
      fgColor = fg;
      font = aFont;
      text = new String[maxText];
      text[0] = line1;
      text[1] = line2;
      text[2] = line3;
      text[3] = line4;
   }
   
   MovingText(Component c, int width, int height)
   {
      fm = c.getFontMetrics(font);
      initText(0, width, height);
   }

   void initText(int index, int width, int height)
   {
      textIndex = index;
      if (textIndex > maxText)
	 textIndex = 0;

      String newText;
      
      // when textIndex is max, we don't define any text (uses an
      // empty string), since we use a delay here
      if (textIndex >= maxText)
	 newText = "";
      else
	 newText = text[textIndex];
      
      textLength = newText.length();
      chars = new char[textLength];
      newText.getChars(0, textLength, chars, 0);
      xPos = new int[textLength];
      yPos = new int[textLength];
      for (int i = 0; i < textLength; i++) {
         xPos[i] = fm.charsWidth(chars, 0, i);
	 yPos[i] = fm.getAscent() - 1;
      }
      dx = 2;
      dy = 2;

      int newWidth  = dx * 2 + fm.stringWidth(newText);
      int newHeight = dy * 2 + font.getSize();
      int newX = (width - newWidth)/2;
      int newY = (height - newHeight)/2;
      
      initSize(newWidth, newHeight);
      initPos(newX, newY, true);
   }
   

   void move(int width, int height)
   {
      count++;
      if (state == DROPPING) {
	 // make characters drop down
	 for (int i = 0; i < textLength; i++) {
	    yPos[i] = yPos[i] + count;
	    if (y+yPos[i] > height) {
	       // we are out of view; break
	       count = maxCount;
	       break;
	    }
	 }
      }
      if (state == EXPLODING) {
	 // make characters move left/right
	 int mid = textLength/2;
	 int outOfView = 0;
	 for (int i = 0; i < textLength; i++) {
	    if (i < mid) 
	       xPos[i] = xPos[i] - 3*(mid - i);
	    else
	       xPos[i] = xPos[i] + 3*(i - mid);
	    if (x+xPos[i] > width || x+xPos[i] < 0)
	       outOfView++;
	 }
	 if (outOfView > textLength-6)
	    // we are out of view; break
	    count = maxCount;
      }

      if (count >= maxCount) {
	 // swich state and/or text
	 if ((textIndex == 0 || textIndex == 2) &&
	     state == NORMAL) {
	    // use fancy animation for text 1 and 3
	    double rand = Math.random();
	    if (rand < 0.5)
	       state = EXPLODING;
	    else 
	       state = DROPPING;
	 }
	 else {
	    // switch to new text
	    initText(textIndex+1, width, height);
	    textState = TEXT_NORMAL;
	    state = NORMAL;
	    if (textIndex == 2)
	       // text 3 displayed as "nervous"
	       textState = TEXT_NERVOUS;
	    else if (textIndex == maxText)
	       state = DELAY;
	 }
	 // reset count
	 if (state == DELAY || textIndex == 1)
	    // but don't show delay and text 2 as long..
	    count = maxCount/2;
	 else
	    count = 0;
      }
   }

   void paint(Graphics g)
   {
      g.setFont(font);
      g.setColor(fgColor);
      
      for (int i = 0; i < textLength; i++) {
	 int tmpX;
	 int tmpY;
	 if (textState == TEXT_NERVOUS) {
	    // Nervous text
	    tmpX = (int)(Math.random() * dx * 2) + xPos[i];
	    tmpY = (int)(Math.random() * dy * 2) + yPos[i];
	 }
	 else {
	    // Normal text
	    tmpX = xPos[i];
	    tmpY = yPos[i];
	 }
	 g.drawChars(chars, i, 1, x+tmpX, y+tmpY);
      }
   }
   
   // dummy; not used here
   Image image()
   {
      return null;
   }
}


/**
 * The Santa and his reins.
 */
class Santa extends MovingGraphComponent
{
   private int dx;
   private int dy;
   private Image image;
   private int imageCount;
   static private BitMap bitMap;
   static private Image images[];

   /**
    * static initializer
    */
    static void initStatic(Component c, Color bg) 
   {
      bitMap = SantaBitmap.instance(bg);
      int pixmap1[] = bitMap.getPixmap(0);
      int pixmap2[] = bitMap.getPixmap(1);
      int pixmap3[] = bitMap.getPixmap(2);

      // create images
      images = new Image[3];
      images[0] = c.createImage(new MemoryImageSource(
	 bitMap.width(), bitMap.height(),
	 pixmap1, 0, bitMap.width()));
      images[1] = c.createImage(new MemoryImageSource(
	 bitMap.width(), bitMap.height(),
	 pixmap2, 0, bitMap.width()));
      images[2] = c.createImage(new MemoryImageSource(
	 bitMap.width(), bitMap.height(),
	 pixmap3, 0, bitMap.width()));
   }

   Santa(int width, int height)
   {
      imageCount = 0;
      image = images[0];
      initSize(bitMap.width(), bitMap.height());
      initStartPos(width, height);
      dx = 3;
      dy = 1;
   }
   
   void initStartPos(int width, int height) 
   {
      int yRand = 20 + (int) (Math.random() * (double) (height/2 - 30));
      if (Math.random() > 0.5) {
	 // top half of screen
	 yRand += height/2;
      }
      initPos(-w, yRand, true);
   }
   

   void move(int width, int height)
   {
      x += dx;
      if (x > width) {
	 // restart santa
	 initStartPos(width, height);
      }
      
      int newY = (Math.random() > 0.5) ? y+dy : y-dy;
      initPos(x, newY, true);
      image = images[imageCount++];
      if (imageCount > 2)
	 imageCount = 0;
   }
   
   Image image()
   {
      return image;
   }
}


/**
 * Abstract snow flake class
 */
abstract class SnowFlake extends MovingGraphComponent
{
   private int dy;
   private int dx;
   private int maxDx;
   private boolean moveToTheRight;
   private int dirChangeSteps = 0;
   
   protected SnowFlake(int width, int height)
   {
      // spread the flakes around
      int xRand = (int) (Math.random() * (double) height);
      int yRand = (int) (Math.random() * (double) width);

      // only show the flakes a the top
      boolean visibleRand = yRand < height/5;
      initPos(xRand, yRand, visibleRand);

      // init dx and dy
      initDxDy(width, height);
   }

   void move(int width, int height)
   {
      if (Math.abs(dx) > dy) {
	 // we are moving to much in x direction; make sure
	 // we move in a direction to fix this up...
	 if (moveToTheRight && dx > 0)
	    moveToTheRight = false;
	 else 
	    moveToTheRight = true;
      }
      else {
	 // make the flakes change direction randomly
	 if (Math.random() > 0.5) {
	    // change direction
	    moveToTheRight = !moveToTheRight;
	 }
      }

      // also verify that we are withing the flakes own maximum
      // horizontal movement.
      if (dx > maxDx)
	 moveToTheRight = false;
      if (dx < -maxDx)
	 moveToTheRight = true;
      if (moveToTheRight) 
	 dx = dx + (int) (Math.random() * 2);
      else
	 dx = dx - (int) (Math.random() * 2);

      x += dx;
      y += dy;

      // if out of view (left or right) make object in visible
      if (x < 0 || x > width)
	 visible = false;
      
      if (y > height) {
	 // restart at the top
	 int xRand = (int) (Math.random() * (double) width);
	 initPos(xRand, 0, true);
	 // re-init dx and dy
	 initDxDy(width, height);
      }
   }

   public void initDxDy(int width, int height)
   {
      int maxDy = Math.min(height/40, 4);
      maxDx = Math.min(width/80, 2);
      dx = (int) (Math.random() * maxDx-1) + 1;
      if (Math.random() > 0.5)
	 dx = -dx;
      if (dx > 0)
	 moveToTheRight = true;
      dy = (int) (Math.random() * (double) maxDy) + 1;
   }
}


/**
 * Small snow flake 
 */
class SmallSnowFlake extends SnowFlake
{
   static private BitMap bitMap;
   static private Image image;

   /**
    * static initializer
    */
   static void initStatic(Component c, Color fg, Color bg) 
   {
      bitMap = SmallSnowFlakeBitmap.instance(fg, bg);
      int pixmap[] = bitMap.getPixmap();
      image = c.createImage(new MemoryImageSource(
	 bitMap.width(), bitMap.height(),
	 pixmap, 0, bitMap.width()));
   }

   SmallSnowFlake(int width, int height)
   {
      super(width, height);
      initSize(bitMap.width(), bitMap.height());
   }

   Image image()
   {
      return image;
   }

}

/**
 * Bigger snow flake 
 */
class BigSnowFlake extends SnowFlake
{
   static private Image image;
   static private BitMap bitMap;

   /**
    * static initializer
    */
   static void initStatic(Component c, Color fg, Color bg) 
   {
      bitMap = LargeSnowFlakeBitmap.instance(fg, bg);
      int pixmap[] = bitMap.getPixmap();
      image = c.createImage(new MemoryImageSource(
	 bitMap.width(), bitMap.height(),
	 pixmap, 0, bitMap.width()));
   }

   BigSnowFlake(int width, int height)
   {
      super(width, height);
      initSize(bitMap.width(), bitMap.height());
   }

   Image image()
   {
      return image;
   }
}

/**
 * Abstract Bitmap class.
 *
 * Subclasses implements conversion of bitmaps (X11 style) to
 * color pixmaps that can be used to create images.
 */
abstract class BitMap
{
   protected int width;
   protected int height;
   
   abstract public int[] getPixmap();
   abstract public int[] getPixmap(int index);

   public int width()
   {
      return width;
   }
   
   public int height()
   {
      return height;
   }
}

class SmallSnowFlakeBitmap extends BitMap {
   static private BitMap instance = null;
   static private int bitmap[] = {
      0x05, 0x02, 0x05
   };
   static private int pixmap[] = null;

   private SmallSnowFlakeBitmap(Color fg, Color bg) 
   {
      width = height = 3;
      pixmap = new int[width*height];
      int index = 0;
      for (int i=0; i<height; i++)
	 for (int j=0; j<width; j++) {
	    int pixel = bitmap[i] & (1 << j);
	    pixmap[index] = (pixel != 0) ? fg.getRGB() : bg.getRGB();
	    index++;
	 }
   }

   static public BitMap instance(Color fg, Color bg)
   {
      if (instance == null)
	 instance = new SmallSnowFlakeBitmap(fg, bg);
      return (BitMap) instance;
   }
   
   public int[] getPixmap() 
   {
      return pixmap;
   }
   
   public int[] getPixmap(int index)
   {
      return pixmap;
   }
}

class LargeSnowFlakeBitmap extends BitMap {
   static private BitMap instance = null;
   static private int bitmap[] = {
      0x14, 0x08, 0x49, 0x36, 0x49, 0x08, 0x14
   };
   static private int pixmap[] = null;

   private LargeSnowFlakeBitmap(Color fg, Color bg) 
   {
      width = height = 7;
      pixmap = new int[width*height];
      int index = 0;
      for (int i=0; i<height; i++)
	 for (int j=0; j<width; j++) {
	    int pixel = bitmap[i] & (1 << j);
	    pixmap[index] = (pixel != 0) ? fg.getRGB() : bg.getRGB();
	    index++;
	 }
   }

   static public BitMap instance(Color fg, Color bg)
   {
      if (instance == null)
	 instance = new LargeSnowFlakeBitmap(fg, bg);
      return (BitMap) instance;
   }
   
   public int[] getPixmap() 
   {
      return pixmap;
   }
   
   public int[] getPixmap(int index)
   {
      return pixmap;
   }
}

class SantaBitmap extends BitMap {
   static private int sleighBits1[] = {
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x54, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc2, 0x00, 0x00, 0x10, 0x00, 0x00,
      0x80, 0x90, 0x00, 0x00, 0x68, 0x30, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
      0x00, 0x10, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x48, 0x30, 0x00, 0x00,
      0x00, 0x00, 0x04, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x37, 0x00, 0x00,
      0x7c, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0xc0, 0x00, 0x00,
      0x00, 0x0c, 0x00, 0x00, 0x7c, 0xc0, 0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00,
      0x00, 0xc0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x5c, 0xc0, 0x31, 0x00,
      0x00, 0x01, 0x0c, 0x08, 0x00, 0xc0, 0x80, 0x00, 0xfc, 0x0f, 0x00, 0x00,
      0x74, 0xc0, 0x71, 0x00, 0x00, 0x03, 0x0f, 0xfc, 0x70, 0xcd, 0xf8, 0x7f,
      0x04, 0x0c, 0x00, 0x00, 0x0c, 0x80, 0xf0, 0x0c, 0x23, 0xfe, 0x0f, 0x00,
      0xe0, 0xff, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0xf8, 0xff, 0xf0, 0x0c,
      0x03, 0xfc, 0x07, 0x00, 0xc0, 0xff, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00,
      0x30, 0xc3, 0x38, 0x00, 0x00, 0xfc, 0x03, 0x00, 0xc0, 0x7f, 0x00, 0x00,
      0xfc, 0x07, 0x00, 0x00, 0x30, 0xc3, 0x18, 0x00, 0x00, 0xfc, 0x03, 0x00,
      0xc0, 0x70, 0x00, 0x00, 0x7c, 0x07, 0x00, 0x00, 0x30, 0xc3, 0x0c, 0x00,
      0x00, 0x06, 0x0e, 0x00, 0x20, 0xe0, 0x00, 0x00, 0x08, 0x0c, 0x00, 0x00,
      0xff, 0xff, 0x07, 0x00, 0x00, 0x03, 0x08, 0x00, 0x30, 0x80, 0x00, 0x00,
      0x06, 0x00, 0x00, 0x00
   };
   static private int sleighBits2[] = {
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x50, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x80, 0x06, 0x00,
      0x80, 0x12, 0x00, 0x00, 0x68, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x12, 0x00,
      0x00, 0x40, 0x02, 0x00, 0x00, 0x13, 0x00, 0x00, 0x48, 0x30, 0x01, 0x00,
      0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x36, 0x00, 0x00,
      0x7c, 0xc0, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x40, 0x01, 0x00,
      0x00, 0x0c, 0x00, 0x00, 0x7c, 0xc0, 0x1b, 0x00, 0x00, 0x00, 0x0c, 0x00,
      0x00, 0xc0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x5c, 0xc0, 0x31, 0x00,
      0x00, 0x01, 0x0c, 0xcc, 0x00, 0xc0, 0x00, 0x00, 0x03, 0x0f, 0x00, 0x00,
      0x74, 0xc0, 0xb0, 0x00, 0x80, 0x03, 0x8c, 0xef, 0x02, 0xf8, 0xe0, 0x3e,
      0x03, 0x0c, 0x00, 0x00, 0x0c, 0xc0, 0xf0, 0x0d, 0x1b, 0xfe, 0x0f, 0x00,
      0xe0, 0xff, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0xf8, 0xff, 0xf0, 0x0c,
      0x02, 0xfc, 0x07, 0x00, 0x80, 0x7f, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00,
      0x30, 0xc3, 0x38, 0x00, 0x00, 0xf8, 0x03, 0x00, 0x80, 0x3f, 0x00, 0x00,
      0xf8, 0x03, 0x00, 0x00, 0x30, 0xc3, 0x18, 0x00, 0x00, 0x38, 0x03, 0x00,
      0x80, 0x33, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, 0x30, 0xc3, 0x0c, 0x00,
      0x00, 0x18, 0x01, 0x00, 0x80, 0x31, 0x00, 0x00, 0x30, 0x03, 0x00, 0x00,
      0xff, 0xff, 0x07, 0x00, 0x00, 0x08, 0x01, 0x00, 0x80, 0x11, 0x00, 0x00,
      0x10, 0x03, 0x00, 0x00
   };
   static private int sleighBits3[] = {
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x64, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x50, 0x0c, 0x00,
      0x00, 0xe5, 0x00, 0x00, 0x60, 0x30, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
      0x00, 0x30, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x48, 0x30, 0x01, 0x00,
      0x00, 0x00, 0x20, 0x00, 0x00, 0x20, 0x02, 0x00, 0x00, 0x16, 0x00, 0x00,
      0x7c, 0xc0, 0x02, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0xc0, 0x00, 0x00,
      0x00, 0x0c, 0x00, 0x00, 0x7c, 0xc0, 0x0b, 0x00, 0x00, 0x00, 0x0c, 0x00,
      0x00, 0xc0, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x5c, 0xc0, 0x31, 0x00,
      0x00, 0x03, 0x0c, 0x80, 0xf0, 0xd8, 0xc0, 0x00, 0x30, 0x0f, 0x00, 0x00,
      0x74, 0xc0, 0xb0, 0x00, 0xe0, 0x02, 0x0e, 0xef, 0x20, 0xc0, 0xc0, 0xff,
      0x07, 0x0c, 0x00, 0x00, 0x0c, 0xc0, 0xf0, 0x0c, 0x03, 0xfc, 0x0f, 0x00,
      0xe0, 0xff, 0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0xf8, 0xff, 0xf0, 0x0c,
      0x03, 0xf8, 0x07, 0x00, 0xc0, 0xff, 0x00, 0x00, 0xfc, 0x0f, 0x00, 0x00,
      0x30, 0xc3, 0x38, 0x00, 0x00, 0x38, 0x03, 0x00, 0x80, 0x3b, 0x00, 0x00,
      0x3c, 0x03, 0x00, 0x00, 0x30, 0xc3, 0x18, 0x00, 0x00, 0x70, 0x01, 0x00,
      0x00, 0x33, 0x00, 0x00, 0x38, 0x03, 0x00, 0x00, 0x30, 0xc3, 0x0c, 0x00,
      0x00, 0xa0, 0x01, 0x00, 0x00, 0x1e, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00,
      0xff, 0xff, 0x07, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00,
      0xe0, 0x00, 0x00, 0x00
   };
      
   static private int santaBits[] = {
      0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x3f,
      0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x08,
      0x00, 0x08, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00
   };
   static private int santaFurBits[] = {
      0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,
      0x80, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
   };
   
   static private BitMap instance = null;
   static private int pixmap1[] = null;
   static private int pixmap2[] = null;
   static private int pixmap3[] = null;

   private SantaBitmap(Color bg) 
   {
      width = 128;
      height = 16;

      // create pixmaps
      pixmap1 = new int[width*height];
      pixmap2 = new int[width*height];
      pixmap3 = new int[width*height];

      // colors
      Color sleighColor = Color.black;
      Color santaColor = Color.red;
      Color furColor = Color.green;
      Color bgColor = bg;

      // init pixmaps from sleigh bitmap
      int index = 0;
      for (int i=0; i<256; i++) {
	 for (int k=0; k<8; k++) {
	    int pixel = sleighBits1[i] & (1 << k);
	    pixmap1[index] = (pixel != 0) ?
	       sleighColor.getRGB() : bgColor.getRGB();
	    pixel = sleighBits2[i] & (1 << k);
	    pixmap2[index] = (pixel != 0) ?
	       sleighColor.getRGB() : bgColor.getRGB();
	    pixel = sleighBits3[i] & (1 << k);
	    pixmap3[index] = (pixel != 0) ?
	       sleighColor.getRGB() : bgColor.getRGB();
	    index++;
	 }
      }
      
      // update pixmaps from santa bitmap
      int santaIndex = 0;
      for (int i=0; i<16; i++) {
	 for (int j=0; j<2; j++) {
	    for (int k=0; k<8; k++) {
	       int pixel = santaBits[santaIndex] & (1 << k);
	       if (pixel != 0) {
		  int indx = (i*128) + (j * k);
		  pixmap1[indx] = santaColor.getRGB();
		  pixmap2[indx] = santaColor.getRGB();
		  pixmap3[indx] = santaColor.getRGB();
	       }
	    }
	    santaIndex++;
	 }
      }

      // update pixmaps from santa fur bitmap
      santaIndex = 0;
      for (int i=0; i<16; i++) {
	 for (int j=0; j<2; j++) {
	    for (int k=0; k<8; k++) {
	       int pixel = santaFurBits[santaIndex] & (1 << k);
	       if (pixel != 0) {
		  int indx = (i*128) + (j * k);
		  pixmap1[indx] = furColor.getRGB();
		  pixmap2[indx] = furColor.getRGB();
		  pixmap3[indx] = furColor.getRGB();
	       }
	    }
	    santaIndex++;
	 }
      }
   }

   static public BitMap instance(Color bg)
   {
      if (instance == null)
	 instance = new SantaBitmap(bg);
      return (BitMap) instance;
   }
   
   public int[] getPixmap() 
   {
      return pixmap1;
   }
   
   public int[] getPixmap(int index)
   {
      if (index == 0)
	 return pixmap1;
      else if (index == 1)
	 return pixmap2;
      else
	 return pixmap3;
   }
}

/**
 * Frame class to display "About" info.  with a "dismiss" button.
 */
class AboutChristmasCardFrame extends Frame {
   private Panel panel;

   public AboutChristmasCardFrame(Applet applet) 
   {
      setTitle("ChristmasCard: About");
      //setBackground(applet.getBackground());
      //setForeground(applet.getForeground());

      // add canvas
      AboutChristmasCardCanvas canvas =
	 new AboutChristmasCardCanvas(this);
      add("North", canvas);

      // add button
      Panel panel = new Panel();
      panel.add(new Button("Dismiss"));
      add("South", panel);

      // pack components
      pack();
   }

   /**
    * handle window destroy (close) event
    */
   public boolean handleEvent(Event e) {
      if (e.id == Event.WINDOW_DESTROY) {
	 hide();
	 return true;
      }
      return super.handleEvent(e);
   }

   /**
    * handle button action
    */
   public boolean action(Event evt, Object arg) {
      if (evt.target instanceof Button) 
	 hide();
      return true;
   }
}

/**
 * Canvas to display "about" text
 */
class AboutChristmasCardCanvas extends Canvas {
   Frame frame;
   int currY;
   int fontHeight;
   
   static Dimension size = new Dimension(450, 300);
   
   public AboutChristmasCardCanvas(Frame frame)
   {
      this.frame = frame;
      resize(size);
   }

   /**
    * Paint the image. I.e the text
    */
   public void paint(Graphics g) {
      g.setColor(getBackground());
      g.fillRect(0, 0, size().width, size().height);
      g.setColor(getForeground());
      //offScreenGraphics.setFont(getFont());
      Font font = new Font("TimesRoman", Font.BOLD, 22);
      g.setFont(font);
      fontHeight = font.getSize();

      currY = 2*fontHeight;
      paintLine(g, true,  "ChristmasCard 1.4, 12/07/95");
      paintLine(g, true, "By Jan Andersson Torpa Konsult AB");
      font = new Font("TimesRoman", Font.BOLD, 16);
      g.setFont(font);
      fontHeight = font.getSize();
      currY += fontHeight;
      paintLine(g, false,
		"This Java Applet where inspired by Rick Jansen's Xsnow.");
      paintLine(g, false,
		"Check out Xsnow from the author's WWW page:");
      currY += fontHeight;
      paintLine(g, false,
		"      http://www.sara.nl/Rick.Jansen");
      currY += fontHeight;
      currY += fontHeight;
      paintLine(g, false,
		"Copyright (c)" +
		" 1984, 1988, 1990, 1993-1995 by Rick Jansen,");
      paintLine(g, false, "all rights reserved.");
      paintLine(g, false,
		"Copyright (c) 1995 by Jan Andersson, all rights reserved.");
      
   }

   /**
    * Paint a line of text.
    */
   public void paintLine(Graphics g, boolean center, String line)
   {
      int x = 10;
      if (center) {
	 FontMetrics fm = getFontMetrics(g.getFont());
	 int w = fm.stringWidth(line);
	 x = (size().width - w)/2;
      }
      currY += fontHeight;
      g.drawString(line, x, currY);
   }
}