EDITOR DE JAVA

Un ejemplo ms complejo del EAI creara clases del java que son reusables. Para crear un
editor en el java usted necesita poder crear varios nodos y entonces ser capaz de reacceder a
ellos para alterar sus propiedades. La nica manera real en que esto puede hacerse es tener
algna clase de estructura de datos que contenga los nodos generados por el applet.
Entonces o un evento del applet o la escena puede pasar la informacin a los campos de los
nodos en la escena. (se han incluido los fragmentos del cdigo ).
Para el editor que yo desarroll el objetivo principal era crear un mtodo simple de crear y
acceder un nodo shape en una escena. Para hacer esto yo decid que se capturan las
propiedades principales de cada forma en cuatro nodos: Un transform, shape, appearance y
el geometry tambin. Estos nodos le dan todas las propiedades de un shape que pueda
necesitar,eg:
Transform {
translation 0.0 0.0 0.0 //etc
children [
Shape {
appearance Appearance { material Material { diffuseColor 1.0 0.0 0.0} }//red!
geometry Box { }
}
]
}

As si usted necesita mover, cambiar el color, alterar el tamao tiene todo lo que usted
necesita en el un paquete. Tambin si nosotros agregamos un TouchSensor podemos hacer
que cada forma responda tambin a las acciones de los usuarios. As bsicamente
necesitamos una funcin que pueda crear los nodos correctos y pueda reunirlos:
protected Node createTransform(Browser browser){
//1:first we set up the three nodes for the scene
Node[] transArray = browser.createVrmlFromString(" Transform {} ");
Node[] shape = browser.createVrmlFromString(" Shape {} ");
Node[] appearance = browser.createVrmlFromString(" Appearance {} ");
//create the material node
Node[] materialArray = browser.createVrmlFromString(" Material { diffuseColor 1 0 0 } ");
material = materialArray[0];
//set transform to the first element of transArray, and then use transform throughout
transform = transArray[0];
//2:define the events needed to set the whole shape
EventInMFNode addToTransform = (EventInMFNode) transform.getEventIn("addChildren");
EventInSFNode setShape = (EventInSFNode) shape[0].getEventIn("set_geometry");
EventInSFNode setAppearance = (EventInSFNode) shape[0].getEventIn("appearance");
EventInSFNode setMaterial = (EventInSFNode)appearance[0].getEventIn("material");
//3: Now add the shape to the relevent events
setShape.setValue(this.setShape(browser));
setAppearance.setValue(appearance[0]);
setMaterial.setValue(material);
addToTransform.setValue(shape);

//try creating and adding a touchSensor \

Node[] TSS = browser.createVrmlFromString(" TouchSensor {} ");
touchSensor = TSS[0];
addToTransform.set1Value(0,touchSensor);
EventOutSFTime active = (EventOutSFTime)touchSensor.getEventOut("touchTime_changed");
active.advise(this,null);
return transform;
}

Bastante directamente, creamos un Transform, un Shape, un Appearance y entonces los

agregamos usando sus campos respectivos. Note sin embargo que el setShape tambin est
usando otra llamada a funcin:
setShape.setValue(this.setShape(browser));

El setShape es otro mtodo que devolver la figura geomtrica actual del nodo de esta
manera podemos heredar esta clase y todos que tenemos que hacer es la llamada a
super.createTransform () y entonces sobrecargar el mtodo setShape () y conseguimos la
figura deseada.
Aqu como un ejemplo el cdigo entero del cubo, sin los imports y declaraciones de
paquetes:

public class Box extends Transform {

Node box = null;
public Box(Browser browser) {
Browser b = browser;
Node transform = super.createTransform(b);
}
public Box(Browser browser, VRMLInterface myParent) {
parent = myParent;
Browser b = browser;
Node transform = super.createTransform(b);
}
protected Node setShape(Browser b) {
Node shapes[]= b.createVrmlFromString(" Box {} ");
Node shape = shapes[0];
return shape;
}
}

