SwatchITime.java

/**
 *	@(#)SwatchITime.java
 *	@version	0.5 01/09/99
 *	@version	1.0 01/10/99
 *	@author		Peter Theill
 *	
 *	This Applet displays current time using Internet Time: a new 
 *	international timeformat invented by Swatch. The SwatchITime 
 *	applet automatically updates every second (or in userdefined
 *	intervals) to symbolize a running clock. Furthermore, you'll
 *	be able to use <code>SwatchITime</code> as a standard 'local
 *	time' clock.
 *	
 *	Copyright(c) 1999 Peter Theill, ConquerWare
 *	All Rights Reserved.
 *	
 */

import java.applet.Applet;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Event;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MediaTracker;
import java.util.Date;

public final class SwatchITime extends Applet implements Runnable
{
	
	final String VERSION = "1.0";
	
	Thread thread;
	
	private Image osImage;
	private Graphics osGraphics;
	private Dimension osSize;
	
	private Font m_font;
	private Image m_imgBackground;
	private FontMetrics fm;
	
	private boolean bUsingITime = true;
	private int m_updateInterval = 1000;
	private int m_userInterval;
	private Color m_color;
	
	public void init()
	{
		String paramFontName, paramFontSize, paramColor, paramImage;
	
		// Get parameters
		if ( (paramFontName = getParameter("font")) == null)
			paramFontName = "SansSerif";

		if ( (paramFontSize = getParameter("size")) == null)
		  paramFontSize = "8";
		  
		if ( (paramColor = getParameter("color")) == null)
		  paramColor = "#000000";
	
		if ( (paramImage = getParameter("image")) == null)
			paramImage = "";
		
		try
		{
			m_userInterval = Integer.parseInt(getParameter("interval"));
		}
		catch (NumberFormatException nfe)
		{
			m_userInterval = 1000;
		}
		
		m_updateInterval = m_userInterval;
		
		// parse colorstring from e.g. #FF0000 to (255, 0, 0)
		try
		{
			int r = Integer.parseInt(paramColor.substring(1, 3), 16);
			int g = Integer.parseInt(paramColor.substring(3, 5), 16);
			int b = Integer.parseInt(paramColor.substring(5, 7), 16);
			m_color = new Color(r, g, b);
		}
		catch(Exception e)
		{
			e.printStackTrace();
			m_color = new Color(0, 0, 0);
		}
		
		// which mode do we have to start in?
		if ( getParameter("localtime") != null)
			bUsingITime = false;
		
		m_font = new Font(paramFontName, Font.PLAIN, Integer.parseInt(paramFontSize));
		
		// Load image used as background
		m_imgBackground = getImage(getCodeBase(), paramImage);
		
		// Show user information
		this.showStatus("Please wait while backgroundimage is loading...");
		
		// Add to our image tracker
		MediaTracker tracker = new MediaTracker(this);
		tracker.addImage(m_imgBackground, 0);
		
		// Make sure you've downloaded all images before proceeding
		try { tracker.waitForAll(); }
		catch(InterruptedException e) { System.err.println("Err: Images not loaded"); }
		
		this.showStatus("Running SwatchItime v" + VERSION);
	
	} // > public void init()
	
	
	/**
	 *	Starts thread
	 *
	 */
	public synchronized void start()
	{
		
		if (thread == null)
		{
		
			thread = new Thread(this);
			thread.start();
		
		}
		
	} // > public synchronized void start()


