/*-----------------------------------------------------------------------------------------------------------------------------------------------+
|
|
|
|
+----------------------------------------------------------------------------------------------------------------------------------------------*/
import java.awt.AWTEvent.*;
import java.awt.event.*;
import java.util.Enumeration;
import javax.media.j3d.*;

public class keyboardBehavior extends javax.media.j3d.Behavior {

private TransformGroup visualObjectTG;
private Transform3D rotateX = new Transform3D();
private Transform3D rotateY = new Transform3D();
private Transform3D rotateZ = new Transform3D();
private Transform3D finalTransform = new Transform3D();
private boolean rotX = true;
private boolean rotY = false;
private boolean rotZ = false;
private double angleX = 0.0;
private double angleY = 0.0;
private double angleZ = 0.0;
private double scale = 0.0;

private WakeupOnAWTEvent listOfEvents =
                new WakeupOnAWTEvent( java.awt.AWTEvent.MOUSE_EVENT_MASK |
                                      java.awt.AWTEvent.KEY_EVENT_MASK );

/*-------------------------------------------------------------------------------------------------------------------------------------------------+
| NAME: keyboardBehavior
| AUTHOR: Bruno Caiado
| DATE: 15,February 2000
| COMMENTS: constructor
+------------------------------------------------------------------------------------------------------------------------------------------------*/
keyboardBehavior(TransformGroup visualObjectTG) {

        Transform3D transform = new Transform3D();
        this.visualObjectTG = visualObjectTG;
        visualObjectTG.getTransform(transform);
        scale = transform.getScale();

}//datasetBehavior

/*-------------------------------------------------------------------------------------------------------------------------------------------------+
| NAME: initializes
| AUTHOR: Bruno Caiado
| DATE: 15,February 2000
| COMMENTS:
+------------------------------------------------------------------------------------------------------------------------------------------------*/
public void initialize() {

        this.wakeupOn( listOfEvents );

}//initialize

/*-------------------------------------------------------------------------------------------------------------------------------------------------+
| NAME: newDatasetPosition
| AUTHOR: Bruno Caiado
| DATE: 15,February 2000
| COMMENTS: This method places the dataset in a new position in the virtual world. The dataset
|       is rotated according to the new x,y and z angle values. If you donīt want to rotate the
|       dataset around one or more axis just place -1 in the angle value. For intances, if you want
|       to rotate the dataset 0.5 around the x-axis and 0.3 around the y-axis call the method with:
|               newDatasetPosition(0.5, 0.3, -1)
+------------------------------------------------------------------------------------------------------------------------------------------------*/
public void newDatasetPosition(double angleX, double angleY, double angleZ) {

        if (angleX > -1) this.angleX = angleX;
        if (angleY > -1) this.angleY = angleY;
        if (angleZ > -1) this.angleZ = angleZ;
        rotateX.rotX(this.angleX);
        rotateY.rotY(this.angleY);
        rotateZ.rotZ(this.angleZ);
        rotateY.mul(this.rotateX);
        rotateZ.mul(this.rotateY);
        rotateZ.setScale(scale);
        visualObjectTG.setTransform(rotateZ);

}//newDatasetPosition

/*-------------------------------------------------------------------------------------------------------------------------------------------------+
| NAME: processStimulus
| AUTHOR: Bruno Caiado
| DATE: 15,February 2000
| COMMENTS:
+------------------------------------------------------------------------------------------------------------------------------------------------*/
public void processStimulus( Enumeration criteria) {

        java.awt.AWTEvent ocurredEvents[] = listOfEvents.getAWTEvent();
        int i,eventID;

        for (i=0;i < ocurredEvents.length; i++) {                             // process all the received events
                eventID = ocurredEvents[i].getID();
                switch( eventID ) {
                        case KeyEvent.KEY_PRESSED:                              // a key present event was received
                                KeyEvent aux = (java.awt.event.KeyEvent) ocurredEvents[i];
                                switch(aux.getKeyCode() ) {                             // Increase the angle value
                                                case KeyEvent.VK_S:
                                                    break;
                                                case KeyEvent.VK_O:
                                                if (rotX)
                                                        angleX += 0.1;
                                                else if (rotY)
                                                        angleY += 0.1;
                                                else if (rotZ)
                                                        angleZ += 0.1;
                                                rotateX.rotX(angleX);
                                                rotateY.rotY(angleY);
                                                rotateZ.rotZ(angleZ);
                                                rotateY.mul(rotateX);
                                                rotateZ.mul(rotateY);
                                                rotateZ.setScale(scale);
                                                visualObjectTG.setTransform(rotateZ);
                                                break;
                                        case KeyEvent.VK_P:                                     // Decrease the angle value
                                                if (rotX)
                                                        angleX -= 0.1;
                                                else if (rotY)
                                                        angleY -= 0.1;
                                                else if (rotZ)
                                                        angleZ -= 0.1;
                                                rotateX.rotX(angleX);
                                                rotateY.rotY(angleY);
                                                rotateZ.rotZ(angleZ);
                                                rotateY.mul(rotateX);
                                                rotateZ.mul(rotateY);
                                                rotateZ.setScale(scale);
                                                visualObjectTG.setTransform(rotateZ);
                                                break;
                                        case KeyEvent.VK_X:                                             // rotate around the x-axis
                                                rotX = true;
                                                rotY = false;
                                                rotZ = false;
                                                break;
                                        case KeyEvent.VK_Y:                                             // rotate around the y-axis
                                                rotY = true;
                                                rotX = false;
                                                rotZ = false;
                                                break;
                                        case KeyEvent.VK_Z:                                             // rotate around the z-axis
                                                rotZ = true;
                                                rotX = false;
                                                rotY = false;
                                                break;
                                        case KeyEvent.VK_R:                                             // Reset the angle values
                                                angleX = 0;
                                                angleY = 0;
                                                angleZ = 0;
                                                rotateX.rotX(angleX);
                                                rotateY.rotY(angleY);
                                                rotateZ.rotZ(angleZ);
                                                rotateY.mul(rotateX);
                                                rotateZ.mul(rotateY);
                                                rotateZ.setScale(scale);
                                                visualObjectTG.setTransform(rotateZ);
                                                break;
                                        default: break;
                                }
                                break;
                        case MouseEvent.MOUSE_CLICKED:          //a mouse pressed event was received
                                MouseEvent aux2 = (java.awt.event.MouseEvent) ocurredEvents[i];
                                switch (aux2.getModifiers() ) {
                                        case MouseEvent.BUTTON1_MASK:           // Start spining the object
                                                angleX = 0;
                                                angleY = 0;
                                                angleZ = 0;
                                                rotateX.rotX(angleX);
                                                rotateY.rotY(angleY);
                                                rotateZ.rotZ(angleZ);
                                                rotateY.mul(rotateX);
                                                rotateZ.mul(rotateY);
                                                rotateZ.setScale(scale);
                                                visualObjectTG.setTransform(rotateZ);
                                                break;
                                        default: break;
                                }
                                break;
                        default: break;
                }
        }

        this.wakeupOn( listOfEvents );                          // reactivate the behavior

}//processStimulus


}//rotateBehavior