De esta manera la clase box y todos sus pequeos objetos instanciados pueden heredar
ahora un juego de mtodos de la clase Transform. Esto es podemos hacer mtodos para
acceder a todos los campos del Transform y Shape para que no necesitemos hacerlo
repetidamente desde el applet y como se heredan no necesitamos preocuparnos por ellos
para todas las formas.
(Un ejemplo de la estructura que tendr la clase del nodo Transform.)

Pasando el nodo a la escena

Ahora en el applet todo lo que tenemos que hacer es la importacin las nuevas formas, o
como un paquete o seperadamente, y entonces crearlas.
Box box = new Box(browser, this); //Explicare esto despus

Tenemos el objeto entonces pero no la forma.Necesitamos agregar esto a la escena usando

el campo del addChildren del nodo de la raz del mundo. Yo he llevado a cabo esto de dos
maneras y hay por lo menos una tercera:
Primero slo paso el principal nodo transform que contiene todos los otros nodos a la
escena:
addchildren.set1value(0,box.returnTransform());

Donde el addChildren es el EventIn del nodo de la raz y returnTransform () es un mtodo

que devuelve el Transforme del shape. O nosotros podramos pasar el EventIn al nodo
actual y podramos permitirle agregarse el mismo eg:
public void addTo(EventInMFNode add) {
add.set1Value(0,transform);
}

Fcil. Y usted podra simplificar las cosas pasando los valores de la raz dentro para que no
necesite agregar el EventIn. (Eliminar es aproximadamente lo mismo). Note que yo uso el
set1Value () todo el tiempo. Esto que yo he encontrado es bastante robusto y ms fcil de
usar. Y se realmente es l. Una vez usted ha preparado los archivos de Clase usted
realmente no necesita ya preocuparse por ellos. Debajo hay un ejemplo de cmo usted
puede usar este mtodo antes de que yo explique cmo usar el mtodo del callBack.
El cdigo para el listado del applet que maneja al editor.
Todos los campos del nodo son as accesibles al editor (aunque algunos no trabajan!). Esto
se hace guardando huella de los nodos en una arreglo y sacando los valores entonces de la
escena cuando necesit y entonces atrs de nuevo despus de que ellos se han alterado.
El cdigo se refiere al los mtodos Transform anteriormente.

EL CALLBACK
Manejando Callbacks
Otro rasgo de vrml es el hecho que la escena y los applet pueden comunicarse entre si a. La
escena puede usar el eventIn, la ruta de acceso setValue y la escena de VRML pueden usar
el mtodo del callback. Lo que yo ofrezco aqu es una solucin para hacer esto ms
extensible. La ruta que yo he tomado es intentar y permitir el acceso ms fcil a los shapes
a travs del callback. La idea era crear un paquete bsico que podra usarse para llevar a
cabo muchos applets bastante fcilmente. Como la parte de este paquete el mtodo del

callback se usa para los objetos para advertir el applet de acciones del usuario pero que los
applet no deben especificarse.
1. El mtodo del callback bsico
Cmo usar el mtodo del callback. Usted tiene que implementar la interfaz
EventOutObserver y entonces implementar el mtodo callBack :
class transform implements EventOutObserver {
public void callback(EventOut who, double when, Object which) {
//actions go here
}
}

ste es el mtodo bsico, aunque recuerde necesita poner uno del eventOuts para ser
elescucha eg:
EventOutSFTime active = (EventOutSFTime)touchSensor.getEventOut("touchTime_changed");
active.advise(this,null);

ste es el TouchSensor y cuando es tocado este se lo dice al mtodo callback. Vea arriba el
cdigo completo del TouchSensor.
2. El callback como la parte de un plan mayor
Cmo decirle a un applet que un evento ha ocurrido? Bien eso es ms duro. Lo qu
necesitamos hacer que el applet sea el padre de la clase aqu. Para hacer esto lo pasamos en
el applet como una referencia en un constructor:
public Transform(myApplet myParent) {
parent = myParent;
}

