import vrml.external.field.*;
import vrml.external.Node;
import vrml.external.Browser;
import vrml.external.exception.*;
import netscape.javascript.JSObject;

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

import java.util.*;
import java.io.*;
import java.net.*;
import java.awt.Dialog;
import java.awt.Frame;
import java.applet.Applet;

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

	private 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 Vector eventOutVector = new Vector();
	private EventOut eventOuts[] = new EventOut[1024];
	private Vector eventOutReference = new Vector();
	private Vector eventInVector = new Vector();
	private LayerPanel panel;
	private ImprovEditor editor;
	private NYUSplashScreen splash;
	int numActors = 0;

	// Stuff to get a handle to the VRML scene

	private JSObject win;    // The Netscape Window
	private Browser browser; // The VRML Browser

	// The vrml nodes

    private Node rootNode;
	private Node body;
	private Node head;
	private Node leftEyeStalk;
	private Node rightEyeStalk;
	private Node leftEye;
	private Node rightEye;
	private Node leftPupil;
	private Node rightPupil;
	private Node timeNode;

	// The VRML scene EventIns (modified by the channel values)
	
	private EventInSFVec3f rootTransEI;
	private EventInSFRotation rootRotEI;
	private EventInSFRotation bodyRotEI;
	private EventInSFRotation headRotEI;
	private EventInSFRotation leftEyeStalkRotEI;
	private EventInSFRotation rightEyeStalkRotEI;
	private EventInSFRotation leftEyeRotEI;
	private EventInSFRotation rightEyeRotEI;
	private EventInSFVec3f leftPupilScaleEI;
	private EventInSFVec3f rightPupilScaleEI;	
	
	// The Improv channels

	private SFVec3fChannel rootTrans;
	private SFRotationChannel rootRot;
	private SFRotationChannel bodyRot;
	private SFRotationChannel headRot;
	private SFRotationChannel leftEyeStalkRot;
	private SFRotationChannel rightEyeStalkRot;
	private SFRotationChannel leftEyeRot;
	private SFRotationChannel rightEyeRot;
	private SFVec3fChannel leftPupilScale;
	private SFVec3fChannel rightPupilScale;

	// The Layers

	private Layer background,layer1,layer2;

	public void init() {
		browser = Browser.getBrowser(this);
		try {
			// Get Nodes from scene
			rootNode = browser.getNode("ROOT");
			body = browser.getNode("Body");			
			head = browser.getNode("Head");			
			leftEyeStalk = browser.getNode("LeftEyeStalk");			
			rightEyeStalk = browser.getNode("RightEyeStalk");			
			leftEye = browser.getNode("LeftEye");			
			rightEye = browser.getNode("RightEye");			
			leftPupil = browser.getNode("LeftPupil");			
			rightPupil = browser.getNode("RightPupil");

			splash = new NYUSplashScreen(this);
			
			// Create Actor

			actor = new Actor("Ned",splash);

			// Create Channels;
			rootTrans = new SFVec3fChannel("root translation");
			rootTransEI = (EventInSFVec3f)rootNode.getEventIn("set_translation");
			rootTrans.addObserver(this,rootTransEI);
			actor.addChannel(rootTrans);

			rootRot = new SFRotationChannel("root Rotation");
			rootRotEI = (EventInSFRotation)rootNode.getEventIn("set_rotation");
			rootRot.addObserver(this,rootRotEI);
			actor.addChannel(rootRot);

			bodyRot = new SFRotationChannel("body Rotation");
			bodyRotEI = (EventInSFRotation)body.getEventIn("set_rotation");
			bodyRot.addObserver(this,bodyRotEI);
			actor.addChannel(bodyRot);

			headRot = new SFRotationChannel("head Rotation");
			headRotEI = (EventInSFRotation)head.getEventIn("set_rotation");
			headRot.addObserver(this,headRotEI);
			actor.addChannel(headRot);

			leftEyeStalkRot = new SFRotationChannel("left eye stalk Rotation");
			leftEyeStalkRotEI = (EventInSFRotation)leftEyeStalk.getEventIn("set_rotation");
			leftEyeStalkRot.addObserver(this,leftEyeStalkRotEI);
			actor.addChannel(leftEyeStalkRot);

			rightEyeStalkRot = new SFRotationChannel("right eye stalk Rotation");
			rightEyeStalkRotEI = (EventInSFRotation)rightEyeStalk.getEventIn("set_rotation");
			rightEyeStalkRot.addObserver(this,rightEyeStalkRotEI);
			actor.addChannel(rootTrans);

			leftEyeRot = new SFRotationChannel("left eye Rotation");
			leftEyeRotEI = (EventInSFRotation)leftEye.getEventIn("set_rotation");
			leftEyeRot.addObserver(this,leftEyeRotEI);
			actor.addChannel(rightEyeStalkRot);

			rightEyeRot = new SFRotationChannel("right eye Rotation");
			rightEyeRotEI = (EventInSFRotation)rightEye.getEventIn("set_rotation");
			rightEyeRot.addObserver(this,rightEyeRotEI);
			actor.addChannel(rightEyeRot);

			leftPupilScale = new SFVec3fChannel("left pupil scale");
			leftPupilScaleEI = (EventInSFVec3f)leftPupil.getEventIn("set_scale");
			leftPupilScale.addObserver(this,leftPupilScaleEI);
			actor.addChannel(leftPupilScale);

			rightPupilScale = new SFVec3fChannel("right pupil scale");
			rightPupilScaleEI = (EventInSFVec3f)rightPupil.getEventIn("set_scale");
			rightPupilScale.addObserver(this,rightPupilScaleEI);
			actor.addChannel(rightPupilScale);

			// Add the layers
			
			State bg,def,lookLeft,lookRight,forward,eyesIn,eyesLeft,eyesRight;
			SFRotationFilter rot[] = new SFRotationFilter[7];
			SFVec3fFilter vec[] = new SFVec3fFilter[3];

			background = actor.addLayer("Background");
			bg = new State("Background");
			vec[0] = new SFVec3fFilter(rootTrans,0,0,0);
			rot[0] = new SFRotationFilter(rootRot,0,0,0);
			rot[1] = new SFRotationFilter(bodyRot,0,0,0);
			rot[2] = new SFRotationFilter(headRot,0,0,0);
			rot[3] = new SFRotationFilter(leftEyeStalkRot,0,0,0);
			rot[4] = new SFRotationFilter(rightEyeStalkRot,0,0,0);
			rot[5] = new SFRotationFilter(leftEyeRot,0,0,0);
			rot[6] = new SFRotationFilter(rightEyeRot,0,0,0);
			vec[1] = new SFVec3fFilter(leftPupilScale,1,1,1);
			vec[2] = new SFVec3fFilter(rightPupilScale,1,1,1);

			for(int i=0;i<rot.length;i++) {
				bg.addFilter(rot[i]);
			}
			for(int i=0;i<vec.length;i++) {
				bg.addFilter(vec[i]);
			}

			background.addBehavior(bg);
			
			layer1 = actor.addLayer("Layer 1");
			def = new State("Default - Layer 1");
			layer1.addBehavior(def);
			
			lookLeft = new State("Look Left");
			rot = new SFRotationFilter[3];
			rot[0] = new SFRotationFilter(headRot,0,90,0);
			NoiseCurve nx1 = new NoiseCurve(-20,20,1);
			NoiseCurve nz1 = new NoiseCurve(20,-20,1);
			rot[1] = new SFRotationFilter(leftEyeStalkRot,nx1,null,nz1);
			NoiseCurve nx2 = new NoiseCurve(20,-20,1);
			nx2.setOffset(.3);
			NoiseCurve nz2 = new NoiseCurve(-20,20,1);
			nz2.setOffset(.3);
			rot[2] = new SFRotationFilter(rightEyeStalkRot,nx2,null,nz2);
			for(int i=0;i<rot.length;i++) {
				lookLeft.addFilter(rot[i]);
			}
			layer1.addBehavior(lookLeft);

			lookRight = new State("Look Right");
			rot = new SFRotationFilter[3];
			rot[0] = new SFRotationFilter(headRot,0,-90,0);
			rot[1] = new SFRotationFilter(leftEyeStalkRot,nx2,null,nz2);
			rot[2] = new SFRotationFilter(rightEyeStalkRot,nx1,null,nz1);
			for(int i=0;i<rot.length;i++) {
				lookRight.addFilter(rot[i]);
			}
			layer1.addBehavior(lookRight);

			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;
			}
	}
}