import vrml.external.field.*;
import vrml.external.Node;
import vrml.external.Browser;
import vrml.external.exception.*;

import improv.actor.*;
import improv.actor.behavior.*;
import improv.event.*;
import improv.misc.*;
import improv.util.gui.*;
import improv.util.*;

import java.util.Hashtable;
import java.applet.Applet;

public class demo extends Applet implements EventOutObserver,ImprovObserver
{
	
	// The actor

	Actor actor;	      
	private Hashtable actorTable;
	private EventOut time;
	private Applet applet;
	private boolean initialized = false;

	// The EventOuts.   These allow users to set filter values from the VRML scene.
	
	private LayerPanel panel;
	private ImprovEditor editor;
	private NYUSplashScreen splash;
	int numActors = 0;

	// Stuff to get a handle to the VRML scene

	Browser browser; // The VRML Browser

	// The vrml nodes

	private Node timeNode;
	
	// The Layers


	public void init() {
		browser = Browser.getBrowser(this);
		try {
			splash = new NYUSplashScreen(this);		
			defBehavior();
			timeNode = browser.getNode("Time");
			time = timeNode.getEventOut("time");
			time.advise(this,null);
		} catch(InvalidNodeException e) { System.out.println("Problem: "+e); }
	}

	public void setBehavior(String state) {
		actor.setBehavior(state);
	}

	public void setProperty(String property, float value) {
		actor.setProperty(property,value);
	}

	public void showPanel() {
		panel = new LayerPanel(actor);
		panel.show();
	}
	public void showEditor() {
		editor = new ImprovEditor(actor);
		editor.show();
	}

/**
	Implemented as part of the ImprovObserver interface.  
	This is called by any ImprovObservable object to which this VRMLManager is an observer.
	This is usually not called directly, but is used by Improv to update the VRML scene.
*/

	public void handleImprovEvent(ImprovEvent evt) {
			switch(evt.id) {
				case ImprovTypes.SFObjectCHANNEL:
					((EventInSFNode)evt.arg).setValue((Node)(((SFObjectChannel)evt.target).getValue()));
					break;
				case ImprovTypes.SFStringCHANNEL:
					((EventInSFString)evt.arg).setValue(((SFStringChannel)evt.target).getValue());
					break;
				case ImprovTypes.SFBoolCHANNEL:
					((EventInSFBool)evt.arg).setValue(((SFBoolChannel)evt.target).getValue());
					break;
				case ImprovTypes.SFFloatCHANNEL:
					((EventInSFFloat)evt.arg).setValue(((SFFloatChannel)evt.target).getValue());
					break;
				case ImprovTypes.SFInt32CHANNEL:
					((EventInSFInt32)evt.arg).setValue(((SFInt32Channel)evt.target).getValue());
					break;
				case ImprovTypes.SFVec2fCHANNEL:
					((EventInSFVec2f)evt.arg).setValue(((SFVec2fChannel)evt.target).getValue());
					break;
				case ImprovTypes.SFVec3fCHANNEL:
					if(evt.arg instanceof EventInSFVec3f) 
						((EventInSFVec3f)evt.arg).setValue(((SFVec3fChannel)evt.target).getValue());
					else 
						((EventInSFColor)evt.arg).setValue(((SFVec3fChannel)evt.target).getValue());
					break;
				case ImprovTypes.SFRotationCHANNEL:
					SFRotationChannel chan = (SFRotationChannel)evt.target;
					((EventInSFRotation)evt.arg).setValue(chan.getValue());
					if(chan.xyzArg!=null) ((EventInSFVec3f)chan.xyzArg).setValue(chan.getXYZ());
					break;
				case ImprovTypes.MFObjectCHANNEL:
					Object nodes[] = ((MFObjectChannel)evt.target).getValue();
					for(int i=0;i<nodes.length;i++) ((EventInMFNode)evt.arg).set1Value(i,(Node)nodes[i]);
					break;
				case ImprovTypes.MFStringCHANNEL:
					((EventInMFString)evt.arg).setValue(((MFStringChannel)evt.target).getValue());
					break;
				case ImprovTypes.MFFloatCHANNEL:
					((EventInMFFloat)evt.arg).setValue(((MFFloatChannel)evt.target).getValue());
					break;
				case ImprovTypes.MFInt32CHANNEL:
					((EventInMFInt32)evt.arg).setValue(((MFInt32Channel)evt.target).getValue());
					break;
				case ImprovTypes.MFVec2fCHANNEL:
					((EventInMFVec2f)evt.arg).setValue(((MFVec2fChannel)evt.target).getValue());
					break;
				case ImprovTypes.MFVec3fCHANNEL:
					if(evt.arg instanceof EventInMFVec3f) 
						((EventInMFVec3f)evt.arg).setValue(((MFVec3fChannel)evt.target).getValue());
					else 
						((EventInMFColor)evt.arg).setValue(((MFVec3fChannel)evt.target).getValue());
					break;
				case ImprovTypes.MFRotationCHANNEL:
					((EventInMFRotation)evt.arg).setValue(((MFRotationChannel)evt.target).getValue());
					break;
				default: break;
			}
	}

/**
	Implemented as part of the EventOutObserver interface.  This is called in response to changes in eventOut 
	field values in the Improv VRML Nodes.
*/