Note que el nombre de la clase del applet tiene que ser myApplet. Podemos pasar entonces
de regreso el Objeto que al que se peg en el applet:
public void callback(EventOut who, double when, Object which) {
parent.makeCurrent(this);
}

Donde en el padre tenemos:

public void makeCurrent(Transform current) {
//some actions performed on the shape
System.out.println("the shape is hit!!!");
int i = nodes.indexOf(current);//setting the array to the current element
this.setDisplay(i);
}

Este sabe entonces qu shape fue tocada y puede desplegarla y lo editarla. Pero esto es una
manera terrible de hacer las cosas. Necesitamos recompilar el Transform y las otras formas
pequeas cada vez nosotros cambiamos el applet al nuevo tipo del padre. As......

3. Usando un paquete y una interfaz

Usamos una interfaz para alertar el applet:
import vrml.external.field.*;
import vrml.external.*;
import vrml.external.exception.*;
public interface VRMLInterface{
public void makeCurrent(Transform current);
public Browser returnBrowser();
}//short and sweet

Hacemos entonces este el tipo del padre del Transform y entonces lo implementamos en el
applet:
public class listing extends Applet implements VRMLInterface { }

el applet entonces implementa los mtodos y se alerta asi cada vez que la forma se toca.

MS EN JAVA Y VRML
Parece que hay unas maneras alrededor de esto:
Acceda una escena pregenerada con un applet de java predefinido que sabe qu acceder...
muy tedioso fuera mas de unas creaciones.
Guardar el archivo java convirtindolo al texto.
Guardar el codigo java a travs de Serializacion de Objetos.
El primero no es una solucin sino el problema. El segundo podra ser til pero usted no
podra leer directamente el texto. Usted podra usar CreateVrmlFromString pero entonces
tiene slo un Node[] eso conforma a la cadena entera que es un nodo. Esto significa que
puede acceder slo a los parmetros generales de la escena. eg si el nodo principal fuera un
Transform entonces podra agregar nuevos hijos pero slo quitar esos no cualquiera en la
escena.
Esto significa que usted necesita reinterpretar la escena entera y convertir cada nodo de
VRML en un nodo del java equivalente y restaurar la escena va el applet. Todos esto
parece un poco como reinventar la rueda. Cul es el caso del parser de VRML? El punto
es que sus escenas son entonces completamente editables en lnea y visibles al instante.
Tambin otra ventaja es que la escena es tericamente compatible con otras escenas de
VRML. Podran cargarse como archivos de texto a la escena y entonces podran analizarse
y editarse.
La serializacion de objetos tambin sera muy til. Usted cree la escena, pase la escena
entera en alguna estructura de datos serializada y entonces recarge la escena simplemente
agregando la lista. Hasta ahora no he tenido el tiempo para hacer esto asi que aunque parece
estupendo no es tan fcil.

La seguridad
El problema principal ser acceder a los archivos. Debido al sistema de la proteccin de
Netscape no puede guardar archivos localmente. As cmo guarda su objeto serializado o
incluso su archivo de texto?
(tratando solo con texto) Cortar y pegar trabajaran. Tenga una rea del texto y entonces
corte y pegue de all a un archivo guardado localmente. Si usted ha estado ocupado tambin
podra hacer un parse invirtiendo el corte.
Enve el archivo a un servidor lo cual puede hacerse por ejemplo a travs de un script de
perl y entonces puede leerse el archivo del host remoto. La lectura y escritura del archivo
tiene que ser del sitio del que llego el applet.
Es el ltimo mtodo que sera preferible al anterior, aunque no es amistoso con el usuario,
es un mtodo de prueba temporal bueno mientras no necesite el applet en el servidor.