	/**
	 *	Stops thread
	 *
	 */
	public synchronized void stop()
	{
		
		thread.stop();
		thread = null;
		
		// Release font  
		m_font = null;
		
		// Release image
		m_imgBackground.flush();
		m_imgBackground = null;
		
	} // > public synchronized void stop()
	
	
	/**
	 *	Mainloop for thread. Paints canvas then goes to sleep
	 *	for a specified number of milliseconds. When it wakes
	 *	up (after specified time OR caused by a notify())
	 *	it just loops it all over again.
	 *
	 */
	public void run()
	{
		
		while (thread != null)
		{
			
			// paint canvas
			repaint();
			
			// go to sleep
			try { Thread.sleep(m_updateInterval); }
			catch (InterruptedException e) { ; }
			
		}
		
	} // > public void run()
	
	
	/**
	 *	The "paint" method is called by AWT when it wants us to
	 *	display our current state on the screen.
	 *
	 */
	public synchronized void paint(Graphics g)
	{
	
		if (osImage != null)
			g.drawImage(osImage, 0, 0, this);
	
	} // > public synchronized void paint(Graphics g)

  
	/**
	 *	Update canvas by drawing backgroundimage and text (either
	 *	Internet Time or Local Time) on a offscreen image. When
	 *	this is done, we update applet canvas by drawing offscreen
	 *	image to it.
	 *
	 */
	public synchronized void update(Graphics g)
	{
	
		// Get dimensions of appletcanvas
		Dimension d = size();

		if( (osImage == null) || (d.width != osSize.width) || (d.height != osSize.height) )
		{
			osImage = createImage(d.width, d.height);
			osSize = d;
			osGraphics = osImage.getGraphics();
			osGraphics.setFont(m_font);
			fm = getFontMetrics(m_font);
		}
		
		osGraphics.clearRect(0, 0, d.width, d.height);

		if (m_imgBackground != null)
			osGraphics.drawImage(m_imgBackground, 0, 0, this);
			
		String out;
		if (bUsingITime)
			out = "Internet Time @ " + calculateITime(new Date());
		else
			out = "Local Time is " + formatLocalTime(new Date());
			
		int x = (int)((d.width - fm.stringWidth(out)) / 2.0);
		int y = (int)((d.height - fm.getHeight()) / 2.0 + fm.getAscent());
			
		osGraphics.setColor(m_color);
		osGraphics.drawString(out, x, y);

		// update applet canvas
		g.drawImage(osImage, 0, 0, this);
		
	} // > public synchronized void update(Graphics g)

  
	/**
	 *	Converts local time to Swatch Internet Time.
	 *
	 *	@param	t		Date object with local time
	 *	@return	String	ITime between 000 and 999
	 *
	 */
	public String calculateITime(Date t)
	{
		
		String ITime = "00" + (int)(( ( ( t.getHours() + (t.getMinutes()/60.0) + (t.getSeconds()/3600.0) ) ) / 24.0 ) * 1000);
		return (ITime.substring(ITime.length()-3));
		
	} // > public int calculateITime(Date t)

	
	/**
	 *	Formats a Date object by appending it with '0' where
	 *	appropriate.
	 *
	 *	@param	t		Date object with local time
	 *	@return	String	Local time nicely formatted.
	 *
	 */
	public String formatLocalTime(Date t)
	{
		StringBuffer sb = new StringBuffer();
		int h, m, s;
		
		if ( (h = t.getHours()) < 10 )
			sb.append("0");
			
		sb.append(h + ":");
		
		if ((m = t.getMinutes()) < 10)
			sb.append("0");
			
		sb.append(m + ":");
		
		if ((s = t.getSeconds()) < 10)
			sb.append("0");
			
		sb.append(s);
		
		return (sb.toString());		
		
	} // > public String formatLocalTime(Date t)


	/**
	 *  Switch between Internet Time and Local Time. We'll have to
	 *  change 'update interval' too, since Local Time changes every
	 *  second, while Internet Time only changes every every 86th
	 *  second.
	 *
	 */
	public boolean mouseDown(Event evt, int x, int y)
	{
		String mode;
  	
  		// change boolean mode
  		bUsingITime = !bUsingITime;

		/**
		 * Set Intervaltime (in ms). Interval specified by user
		 * is in seconds, though.
		 */
		if (bUsingITime)
		{
			m_updateInterval = m_userInterval;
			mode = "Internet Time";
		}
		else
		{
			m_updateInterval = 1000; // one (1) second
			mode = "Local Time";
		}

		repaint();
		thread.notify();
		
		this.showStatus("Running SwatchItime v" + VERSION + " in " + mode + " mode");

    	return true;
    	
	} // > public boolean mouseDown(Event evt, int x, int y)
	
}