	public void callback(EventOut evt, double d, Object o) {
			switch(evt.getType()) {
				case FieldTypes.SFTIME:
					actor.doFrame();
					break;
				default: break;
			}
	}
	
	public void defBehavior() {

	}

	public void makeActor(String name) {
		actor = new Actor(name,splash);
	}

	public Channel addChannel(String node,String event) {
		String name = node+":"+event;
		Node n = browser.getNode(node);
		EventIn eventIn = n.getEventIn(event);
		Channel chan = null;
		if(eventIn instanceof EventInSFBool) chan = new SFBoolChannel(name);
		else if(eventIn instanceof EventInSFInt32) chan = new SFInt32Channel(name);
		else if(eventIn instanceof EventInSFFloat) chan = new SFFloatChannel(name);
		else if(eventIn instanceof EventInSFString) chan = new SFStringChannel(name);
		else if(eventIn instanceof EventInSFVec2f) chan = new SFVec2fChannel(name);
		else if(eventIn instanceof EventInSFVec3f || eventIn instanceof EventInSFColor ) chan = new SFVec3fChannel(name);
		else if(eventIn instanceof EventInSFRotation) chan = new SFRotationChannel(name);
		else if(eventIn instanceof EventInSFString) chan = new SFStringChannel(name);
		else if(eventIn instanceof EventInSFNode) chan = new SFObjectChannel(name);
		if(chan!=null) {
			chan.addObserver(this,eventIn);
			actor.addChannel(chan);
		}
		return chan;
	}
	public Channel addChannel(String node,String event,int numValues) {
		String name = node+":"+event;
		Node n = browser.getNode(node);
		EventIn eventIn = n.getEventIn(event);
		Channel chan = null;
		if(eventIn instanceof EventInSFInt32) chan = new MFInt32Channel(name,numValues);
		else if(eventIn instanceof EventInMFFloat) chan = new MFFloatChannel(name,numValues);
		else if(eventIn instanceof EventInMFString) chan = new MFStringChannel(name,numValues);
		else if(eventIn instanceof EventInMFVec2f) chan = new MFVec2fChannel(name,numValues);
		else if(eventIn instanceof EventInMFVec3f) chan = new MFVec3fChannel(name,numValues);
		else if(eventIn instanceof EventInMFColor) chan = new MFVec3fChannel(name,numValues);
		else if(eventIn instanceof EventInMFRotation) chan = new MFRotationChannel(name,numValues);
		else if(eventIn instanceof EventInMFString) chan = new MFStringChannel(name,numValues);
		else if(eventIn instanceof EventInMFNode) chan = new MFObjectChannel(name,numValues);
		if(chan!=null) {
			chan.addObserver(this,eventIn);
			actor.addChannel(chan);
		}
		return chan;
	}
}