/*
    * @(#) GameLeaderInteractionLayer.java Nov 9, 2004
    * 
    * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628 BX
    * Delft, the Netherlands. All rights reserved.
    * 
    * See for project information <a href="http://www.simulation.tudelft.nl/">
    * www.simulation.tudelft.nl </a>.
    * 
   * The source code and binary code of this software is proprietary information
   * of Delft University of Technology.
   */
  package org.gscg.gameleader.interactionlayer;
  
  import java.awt.Dimension;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.ObjectOutputStream;
  import java.io.Serializable;
  import java.rmi.RemoteException;
  import java.rmi.server.UnicastRemoteObject;
  import java.text.DateFormat;
  import java.util.ArrayList;
  import java.util.Calendar;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.SortedSet;
  import java.util.Timer;
  import java.util.TimerTask;
  import java.util.TreeSet;
  
  import javax.naming.Binding;
  import javax.naming.NamingEnumeration;
  import javax.naming.event.EventContext;
  import javax.naming.event.NamespaceChangeListener;
  import javax.naming.event.NamingEvent;
  import javax.naming.event.NamingExceptionEvent;
  
  import nl.tudelft.simulation.actor.ActorInterface;
  import nl.tudelft.simulation.dsol.SimRuntimeException;
  import nl.tudelft.simulation.dsol.animation.D2.ImageRenderable;
  import nl.tudelft.simulation.dsol.animation.D2.Renderable2DInterface;
  import nl.tudelft.simulation.dsol.animation.D2.SingleImageRenderable;
  import nl.tudelft.simulation.dsol.experiment.Experiment;
  import nl.tudelft.simulation.dsol.experiment.Replication;
  import nl.tudelft.simulation.dsol.experiment.TimeUnit;
  import nl.tudelft.simulation.dsol.experiment.TimeUnitInterface;
  import nl.tudelft.simulation.dsol.simulators.AnimatorInterface;
  import nl.tudelft.simulation.dsol.simulators.DESSSimulatorInterface;
  import nl.tudelft.simulation.dsol.simulators.SimulatorInterface;
  import nl.tudelft.simulation.event.Event;
  import nl.tudelft.simulation.event.EventInterface;
  import nl.tudelft.simulation.event.EventListenerInterface;
  import nl.tudelft.simulation.event.EventType;
  import nl.tudelft.simulation.event.remote.RemoteEventListenerInterface;
  import nl.tudelft.simulation.language.d3.DirectedPoint;
  import nl.tudelft.simulation.language.swing.SwingWorker;
  import nl.tudelft.simulation.logger.Logger;
  import nl.tudelft.simulation.naming.InitialEventContext;
  import nl.tudelft.simulation.supplychain.actor.SupplyChainActor;
  import nl.tudelft.simulation.supplychain.animation.ContentAnimation;
  
  import org.gscg.common.GameAnimator;
  import org.gscg.common.gui.exceptions.ReceivedUnknownEventException;
  import org.gscg.common.interactionlayer.AnnounceInterface;
  import org.gscg.common.interactionlayer.ThreadedEventProducer;
  import org.gscg.common.interactionlayer.dataobjects.ProgressionData;
  import org.gscg.common.interactionlayer.location.YellowPage;
  import org.gscg.common.interactionlayer.messaging.ScenarioText;
  import org.gscg.common.interactionlayer.messaging.SocialMessaging;
  import org.gscg.common.interactionlayer.timecontrol.CurrentRowOrColumnNumber;
  import org.gscg.common.interactionlayer.timecontrol.GlobalProgressDateAndTime;
  import org.gscg.common.interactionlayer.timecontrol.GlobalRowOrColumnNumber;
  import org.gscg.common.interactionlayer.timecontrol.ProgressDateAndTime;
  import org.gscg.game.GameGlobalData;
  import org.gscg.gameactors.GameMarket;
  import org.gscg.gameleader.animation2D.GisActorAnimation;
  import org.gscg.gameleader.animation2D.GisActorImageDataElement;
  import org.gscg.gameleader.animation2D.GisGraphicsRenderable;
  import org.gscg.gameleader.animation2D.GisRenderable2D;
  import org.gscg.gameleader.animation2D.ImageDataElement;
  import org.gscg.gameleader.animation2D.ImageDataInterface;
  import org.gscg.gameleader.animation2D.SingleImageDataElement;
  import org.gscg.gameleader.animation2D.mouse.IntrospectionData;
  import org.gscg.gameleader.interactionlayer.experiment.ExperimentParser;
  import org.gscg.gameleader.interactionlayer.experiment.ExperimentParsingThread;
  import org.gscg.gameleader.interactionlayer.statistics.DemandStatistics;
  import org.gscg.gameleader.interactionlayer.util.EventTypeComparator;
  import org.gscg.gameleader.interactionlayer.util.IntrospectionUtil;
  import org.jdom.Element;
  
  /***
   * The game leader interaction layer is the layer between server-side game
   * control logic and a client-side game administrator application.
  * <p>
  * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628 BX
  * Delft, the Netherlands. All rights reserved.
  * 
  * See for project information <a href="http://www.simulation.tudelft.nl/">
  * www.simulation.tudelft.nl </a>.
  * 
  * The source code and binary code of this software is proprietary information
  * of Delft University of Technology.
  * 
  * @author <a
  *         href="http://www.tbm.tudelft.nl/webstaf/stijnh/index.htm">Stijn-Pieter
  *         van Houten </a>
  * @version $Revision: 1.2 $ $Date: 2005/08/03 08:52:50 $
  * @since 1.0.0 <br>
  */
 public class GameLeaderInteractionLayer extends ThreadedEventProducer implements
 		RemoteInteractionLayerInterface, NamespaceChangeListener
 {
 	/*** the serial version uid */
 	private static final long serialVersionUID = 13L;
 
 	/*** the object added event */
 	public static final EventType OBJECT_ADDED_EVENT = new EventType(
 			"OBJECT_ADDED_EVENT");
 
 	/*** the object removed event */
 	public static final EventType OBJECT_REMOVED_EVENT = new EventType(
 			"OBJECT_REMOVED_EVENT");
 
 	/*** the animation changed event */
 	public static final EventType ANIMATION_UPDATE_EVENT = new EventType(
 			"ANIMATION_UPDATE_EVENT");
 
 	/*** indicates whether this class has been deserialized */
 	private static boolean deserialized = false;
 
 	/*** indicates whether the bindings have already been looked up */
 	private static boolean bindingsLookedUp = false;
 
 	/*** the simulator events types for the interaction layer to subscribe to */
 	private EventType[] simulatorEventTypes = {
 			AnimatorInterface.ANIMATION_DELAY_CHANGED_EVENT,
 			AnimatorInterface.UPDATE_ANIMATION_EVENT,
 			SimulatorInterface.STOP_EVENT, SimulatorInterface.START_EVENT};
 
 	/*** the experiment */
 	private Experiment experiment = null;
 
 	/*** the client side event listeners */
 	private transient List clients = new ArrayList();
 
 	/*** indicates whether the client side game administrator is online */
 	private int numberLoggedIn = 0;
 
 	/*** the id of the interaction layer */
 	private String id = null;
 
 	/*** the event types this layer is subscribed to */
 	private Set eventsSentByClient = new HashSet();
 
 	/*** the elements of the animation panel */
 	private transient Set elements = Collections.synchronizedSet(new HashSet());
 
 	/*** contains the changed elements during an animation refreshment */
 	private transient Map changedElements = Collections
 			.synchronizedMap(new HashMap());
 
 	/*** the map with data elements of the images */
 	private transient Map imageDataElements = Collections
 			.synchronizedMap(new HashMap());
 
 	/*** a map with a key - source mappings */
 	private transient Map keySourceMap = Collections
 			.synchronizedMap(new HashMap());
 
 	/*** maps a remote event listener to its refresh rate */
 	private transient Map listenersRefreshRates = Collections
 			.synchronizedMap(new HashMap());
 
 	/*** maps a remote event listener to its timer */
 	private transient Map listenersTimers = Collections
 			.synchronizedMap(new HashMap());
 
 	/*** the map with actor keys */
 	private transient Map actorKeys = new HashMap();
 
 	/*** the timed animation refresher */
 	private TimedAnimationRefresher timedAnimationRefresher = null;
 
 	/*** we use this for persistency reasons */
 	private int numberOfTreatment = 0;
 
 	/*** we use this for persistency reasons */
 	private int numberOfReplication = 0;
 
 	/*** we use this for persistency reasons */
 	private String run = null;
 
 	/*** maps event types and corresponding announce objects */
 	private HashMap announceObjects = new HashMap();
 
 	/*** the event types this layer is subscribed to */
 	private Set statisticEventTypes = new TreeSet(new EventTypeComparator());
 
 	/*** the global supply chain data */
 	private GameGlobalData globalSupplyChainData = null;
 
 	/*** the scenario text */
 	private ScenarioText scenarioText = null;
 
 	/*** the social messaging */
 	private SocialMessaging socialMessaging = null;
 
 	/*** the yellowpage */
 	private YellowPage yellowPage = null;
 
 	/***
 	 * constructs a new GameLeaderInteractionLayer
 	 * 
 	 * @param id the id of the game administrator
 	 */
 	public GameLeaderInteractionLayer(final String id)
 	{
 		super();
 		this.id = id;
 		try
 		{
 			UnicastRemoteObject.exportObject(this);
 		} catch (RemoteException remoteException)
 		{
 			Logger.severe(this, "<init>", remoteException);
 		}
 
 		try
 		{
 			// we bind ourselves, may throw a naming exception
 			new InitialEventContext().bind(this.id, this);
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "<init>", exception);
 		}
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.event.EventListenerInterface#notify(nl.tudelft.simulation.event.EventInterface)
 	 */
 	public void notify(final EventInterface event) throws RemoteException
 	{
 		if (this.numberLoggedIn > 0)
 		{
 			if (event.getType()
 					.equals(AnimatorInterface.UPDATE_ANIMATION_EVENT))
 			{
 				synchronized (this.elements)
 				{
 					for (Iterator i = this.elements.iterator(); i.hasNext();)
 					{
 						Renderable2DInterface renderable = ((Renderable2DInterface) i
 								.next());
 						ImageDataInterface element = (ImageDataInterface) this.imageDataElements
 								.get(renderable.getSource().toString()
 										+ renderable.getSource().hashCode());
 						try
 						{
 							if (element != null)
 							{
 								if (!renderable.getSource().getLocation()
 										.equals(
 												new DirectedPoint(element
 														.getPoint()[0], element
 														.getPoint()[1], element
 														.getPoint()[2])))
 								{
 									synchronized (this.changedElements)
 									{
 										// we have a different location
 										element.setPoints(new double[]{
 												renderable.getSource()
 														.getLocation().x,
 												renderable.getSource()
 														.getLocation().y,
 												renderable.getSource()
 														.getLocation().z});
 										// for each of the remote event
 										// listeners we
 										// put the changed element in the array
 										// of
 										// changed elements
 										for (Iterator it = this.changedElements
 												.keySet().iterator(); it
 												.hasNext();)
 										{
 											((List) this.changedElements.get(it
 													.next())).add(element);
 										}
 									}
 								}
 							}
 						} catch (NullPointerException nullPointerException)
 						{
 							Logger.severe(this, "notify", nullPointerException);
 						}
 					}
 					return;
 				}
 			}
 			super.fireEvent(event);
 		}
 	}
 
 	/***
 	 * Method addStatisticEventType adds an event to a set with event types only
 	 * used for statistical updates. Upon initialization, a remote game leader
 	 * graphical user interface asks for this set. EventTypes which are added to
 	 * this set should follow the following convention ACTORROLE_ + description
 	 * of eventtype. E.g. CUSTOMER_DEMAND_CHANGED_EVENT.
 	 * 
 	 * @param eventType the event type to add
 	 */
 	public void addStatisticEventType(final EventType eventType)
 	{
 		if (!this.statisticEventTypes.contains(eventType))
 		{
 			this.statisticEventTypes.add(eventType);
 		}
 	}
 
 	/***
 	 * @see org.gscg.common.interactionlayer.GlobalInteractionLayerInterface#getCache(java.lang.Object,
 	 *      nl.tudelft.simulation.event.EventType, boolean)
 	 */
 	public void getCache(final Object remoteEventListener,
 			final EventType eventType, final boolean cache)
 			throws RemoteException
 	{
 
 		if (cache)
 		{
 			if (eventType.equals(YellowPage.UPDATE_ACTORS))
 			{
 				// pass the locations
 				this.globalSupplyChainData.getYellowPage().update(true, this);
 				return;
 			}
 			// since it is possible that multiple game leaders login, we need
 			// only to notify the game leader that is 'new', therefore, instead
 			// of firing an event, we directly notify the listener
 			if (eventType
 					.equals(SocialMessaging.UPDATE_RECEIVED_SOCIAL_MESSAGES))
 			{
 				for (int i = 0; i < this.socialMessaging
 						.getReceivedSocialMessages().size(); i++)
 				{
 					((RemoteEventListenerInterface) remoteEventListener)
 							.notify(new Event(
 									SocialMessaging.UPDATE_RECEIVED_SOCIAL_MESSAGE,
 									this, this.socialMessaging
 											.getReceivedSocialMessages().get(i)));
 				}
 				return;
 			}
 			if (eventType.equals(SocialMessaging.UPDATE_SENT_SOCIAL_MESSAGES))
 			{
 				for (int i = 0; i < this.socialMessaging
 						.getSentSocialMessages().size(); i++)
 				{
 					((RemoteEventListenerInterface) remoteEventListener)
 							.notify(new Event(
 									SocialMessaging.UPDATE_SENT_SOCIAL_MESSAGE,
 									this, this.socialMessaging
 											.getSentSocialMessages().get(i)));
 				}
 				return;
 			}
 			if (eventType.equals(SimulatorInterface.TIME_CHANGED_EVENT))
 			{
 				ProgressionData data = new ProgressionData(
 						GlobalProgressDateAndTime.getDate(),
 						GlobalProgressDateAndTime.getTime(),
 						GlobalProgressDateAndTime.getStopTime(),
 						GlobalProgressDateAndTime.getProgress(),
 						GlobalProgressDateAndTime.getProgressTime());
 				((RemoteEventListenerInterface) remoteEventListener)
 						.notify(new Event(
 								SimulatorInterface.TIME_CHANGED_EVENT, this,
 								data));
 				return;
 			}
 			new ReceivedUnknownEventException(this, "getCache", eventType);
 		} else
 		{
 			// no announce, for example for updating statistics
 			if (this.announceObjects.containsKey(eventType.toString()))
 			{
 				AnnounceInterface object = (AnnounceInterface) this.announceObjects
 						.get(eventType.toString());
 				object.announce(eventType, false);
 				return;
 			}
 			new ReceivedUnknownEventException(this, "getCache", eventType);
 		}
 	}
 
 	/***
 	 * @see org.gscg.common.interactionlayer.GlobalInteractionLayerInterface#login(nl.tudelft.simulation.event.remote.RemoteEventListenerInterface)
 	 */
 	public synchronized boolean login(final RemoteEventListenerInterface client)
 	{
 		if (!GameLeaderInteractionLayer.bindingsLookedUp)
 		{
 			GameLeaderInteractionLayer.bindingsLookedUp = true;
 			this.resolveBindings(GameLeaderInteractionLayer.deserialized);
 		}
 		boolean loggedIn = false;
 		if (this.numberLoggedIn > 0)
 		{
 			loggedIn = true;
 		}
 		this.numberLoggedIn++;
 		this.clients.add(client);
 		this.globalSupplyChainData.getYellowPage()
 				.updateInteractiveOnlineStatus(this, true, false);
 		return loggedIn;
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.experiment.ExperimentInterface#parseExperiment(org.jdom.Element)
 	 */
 	public void parseExperiment(final Element experimentElement)
 			throws RemoteException
 	{
 		if (this.experiment != null)
 		{
 			try
 			{
 				// we stop any running experiment
 				if (!this.experiment.getSimulator().isRunning())
 				{
 					this.experiment.getSimulator().stop();
 				}
 			} catch (Exception exception)
 			{
 				Logger.severe(this, "parseExperiment", exception);
 			}
 		}
 
 		try
 		{
 			this.experiment = ExperimentParser
 					.parseExperiment(experimentElement);
 
 			if (this.experiment != null)
 			{
 				this.experiment.setSimulator(new GameAnimator());
 				this.experiment.start();
 				this.experiment.getSimulator().stop();
 
 				// subscribe to simulator events
 				for (int i = 0; i < this.simulatorEventTypes.length; i++)
 				{
 					this.experiment.getSimulator().addListener(this,
 							this.simulatorEventTypes[i], false);
 				}
 
 				// we clean our animation history
 				this.elements.clear();
 				this.changedElements.clear();
 				this.imageDataElements.clear();
 				this.keySourceMap.clear();
 				this.listenersRefreshRates.clear();
 				this.listenersTimers.clear();
 
 				// create the timer for the animation
 				this.timedAnimationRefresher = new TimedAnimationRefresher(this);
 
 				// we set our experiment related numbers
 				this.numberOfTreatment = this.experiment.getSimulator()
 						.getReplication().getRunControl().getTreatment()
 						.getNumber();
 				this.numberOfReplication = this.experiment.getSimulator()
 						.getReplication().getNumber();
 				this.run = this.experiment.getRun();
 
 				// lookup the global supply chain data
 				this.globalSupplyChainData = (GameGlobalData) new InitialEventContext()
 						.lookup(GameGlobalData.CONTEXT_NAME);
 
 				// listen to global time control
 				new ProgressDateAndTime(this);
 				new CurrentRowOrColumnNumber(this);
 
 				this.socialMessaging = new SocialMessaging(this,
 						this.globalSupplyChainData.getYellowPage());
 
 				// the yellow page
 				this.yellowPage = this.globalSupplyChainData.getYellowPage();
 				this.yellowPage.addGameLeader(this);
 
 				// add actor to the location and name class
 				this.yellowPage.addListener(this, YellowPage.UPDATE_ACTORS,
 						false);
 				this.globalSupplyChainData.getYellowPage().addListener(this,
 						YellowPage.UPDATE_INTERACTIVE_PLAYER_STATUS, false);
 
 				// scenario text
 				this.scenarioText = (ScenarioText) new InitialEventContext()
 						.lookup(ScenarioText.CONTEXT_NAME);
 				this.scenarioText.addInteractionLayer(this);
 
 
 				// init statistics
 				for (Iterator it = this.globalSupplyChainData
 						.getSupplyChainActors().iterator(); it.hasNext();)
 				{
 					Object obj = it.next();
 					if (obj instanceof GameMarket)
 					{
 						new DemandStatistics(this, (GameMarket) obj);
 					}
 				}
 
 				// we notify the client
 				for (int i = 0; i < this.clients.size(); i++)
 				{
 					((RemoteEventListenerInterface) this.clients.get(i))
 							.notify(new Event(
 									ExperimentParsingThread.EXPERIMENT_PARSED_EVENT,
 									this, null));
 				}
 				// TODO do we need to implement something for a regular save,
 				// e.g. based on a timer task? We cannot schedule such a save on
 				// the event list, since saving and exeuting an event requires
 				// the same semaphore. --> deadlock....
 			}
 		} catch (Exception exception)
 		{
 			exception.printStackTrace();
 		}
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.SimulatorInterface#getSimulatorTime()
 	 */
 	public double getSimulatorTime() throws RemoteException
 	{
 		return this.experiment.getSimulator().getSimulatorTime();
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.SimulatorInterface#getReplication()
 	 */
 	public Replication getReplication() throws RemoteException
 	{
 		return this.experiment.getTreatments()[0].getRunControl()
 				.getReplications()[0];
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.SimulatorInterface#initialize(nl.tudelft.simulation.dsol.experiment.Replication)
 	 */
 	public void initialize(final Replication replication)
 			throws RemoteException, SimRuntimeException
 	{
 		this.experiment.getSimulator().initialize(replication);
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.SimulatorInterface#isRunning()
 	 */
 	public boolean isRunning() throws RemoteException
 	{
 		if (this.experiment != null)
 		{
 			return this.experiment.getSimulator().isRunning();
 		}
 		return false;
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.SimulatorInterface#start()
 	 */
 	public void start() throws RemoteException, SimRuntimeException
 	{
 		this.experiment.getSimulator().start();
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.SimulatorInterface#step()
 	 */
 	public void step() throws RemoteException, SimRuntimeException
 	{
 		this.experiment.getSimulator().step();
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.SimulatorInterface#stop()
 	 */
 	public void stop() throws RemoteException, SimRuntimeException
 	{
 		this.experiment.getSimulator().stop();
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.event.EventProducerInterface#removeListener(nl.tudelft.simulation.event.EventListenerInterface,
 	 *      nl.tudelft.simulation.event.EventType)
 	 */
 	public synchronized boolean removeListener(
 			final EventListenerInterface listener, final EventType eventType)
 	{
 		SwingWorker worker = new SwingWorker()
 		{
 			/***
 			 * @see nl.tudelft.simulation.language.swing.SwingWorker#construct()
 			 */
 			public Object construct()
 			{
 				Logger.info(this, "removeListener",
 						"Listener removed for event type: " + eventType);
 
 				return null;
 			}
 		};
 		worker.start();
 
 		// we assume that the game leader is offline
 		if (eventType.equals(SimulatorInterface.TIME_CHANGED_EVENT))
 		{
 			this.numberLoggedIn--;
 			if (this.clients.remove(listener))
 			{
 				Logger.info(this, "removeListener", "Game leader is offline");
 			}
 			if (this.numberLoggedIn == 0)
 			{ // no more game leaders, set status to inactive
 				this.yellowPage.updateInteractiveOnlineStatus(this, false,
 						false);
 			}
 		}
 		return super.removeListener(listener, eventType);
 	}
 
 
 	/***
 	 * @return Returns the id
 	 */
 	public String getId()
 	{
 		return this.id;
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.DESSSimulatorInterface#getTimeStep()
 	 */
 	public double getTimeStep() throws RemoteException
 	{
 		return ((DESSSimulatorInterface) this.experiment.getSimulator())
 				.getTimeStep();
 	}
 
 	/***
 	 * @see nl.tudelft.simulation.dsol.simulators.DESSSimulatorInterface#setTimeStep(double)
 	 */
 	public void setTimeStep(final double arg0) throws RemoteException
 	{
 		((DESSSimulatorInterface) this.experiment.getSimulator())
 				.setTimeStep(arg0);
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#getAnimationDelay()
 	 */
 	public long getAnimationDelay() throws RemoteException
 	{
 		return ((AnimatorInterface) this.experiment.getSimulator())
 				.getAnimationDelay();
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#setAnimationDelay(long)
 	 */
 	public void setAnimationDelay(final long arg0) throws RemoteException
 	{
 		((AnimatorInterface) this.experiment.getSimulator())
 				.setAnimationDelay(arg0);
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#getActorKeys()
 	 */
 	public Map getActorKeys() throws RemoteException
 	{
 		return this.actorKeys;
 	}
 
 	/***
 	 * @see org.gscg.common.interactionlayer.GlobalInteractionLayerInterface#getTotalNumberOfDays()
 	 */
 	public int getTotalNumberOfDays() throws RemoteException
 	{
 		return GlobalRowOrColumnNumber.getNumberOfDays();
 	}
 
 	/***
 	 * @see javax.naming.event.NamespaceChangeListener#objectAdded(javax.naming.event.NamingEvent)
 	 */
 	public void objectAdded(final NamingEvent namingEvent)
 	{
 		Renderable2DInterface element = null;
 		ImageDataElement dataElement = null;
 		try
 		{
 			element = (Renderable2DInterface) namingEvent.getNewBinding()
 					.getObject();
 			this.elements.add(element);
 			SingleImageRenderable object = (SingleImageRenderable) element;
 			String imagePath = null;
 			if (ContentAnimation.class.isAssignableFrom(object.getSource()
 					.getClass()))
 			{
 				imagePath = ((ContentAnimation) object.getSource())
 						.getImageURLlName();
 				String[] array = imagePath.split("!");
 				if (array.length == 1)
 				{
 					array = imagePath.split("classes");
 				}
 				imagePath = array[1];
 				dataElement = new SingleImageDataElement(element.getClass()
 						.getName(), element.getSource().toString()
 						+ element.getSource().hashCode(), imagePath, object
 						.getSource().getLocation(), new Dimension(25, 25),
 						object.isFlip(), object.getOrientation(), object
 								.isRotate(), object.isScale(), object
 								.isTranslate());
 
 				this.keySourceMap.put(element.getSource().toString()
 						+ element.getSource().hashCode(),
 						((ContentAnimation) element.getSource()).getContent());
 			} else
 			{
 				if (SingleImageRenderable.class.isAssignableFrom(element
 						.getClass()))
 				{
 					if (object.getImages() != null)
 					{
 						imagePath = object.getImages()[0].toString();
 						String[] array = imagePath.split("!");
 						if (array.length == 1)
 						{
 							array = imagePath.split("classes");
 						}
 
 						// we create our data elements and add it to the list
 						dataElement = new SingleImageDataElement(element
 								.getClass().getName(), element.getSource()
 								.toString()
 								+ element.getSource().hashCode(), array[1],
 								object.getSource().getLocation(),
 								new Dimension(object.getImages()[0]
 										.getIconWidth(), object.getImages()[0]
 										.getIconHeight()), object.isFlip(),
 								object.getOrientation(), object.isRotate(),
 								object.isScale(), object.isTranslate());
 					}
 
 					this.keySourceMap.put(element.getSource().toString()
 							+ element.getSource().hashCode(), element
 							.getSource());
 				} else
 				{
 					Logger.severe(this, "objectAdded",
 							"GameLeaderInteractionLayer object.getSource().getClass(): "
 									+ object.getSource().getClass());
 				}
 			}
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "objectAdded", exception);
 		}
 
 		if (dataElement != null)
 		{
 			this.imageDataElements.put(element.getSource().toString()
 					+ element.getSource().hashCode(), dataElement);
 			super.fireEvent(new Event(
 					GameLeaderInteractionLayer.OBJECT_ADDED_EVENT, this,
 					dataElement));
 		}
 	}
 
 	/***
 	 * @see javax.naming.event.NamespaceChangeListener#objectRemoved(javax.naming.event.NamingEvent)
 	 */
 	public void objectRemoved(final NamingEvent namingEvent)
 	{
 		try
 		{
 			synchronized (this.elements)
 			{ // we must synchronize
 				this.elements.remove(namingEvent.getOldBinding().getObject());
 
 				ImageDataInterface element = (ImageDataInterface) this.imageDataElements
 						.remove(((Renderable2DInterface) namingEvent
 								.getOldBinding().getObject()).getSource()
 								.toString()
 								+ ((Renderable2DInterface) namingEvent
 										.getOldBinding().getObject())
 										.getSource().hashCode());
 
 				this.keySourceMap.remove(((Renderable2DInterface) namingEvent
 						.getOldBinding().getObject()).getSource().toString()
 						+ namingEvent.getOldBinding().getObject().hashCode());
 
 				synchronized (this.changedElements)
 				{ // if the element exists in a changed list, we remove it
 					if (element != null)
 					{
 						for (Iterator it = this.changedElements.keySet()
 								.iterator(); it.hasNext();)
 						{
 							List list = (List) this.changedElements.get(it
 									.next());
 							list.remove(element);
 						}
 					}
 				}
 			}
 			super.fireEvent(new Event(
 					GameLeaderInteractionLayer.OBJECT_REMOVED_EVENT, this,
 					new SingleImageDataElement("",
 							((Renderable2DInterface) namingEvent
 									.getOldBinding().getObject()).getSource()
 									.toString()
 									+ ((Renderable2DInterface) namingEvent
 											.getOldBinding().getObject())
 											.getSource().hashCode(), null,
 							new DirectedPoint(0.0, 0.0, 0.0), null, false,
 							ImageRenderable.CC, false, false, false)));
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "objectRemoved", exception);
 		}
 	}
 
 	/***
 	 * @see javax.naming.event.NamespaceChangeListener#objectRenamed(javax.naming.event.NamingEvent)
 	 */
 	public void objectRenamed(final NamingEvent evt)
 	{
 		// nothing to do
 	}
 
 	/***
 	 * @see javax.naming.event.NamingListener#namingExceptionThrown(javax.naming.event.NamingExceptionEvent)
 	 */
 	public void namingExceptionThrown(final NamingExceptionEvent evt)
 	{
 		// nothing to do
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#getBindings()
 	 */
 	public Map getBindings() throws RemoteException
 	{
 		return this.imageDataElements;
 	}
 
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#getIntrospectedObjectData(java.lang.String)
 	 */
 	public IntrospectionData getIntrospectedObjectData(final String key)
 			throws RemoteException
 	{
 		return IntrospectionUtil.introspectObject(this.keySourceMap.get(key),
 				key);
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#updateIntrospectedObject(org.gscg.gameleader.animation2D.mouse.IntrospectionData)
 	 */
 	public void updateIntrospectedObject(final IntrospectionData data)
 			throws RemoteException
 	{
 		IntrospectionUtil.updateIntrospectedObject(this.keySourceMap.get(data
 				.getKey()), data);
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#setAnimationRefreshDelay(int,
 	 *      nl.tudelft.simulation.event.remote.RemoteEventListenerInterface)
 	 */
 	public void setAnimationRefreshDelay(final double times,
 			final RemoteEventListenerInterface listener) throws RemoteException
 	{
 		synchronized (this.changedElements)
 		{
 			if (!this.listenersRefreshRates.containsKey(listener))
 			{
 				this.changedElements.put(listener, Collections
 						.synchronizedList(new ArrayList()));
 				this.listenersRefreshRates.put(listener, new Double(times));
 
 				// we schedule a task
 				if (this.timedAnimationRefresher == null)
 				{
 					this.timedAnimationRefresher = new TimedAnimationRefresher(
 							this);
 				}
 				this.timedAnimationRefresher.scheduleTask(listener, times);
 			} else
 			{
 				this.listenersRefreshRates.put(listener, new Double(times));
 			}
 		}
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#removeAnimationRefreshDelayListener(nl.tudelft.simulation.event.remote.RemoteEventListenerInterface)
 	 */
 	public void removeAnimationRefreshDelayListener(
 			final RemoteEventListenerInterface listener) throws RemoteException
 	{
 		synchronized (this.changedElements)
 		{
 			// there is an error, lets remove the listener and
 			// all its objects belonging to him
 			this.changedElements.remove(listener);
 			this.listenersRefreshRates.remove(listener);
 			this.listenersTimers.remove(listener);
 		}
 	}
 
 	/***
 	 * @see org.gscg.gameleader.interactionlayer.RemoteInteractionLayerInterface#saveSimulation()
 	 */
 	public void saveSimulation() throws RemoteException
 	{
 		boolean running = false;
 
 		try
 		{
 			if (this.experiment.getSimulator().isRunning())
 			{
 				running = true;
 				try
 				{
 					this.experiment.getSimulator().stop();
 				} catch (Exception exception)
 				{
 					Logger.severe(this, "saveSimulation", exception);
 				}
 			}
 		} catch (RemoteException remoteException)
 		{
 			remoteException.printStackTrace();
 		}
 
 		try
 		{
 			SaveSimulationRunnable runnable = new SaveSimulationRunnable();
 			Thread thread = new Thread(runnable, "Save Simulation Thread");
 			thread.setPriority(Thread.MAX_PRIORITY);
 
 			thread.start();
 			// we join, and therefore wait till the thread has finished or
 			// died due to an exception
 			thread.join();
 		} catch (Throwable throwable)
 		{
 			Logger.severe(this, "saveSimulation", throwable);
 		}
 
 		if (running)
 		{
 			try
 			{
 				this.experiment.getSimulator().start();
 			} catch (Exception exception)
 			{
 				Logger.severe(this, "saveSimulation", exception);
 			}
 		}
 	}
 
 	/***
 	 * @see org.gscg.common.interactionlayer.GlobalInteractionLayerInterface#getStatisticEventTypes()
 	 */
 	public EventType[] getStatisticEventTypes()
 	{
 		return (EventType[]) this.statisticEventTypes
 				.toArray(new EventType[this.statisticEventTypes.size()]);
 	}
 
 	/***
 	 * @see org.gscg.common.interactionlayer.GlobalInteractionLayerInterface#addEventTypeSentByClient(nl.tudelft.simulation.event.EventType)
 	 */
 	public void addEventTypeSentByClient(final EventType eventType)
 	{
 		if (!this.eventsSentByClient.contains(eventType))
 		{
 			this.eventsSentByClient.add((eventType));
 		}
 	}
 
 	/***
 	 * @see org.gscg.common.interactionlayer.GlobalInteractionLayerInterface#addEventTypeToAnnounceList(nl.tudelft.simulation.event.EventType,
 	 *      org.gscg.common.interactionlayer.AnnounceInterface)
 	 */
 	public void addEventTypeToAnnounceList(final EventType eventType,
 			final AnnounceInterface announceObject)
 	{
 		String key = eventType.toString();
 		this.announceObjects.put(key, announceObject);
 	}
 
 	//
 	// private methods
 	//
 
 	/***
 	 * Resolves the bindings present in the context
 	 * 
 	 * @param deserialized indicates whether the simulation has been
 	 *        deserialized
 	 */
 	private void resolveBindings(final boolean deserialized)
 	{
 		try
 		{
 			String contextName = this.run + "/treatment("
 					+ this.numberOfTreatment + ")/replication("
 					+ this.numberOfReplication + ")/animation/2D";
 			EventContext context = (EventContext) new InitialEventContext()
 					.lookup(contextName);
 			NamingEnumeration list = context.listBindings("");
 			while (list.hasMore())
 			{
 				Binding binding = (Binding) list.next();
 				Renderable2DInterface element = (Renderable2DInterface) binding
 						.getObject();
 				this.elements.add(element);
 
 				Object obj = binding.getObject();
 				if (GisActorAnimation.class.isAssignableFrom(obj.getClass()))
 				{
 					GisActorAnimation object = (GisActorAnimation) obj;
 					String imagePath = object.getImages()[0].toString();
 					String[] array = imagePath.split("!");
 					if (array.length == 1)
 					{
 						array = imagePath.split("classes");
 					}
 
 					// we create our data elements and add it to the list
 					this.imageDataElements.put(element.getSource().toString()
 							+ element.getSource().hashCode(),
 							new GisActorImageDataElement(element.getClass()
 									.getName(), element.getSource().toString()
 									+ element.getSource().hashCode(), array[1],
 									object.getSource().getLocation(),
 									new Dimension(object.getImages()[0]
 											.getIconWidth(),
 											object.getImages()[0]
 													.getIconHeight()), element
 											.getSource().getClass().getName(),
 									((ActorInterface) element.getSource())
 											.getName()));
 					this.keySourceMap.put(element.getSource().toString()
 							+ element.getSource().hashCode(), element
 							.getSource());
 				} else if (SingleImageRenderable.class.isAssignableFrom(obj
 						.getClass()))
 				{
 					SingleImageRenderable object = (SingleImageRenderable) obj;
 					String imagePath = object.getImages()[0].toString();
 					String[] array = imagePath.split("!");
 					if (array.length == 1)
 					{
 						array = imagePath.split("classes");
 					}
 
 					// we create our data elements and add it to the list
 					this.imageDataElements.put(element.getSource().toString()
 							+ element.getSource().hashCode(),
 							new SingleImageDataElement(element.getClass()
 									.getName(), element.getSource().toString()
 									+ element.getSource().hashCode(), array[1],
 									object.getSource().getLocation(),
 									new Dimension(object.getImages()[0]
 											.getIconWidth(),
 											object.getImages()[0]
 													.getIconHeight()), object
 											.isFlip(), object.getOrientation(),
 									object.isRotate(), object.isScale(), object
 											.isTranslate()));
 					if (ContentAnimation.class.isAssignableFrom(object
 							.getSource().getClass()))
 					{
 						this.keySourceMap.put(element.getSource().toString()
 								+ element.getSource().hashCode(),
 								((ContentAnimation) element.getSource())
 										.getContent());
 					} else
 					{
 						this.keySourceMap.put(element.getSource().toString()
 								+ element.getSource().hashCode(), element
 								.getSource());
 					}
 				} else if (GisRenderable2D.class.isAssignableFrom(obj
 						.getClass()))
 				{
 					this.imageDataElements.put(element.getSource().toString()
 							+ element.getSource().hashCode(),
 							new ImageDataElement(element.getClass().getName(),
 									element.getSource().toString()
 											+ element.getSource().hashCode(),
 									element.getSource().getLocation(),
 									"/world.map.xml"));
 					this.keySourceMap.put(element.getSource().toString()
 							+ element.getSource().hashCode(), element
 							.getSource());
 				} else if (GisGraphicsRenderable.class.isAssignableFrom(obj
 						.getClass()))
 				{
 					this.imageDataElements.put(element.getSource().toString()
 							+ element.getSource().hashCode(),
 							new ImageDataElement(element.getClass().getName(),
 									element.getSource().toString()
 											+ element.getSource().hashCode(),
 									element.getSource().getLocation(),
 									"undefined"));
 					this.keySourceMap.put(element.getSource().toString()
 							+ element.getSource().hashCode(), element
 							.getSource());
 				} else
 				{
 					Logger.severe(this, "resolveBindings",
 							"GameLeaderInteractionLayer: unknown renderable implementation: "
 									+ obj.getClass());
 				}
 
 				// we check whether it is a supply chain actor, if so
 				// we add the actor key to our map of keys
 				if (element.getSource() instanceof SupplyChainActor)
 				{
 					String actorKey = element.getSource().toString()
 							+ element.getSource().hashCode();
 
 					// we split the actors based on their reference type
 					String[] split = element.getSource().getClass().getName()
 							.split("//.");
 					String mapKey = split[split.length - 1];
 					// is the key already present?
 					if (this.actorKeys.get(mapKey) == null)
 					{
 						// let's sort the actor keys alfabetically
 						SortedSet set = new TreeSet();
 						this.actorKeys.put(mapKey, set);
 					}
 					((Set) this.actorKeys.get(mapKey)).add(actorKey);
 				}
 			}
 
 			// we listen for new events
 			context.addNamingListener("", EventContext.SUBTREE_SCOPE, this);
 
 			if (!deserialized)
 			{
 				// we start listening for animation update events
 				this.experiment.getSimulator().addListener(this,
 						AnimatorInterface.UPDATE_ANIMATION_EVENT, false);
 			}
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "resolveBindings", exception);
 		}
 	}
 
 	/***
 	 * writes a serializable method to stream
 	 * 
 	 * @param out the outputstream
 	 * @throws IOException on IOException
 	 */
 	private synchronized void writeObject(final ObjectOutputStream out)
 			throws IOException
 	{
 		// we set our status to offline;
 		this.yellowPage.updateInteractiveOnlineStatus(this, false, true);
 
 		this.numberOfTreatment = this.experiment.getSimulator()
 				.getReplication().getRunControl().getTreatment().getNumber();
 		this.numberOfReplication = this.experiment.getSimulator()
 				.getReplication().getNumber();
 		out.defaultWriteObject();
 		// we reset our status to the original one
 		if (this.numberLoggedIn > 0)
 		{
 			this.yellowPage.updateInteractiveOnlineStatus(this, false, true);
 		}
 	}
 
 	/***
 	 * reads a serializable method from stream
 	 * 
 	 * @param in the inputstream
 	 */
 	private synchronized void readObject(final java.io.ObjectInputStream in)
 	{
 		try
 		{
 			in.defaultReadObject();
 
 			// custom deserialize methods
 			this.clients = new ArrayList();
 			this.listenersRefreshRates = Collections
 					.synchronizedMap(new HashMap());
 			this.listenersTimers = Collections.synchronizedMap(new HashMap());
 			this.actorKeys = new HashMap();
 
 			try
 			{
 				UnicastRemoteObject.exportObject(this);
 			} catch (RemoteException remoteException)
 			{
 				Logger.severe(this, "<readObject>", remoteException);
 			}
 
 			new InitialEventContext().bind(this.id, this);
 
 			// we clean our animation history
 			this.elements = Collections.synchronizedSet(new HashSet());
 			this.changedElements = Collections.synchronizedMap(new HashMap());
 			this.imageDataElements = Collections.synchronizedMap(new HashMap());
 			this.keySourceMap = Collections.synchronizedMap(new HashMap());
 
 			GameLeaderInteractionLayer.deserialized = true;
 
 			// create the timer for the animation
 			this.timedAnimationRefresher = new TimedAnimationRefresher(this);
 
 			// reset online status
 			this.numberLoggedIn = 0;
 
 		} catch (Exception exception)
 		{
 			Logger.severe(this, "readObject", exception);
 		}
 	}
 
 	/***
 	 * A Runnable used for saving the simulation.
 	 * <p>
 	 * (c) copyright 2005 <a href="http://www.simulation.tudelft.nl">Delft
 	 * University of Technology </a>, the Netherlands. <br>
 	 * See for project information <a
 	 * href="http://www.simulation.tudelft.nl">www.simulation.tudelft.nl </a>
 	 * <br>
 	 * 
 	 * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628
 	 * BX Delft, the Netherlands. All rights reserved.
 	 * 
 	 * See for project information <a href="http://www.simulation.tudelft.nl/">
 	 * www.simulation.tudelft.nl </a>.
 	 * 
 	 * The source code and binary code of this software is proprietary
 	 * information of Delft University of Technology.
 	 * 
 	 * @author <a
 	 *         href="http://www.tbm.tudelft.nl/webstaf/stijnh/index.htm">Stijn-Pieter
 	 *         van Houten </a>
 	 * @version $Revision: 1.2 $ $Date: 2005/08/03 08:52:50 $
 	 * @since 1.1.3
 	 */
 	private class SaveSimulationRunnable implements Runnable
 	{
 		/***
 		 * constructs a new SaveSimulationRunnable
 		 */
 		public SaveSimulationRunnable()
 		{
 			super();
 		}
 
 		/***
 		 * @see java.lang.Runnable#run()
 		 */
 		public void run()
 		{
 			// we sleep one second to give the simulator the chance to fire the
 			// SimulatorInterface.STOP_EVENT; otherwise a client side gui looks
 			// like it 'hangs', while in effect the simulation is paused.
 			try
 			{
 				Thread.sleep(1000);
 			} catch (InterruptedException interruptedException)
 			{
 				Logger.severe(this, "run", interruptedException);
 			}
 			// we synchronize with the animator; during serialization the
 			// animator is not able to advance in time nor executing an event of
 			// its eventlist
 			synchronized (((GameAnimator) GameLeaderInteractionLayer.this.experiment
 					.getSimulator()).gameSemaphore)
 			{
 				try
 				{
 					ThreadedEventProducer.DIJKSTRASEMAPHORE.acquireAll();
 
 					double time = Math.round(TimeUnit.convert(
 							GameLeaderInteractionLayer.this.experiment
 									.getSimulator().getSimulatorTime(),
 							GameLeaderInteractionLayer.this.experiment
 									.getSimulator().getReplication()
 									.getRunControl().getTreatment()
 									.getTimeUnit(), TimeUnitInterface.DAY));
 
 					// some formatting to get a nicely sorted list of saved
 					// simulations
 					String doubleAsString = "" + time;
 					String[] split = doubleAsString.split("//.");
 					String toFormat = split[0];
 					while (toFormat.length() <= 3)
 					{
 						toFormat = "0" + toFormat;
 					}
 					doubleAsString = toFormat + "." + split[1];
 
 					// the calendar for the wall clock time
 					Calendar calendar = Calendar.getInstance();
 					calendar.setTimeInMillis(System.currentTimeMillis());
 					String date = DateFormat.getDateTimeInstance().format(
 							calendar.getTime());
 					// replace any :
 					String[] dates = date.split(":");
 					date = dates[0] + "_" + dates[1] + "_" + dates[2];
 
 					FileOutputStream file = new FileOutputStream(
 							GameLeaderInteractionLayer.this.experiment
 									.getProperty(Experiment.EXPERIMENT_NAME)
 									+ " time in days "
 									+ doubleAsString
 									+ " wallclock " + date + ".ids");
 
 					// we remove the animation panel extent since it is not
 					// serializable
 					GameLeaderInteractionLayer.this.experiment.getSimulator()
 							.getReplication().getRunControl().getTreatment()
 							.getProperties().put("animationPanel.extent", "");
 
 					ObjectOutputStream fos = new ObjectOutputStream(file);
 					// we write these objects first since they are used to
 					// create a context
 					try
 					{
 						fos
 								.writeObject(GameLeaderInteractionLayer.this.experiment);
 						fos
 								.writeObject(GameLeaderInteractionLayer.this.experiment
 										.getSimulator().getReplication()
 										.getRunControl());
 					} catch (Exception exception)
 					{
 						fos.reset();
 						fos.flush();
 						fos.close();
 						file.close();
 						exception.printStackTrace();
 					} finally
 					{
 						try
 						{
 							// close the streams
 							fos.flush();
 							fos.close();
 							file.close();
 							fos = null;
 							file = null;
 						} catch (Exception exception2)
 						{
 							// we may ignore
 							exception2 = null;
 						}
 					}
 
 					Logger
 							.info(
 									this,
 									"saveSimulation",
 									"GameLeaderInteractionLayer: succesfully saved simulation to persistent storage");
 					ThreadedEventProducer.DIJKSTRASEMAPHORE.releaseAll();
 				} catch (Throwable exception)
 				{
 					ThreadedEventProducer.DIJKSTRASEMAPHORE.releaseAll();
 
 					// if a StackOverFlowError is thrown, most likely the Stack
 					// became too big due to the serialization process and NOT
 					// due to a programming mistake.... :-)
 					// we use"-Xmx512m" and -Xss2m for the VM while running the
 					// management application most likely the stack trace is
 					// never shown, since the stack is full....
 					exception.printStackTrace();
 				}
 			}
 		}
 	}
 
 	/***
 	 * 
 	 * The TimedAnimationRefresher manages refreshing the client side animation
 	 * panels.
 	 * <p>
 	 * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628
 	 * BX Delft, the Netherlands. All rights reserved.
 	 * 
 	 * See for project information <a href="http://www.simulation.tudelft.nl/">
 	 * www.simulation.tudelft.nl </a>.
 	 * 
 	 * The source code and binary code of this software is proprietary
 	 * information of Delft University of Technology.
 	 * 
 	 * @author <a
 	 *         href="http://www.tbm.tudelft.nl/webstaf/stijnh/index.htm">Stijn-Pieter
 	 *         van Houten </a>
 	 * @version $Revision: 1.2 $ $Date: 2005/08/03 08:52:50 $
 	 * @since 1.0.6 <br>
 	 */
 	private class TimedAnimationRefresher implements Serializable
 	{
 		/*** the serial version uid */
 		private static final long serialVersionUID = 13L;
 
 		/*** the timer */
 		private Timer timer = null;
 
 		/*** the owner */
 		private GameLeaderInteractionLayer owner = null;
 
 		/***
 		 * constructs a new TimedAnimationRefresher
 		 * 
 		 * @param owner the owner
 		 */
 		public TimedAnimationRefresher(final GameLeaderInteractionLayer owner)
 
 		{
 			this.timer = new Timer();
 			this.owner = owner;
 		}
 
 		/***
 		 * Method scheduleTask schedules a new timer task
 		 * 
 		 * @param listener the listener
 		 * @param times the number of times
 		 */
 		protected void scheduleTask(
 				final RemoteEventListenerInterface listener, final double times)
 		{
 			AnimationRefreshTask task = new AnimationRefreshTask(this,
 					listener, times);
 			this.timer.schedule(task, (long) ((1 / times) * 1000), // initial
 					// delay
 					(long) ((1 / times) * 1000)); // subsequent rate
 			this.owner.listenersTimers.put(listener, task);
 		}
 
 		/***
 		 * writes a serializable method to stream
 		 * 
 		 * @param out the outputstream
 		 * @throws IOException on IOException
 		 */
 		private synchronized void writeObject(final ObjectOutputStream out)
 				throws IOException
 		{
 			out.writeObject(this.owner);
 		}
 
 		/***
 		 * reads a serializable method from stream
 		 * 
 		 * @param in the inputstream
 		 */
 		private synchronized void readObject(final java.io.ObjectInputStream in)
 		{
 			try
 			{
 				this.owner = (GameLeaderInteractionLayer) in.readObject();
 				this.timer = new Timer();
 			} catch (Exception exception)
 			{
 				Logger.severe(this, "readObject", exception);
 			}
 		}
 
 		/***
 		 * <p>
 		 * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5,
 		 * 2628 BX Delft, the Netherlands. All rights reserved.
 		 * 
 		 * See for project information <a
 		 * href="http://www.simulation.tudelft.nl/"> www.simulation.tudelft.nl
 		 * </a>.
 		 * 
 		 * The source code and binary code of this software is proprietary
 		 * information of Delft University of Technology.
 		 * 
 		 * @author <a
 		 *         href="http://www.tbm.tudelft.nl/webstaf/stijnh/index.htm">Stijn-Pieter
 		 *         van Houten </a>
 		 * @version $Revision: 1.2 $ $Date: 2005/08/03 08:52:50 $
 		 * @since 1.0.0 <br>
 		 */
 		class AnimationRefreshTask extends TimerTask
 		{
 			/*** the owner */
 			private TimedAnimationRefresher owner = null;
 
 			/*** the listener */
 			private RemoteEventListenerInterface listener = null;
 
 			/***
 			 * constructs a new RemindTask
 			 * 
 			 * @param owner the owner
 			 * @param listener the listener
 			 * @param times the number of times
 			 */
 			public AnimationRefreshTask(final TimedAnimationRefresher owner,
 					final RemoteEventListenerInterface listener,
 					final double times)
 			{
 				super();
 				this.owner = owner;
 				this.listener = listener;
 			}
 
 			/***
 			 * @see java.lang.Runnable#run()
 			 */
 			public void run()
 			{
 				try
 				{
 					synchronized (this.owner.owner.changedElements)
 					{
 						List changes = (List) this.owner.owner.changedElements
 								.get(this.listener);
 
 						if (changes.size() > 0)
 						{
 							// we notify the listener directly and as such do
 							// not delay the running of the game thread while
 							// using animation as well, however, there is always
 							// the constraint of bandwith usage
 							this.listener
 									.notify(new Event(
 											GameLeaderInteractionLayer.ANIMATION_UPDATE_EVENT,
 											this.owner.owner, changes));
 							// we empty the list
 							changes.clear();
 						}
 
 						this.cancel();
 						// we schedule ourselves for a new round
 						// based on the latest number of times to refresh
 						this.owner
 								.scheduleTask(
 										this.listener,
 										((Double) this.owner.owner.listenersRefreshRates
 												.get(this.listener))
 												.doubleValue());
 					}
 				} catch (Exception exception)
 				{
 					// we cancel the task
 					this.cancel();
 					synchronized (this.owner.owner.changedElements)
 					{
 						try
 						{
 							// there is an error, lets remove the listener and
 							// all its objects belonging to him
 							this.owner.owner.changedElements
 									.remove(this.listener);
 							this.owner.owner.listenersRefreshRates
 									.remove(this.listener);
 							this.owner.owner.listenersTimers
 									.remove(this.listener);
 						} catch (Exception exception2)
 						{
 							// ignore
 							exception2 = null;
 						}
 					}
 					Logger.info(this, "AnimationRefreshTask",
 							"RemoteListener removed from timer task");
 				}
 			}
 		}
 	}
 }