Capítulo 12

1
VRML 2.0 con Java CAPÍTULO 12
La generación de VRML con

Java
Contenido CAPÍTULO 12
2
• Esquema del Proyecto

• Primeros pasos
• Estructura del Código
• La ventana del editor de
• El Árbol de la pantalla
• Agregar a la escena
• Escribir el archivo
• Eliminación de nodos
• Usar el Editor de
• ¿Cuál es la izquierda?
Esquema del Proyecto
Para un buen proyecto, siempre debe saber lo que estamos tratando de lograr
desde el principio. Debido a que este es más probable la primera aplicación
que utiliza la interfaz externa, vamos a seguir es relativamente sencillo en el
3
diseño al tiempo que cubre la mayoría de las partes importantes de la EAI.
El objetivo de este capítulo es para escribir un generador de VRML utilizando

sólo un applet de Java, un navegador de VRML, y el navegador Web. Podría
tonto y escribir sólo un sistema que te permite escribir en la escena gráfica en
una ventana de texto y, a continuación, coloca el archivo, pero eso sería hacer
trampa y definitivamente no es justo para usted. Lo que queremos es
conseguir un generador de VRML que permite seleccionar un objeto a partir de
una lista y, a continuación, colóquelo en la escena en el lugar adecuado. Como
tengo poco espacio aquí, voy a dejar a usted a hacer lo que quiera con el
código debería sentirse como mejorarla.
En el CD-ROM: Usted puede encontrar el código de la base de VRML

generador en el CD-ROM y también en mi sitio Web:
http://www.vlc.com.au/VermelGen/. Este generador será un proyecto en curso,
a fin de comprobar el sitio Web de actualizaciones periódicas, ya que su código
será sin duda más avanzado que el código presentado en este libro. El editor es
liberado bajo la licencia GNU. Si no está familiarizado con él, hay una copia en
la página principal y también se incluye en el archivo en el CD-ROM.
Básicamente dice que usted puede copiar y modificar el código para producir
su sistema que desee, siempre y cuando se obtiene un crédito para ello. Si
hace algo muy bien de él, le agradecería que caer un e-mail y dejar que me
eche un vistazo.
Esquema del interfaz de usuario
Uno de mis programas favoritos es el software de IDS V-Reino Builder, que

permite ver una lista de nodos de un lado y una actualización en tiempo real de
la escena, por el otro. Esta será la guía básica para influir en la interfaz de
usuario en este proyecto.
Para hacer la vida sencilla, habrá dos partes básicas para el programa: la
información en tiempo real, que es proporcionada por el navegador de VRML, y
la descripción gráfica de los contenidos de la escena, siempre en una ventana
aparte.
¿Por qué una ventana aparte? Quiero usar menús básicos para la escena de
fomento de la funcionalidad. Con pantallas pequeñas, que desea mostrar la
mayor cantidad de código y los gráficos como sea posible a la vez, por lo tanto,
con dos ventanas, no puedo poner el VRML en un lado y la interfaz de usuario
de Java en el otro, lo que permite máximo la pantalla de bienes raíces para el
VRML. (Otra ventaja de esto es que podemos avanzar muy rápidamente el
código Java para trabajar desde el navegador a través de un nodo de
secuencias de comandos en una fecha posterior.)
4
Funcionalidad
Voy a desarrollar el sistema, proporcionando un editor de base que puede

extenderse fácilmente. Nuestro editor de escenario sólo será capaz de insertar
un objeto en la escena de la derecha. Una vez que el objeto está allí, se queda.
No borrar, no cortar y pegar, y no cambiar las propiedades. Para simplificar,
vamos a restringir la salida también a la manipulación de base sólo primitivas
(Esfera, Cono, caja, cilindro) y las propiedades básicas tales como la posición y
el aspecto. El sistema no será capaz de escribir la escena en el disco, pero,
para demostrar que realmente puede generar el código, se escribe la salida a
una ventana.
Después de desarrollar este sistema, voy a mostrar lo fácil que es extender la

solicitud de base mediante la adición de supresión nodo. Si desea mover un
nodo a otro lugar en la escena gráfica, tendrás que borrar y empezar de nuevo
o llevarlo a usted a mejorar en mi código.
Cómo empezar
Hay mucho que hacer-, siempre es difícil decidir por dónde empezar. Podemos
comenzar con lo que va a aparecer en pantalla en primer lugar. Debido a que
están operando en un navegador Web, este punto de partida será una página
HTML.
HTML Esquema
Nuestro proyecto requiere de dos partes: un navegador VRML y añadido de un

applet de Java, que aparecerá en la misma página en el navegador Web. La
página se compondrá de la VRML navegador en la parte superior y debajo del
applet. El applet será muy sencillo, barra de botones con algunos controles
básicos.
No podemos decirle al navegador de VRML para situarse en la página HTML;

hay que darle la información básica mundo. Para ello, vamos a integrar una
muy simple mundo (incluidas en la siguiente sección), en la página HTML. Que
a continuación vamos a poner el applet. El archivo HTML para producir este
efecto se da en el Listado de 12.1.
12.1 La lista de archivos HTML para el Generador de VRML
<! DOCTYPE HTML PUBLIC "- / / IETF / / DTD HTML / / EN">

<HTML>
5
<HEAD>
Generador <TITLE> VRML </ TITLE>
</ HEAD>
<! --
(c) Copyright Justin Sofá,
Virtual Light Company de 1996.
Código liberado bajo la licencia GNU Copyleft.
->
<BODY>
<embed SRC="basic.wrl" Width="100%" HEIGHT="500">
<applet>
CÓDIGO = "VrmlGenerator.class"
HEIGHT = "40" width = "100%"
MAYSCRIPT
>
<PARAM
name = "top_directory"
value = "c | / users / justin / libros / LNV / java / editor"
>
</ APPLET>
</ BODY>
</ HTML>
Puedes ver todos los elementos básicos en el Listado 12.1. Me han incorporado
la escena VRML ancho total y dado que una altura de 500 píxeles. El VRML
fuente archivo se llama basic.wrl. Debajo de que pongo en la etiqueta APPLET
habituales para incluir el código Java, con una altura de 40, porque sólo habrá
una sola fila de botones en la parte inferior. Una vez más, esta barra de
botones se extenderá todo el ancho de la pantalla.
NOTA: Estoy suponiendo que usted va a correr con una resolución de pantalla de al menos 800x600 y 16
bits de color. Usted necesita la presente resolución al ser capaces de adecuarse a toda la información y los
cuadros de diálogo en la pantalla. También estoy suponiendo que se está ejecutando este proyecto en un
sistema que puede manejar nombres de fichero largos.
El parámetro de la etiqueta de applet el directorio de fuentes de donde se

colocará el código. Usted debe cambiar esta ruta para reflejar la ubicación del
archivo en su sistema.
6
Esquema de VRML
Así que aquí estamos tratando de escribir un generador de VRML, y tenemos que tener un
archivo VRML, incluso antes de empezar. Esto no tiene sentido! El motivo de esta captura-
22 se encuentra en lo profundo de la especificación de la clase de navegador.
Cuando llegamos a añadir un nodo que se han generado internamente, tenemos que tener
algunos padres de ese nodo. Por ejemplo, el createVrmlFromString () método devuelve un
conjunto de nodos. Para añadir estos nodos a la escena actual que necesita para pasar a la
del navegador de VRML. La única manera que usted puede hacer es añadir a los niños
como una pre-existente en el nodo de VRML escena actualmente visible. Poner
simplemente, tenemos que tener un nodo de agrupación como el nodo raíz en el mundo
VRML.
Ahora que sabemos que necesitamos un nodo de agrupación, es necesario que uno elija.
Para nuestros propósitos, este nodo sólo tiene que ser algo que podemos añadir y eliminar
nodos de. El Grupo de nodo es perfecto para este propósito.
Una vez que tenemos un nodo de la escena actual, tenemos que ser capaces de acceder a él
desde el applet. La única manera de hacerlo es dar el nodo DEF con un nombre y luego
recuperar una referencia a la misma con el getNode () método en el applet. No necesito
ningún procedimiento especial para ello, así que sólo lo llaman superusuario.
No necesito nada más en el archivo VRML, salvo las habituales de cabecera y un

comentario. El archivo completo de VRML para el mundo parece básico en el Listado 12.2.
12.2 La lista de archivos VRML basic.wrl que se ha incrustado en el Listado 12,1
# VRML V2.0 utf8

#
Código de Derecho de Autor # VermelGen Justin Sofá
# Virtual Light Company de 1996.
# Código liberado bajo GNU Copyleft.
# El mundo de base
DEF raíz Grupo ()
Seguridad en Java
Seguridad de Java es un gran tema que hace la vida difícil para nosotros, ya que nos
gustaría ser capaces de escribir nuestros archivos en el disco.
A pesar de que estamos creando un applet, el funcionamiento es realmente como una

aplicación. Todo está diseñado para ser cargado en la unidad de disco duro local, lo que
hace que para algunos problemas de seguridad en los navegadores web-consciente.
Tenemos que crear nuestro applet como una aplicación de confianza. A falta de darle la
7
firma digital, tenemos que buscar algún otro trabajo de Alternativas a la restricciones de
seguridad en Java applets.
El método más fácil de la creación de un applet de confianza que por lo general se trabaja
para incluir el código en un directorio que está en su CLASSPATH. Puede colocar el código
en un directorio ya existente o añadir un nuevo directorio en su CLASSPATH. Usted tendrá
que configurar el parámetro para source_directory el applet a este mismo directorio (ver la
sección anterior para obtener más información sobre el directorio de fuentes).
Java 1.1 y Netscape 4.0 se incluyen otras opciones para permitir el acceso a los applets de
la unidad de disco duro. Otras alternativas son el lugar para el applet de java en el directorio
de Netscape, o incluso en el directorio donde se encuentran las clases java .*.
Algunos navegadores web son muy cerrados de mente acerca de que permite el acceso a las
unidades locales, incluso a un applet de confianza. Por esta razón, he incluido una ventana
adicional que se mostrará el archivo de texto. Como primera solución, el código Java se
escribirá en esta ventana, usted tendrá la opción de tratar de escribir a su unidad local. Si la
escritura falla, siempre puedes hacer el viejo de cortar y pegar truco en su editor de texto
favorito.
Nota: No olvide guardar el archivo como texto plano, no como unicode o cualquier otro formato.
Recursos del código de Java

Java se ha convertido en una cosa grande en la Internet que usted puede encontrar siempre
el código que casi hace lo que quiere. Uno de los mejores sitios para usar un applet de Java
biblioteca es Gamelan (www.gamelan.com), que mantiene una colección de recursos de
Java. A través de una búsqueda inicial Gamelan puede ahorrarle el trabajo de reproducción
que han hecho otros y le puede dar algunas ideas para sus propias aplicaciones. (Gamelan
también ha comenzado a recoger artículos relacionados con el VRML!): Javasoft Un
crucero alrededor de la página de inicio (www.javasoft.com) también rendimientos
interesantes código.
Sin embargo, debido a VRML 2.0 y la interfaz externa son tan nuevas, todo el código que
se ha desarrollado desde cero, haciendo de esta una muy interesante reto. Todas las
estructuras de datos internas y la mayor parte de la interfaz de usuario se han desarrollado
por mí y un amigo, Cameron Gillies.
Quería mostrar una estructura de árbol de la escena gráfica que indica los nodos y cómo
encajan juntos. (Recuerde que estoy tratando de crear una interfaz de usuario similar a la V-
IDS Reino constructor.) Usé un widget de árbol de Thomas Koch (Koch
http://orgwis.gmd.de/ ~ / Java / Applets / TreeTool /) como el punto de partida. Sólo se
ofrece etiquetas de texto, pero la estructura general está ahí. Hemos mejorado
significativamente este paquete básico para añadir imágenes y texto, así como muchas otras
pequeñas mejoras.
8
Código de estructura
Este proyecto va a ser una tarea bastante compleja pieza de código, por lo que debemos
asegurarnos de que tenemos una buena estructura del código para evitar que un lío de cosas.
Hay tres partes principales del código: el código de inicio de aplicación, la interfaz de
usuario (IU), y el almacenamiento de datos interno. Vamos a colocar cada parte en paquetes
separados y tener un directorio de todas las imágenes.
El código de inicio inicializa todas las estructuras de datos y las interfaces de usuario. He
creado dos ventanas principales, además de la barra de botones en el applet. Una ventana es
el editor, y el otro es para el código de salida y es mucho más simple que el editor.
Código de inicio se mantiene en el directorio de nivel superior, en el mismo lugar que los
archivos HTML y VRML. Usted puede cambiar esta ubicación por tener una diferente
CODEBASE se especifica en la etiqueta APPLET. Las excepciones que podría generar el
código se mantienen en el conjunto de excepciones en virtud de este directorio de nivel
superior.
Interfaz de usuario
Creación de la interfaz de usuario (IU) en el código de este proyecto tiene la mayoría de los
esfuerzos y se puede subdividir en varias categorías, incluida la principal ventana del editor,
de un millón de cuadros de diálogo de diversas acciones, y un paquete separado para
mostrar el árbol en el editor . El árbol es una pieza bastante compleja de código en su
propio derecho, por lo que se mantiene en un paquete separado.
He cumplido con cada uno de diálogo y ventanas de su propia clase y creó una
sola instancia de cada clase al comienzo para que pueda ocultar y mostrar que
cuando se requiera. Yo prefiero este enfoque más dinámica la generación de
nuevos casos cada vez que quiera editar algo, porque es mucho más rápido
(especialmente cuando se ejecuta código Java interpretarse). Además de esa
ventaja, este enfoque también significa que sólo puede tener una copia de
cada cuadro de diálogo en la pantalla a la vez, por lo tanto, el ahorro de
confusión por parte del usuario. Otra buena razón para hacerlo de esta manera
es que la mayoría de los sistemas operativos tienen límites duros sobre el
número de ventanas abiertas, si están en constante creación de nuevos
cuadros de diálogo, es posible agotar los recursos del sistema, mientras que
todavía hay bastante memoria izquierda. Y si hay mucho de memoria, la
recolección de basura no liberar los recursos para usted. Así que la mejor
práctica es mantener a uno y sólo uno de cada uno alrededor.
Hay tres paquetes Java de la interfaz de usuario: la interfaz de usuario contiene

toda la interfaz gráfica de alto nivel de código, como los dos grandes ventanas
y el código de propósito general. En virtud de la interfaz de usuario hay dos
9
paquetes-ui.dialogs y ui.tree. El paquete contiene todos los cuadros de diálogo

de los cuadros de diálogo que se le viendo, y el árbol paquete contiene todo el
código gráfico de la escena del árbol pantalla.
Almacenamiento interno de datos
Este proyecto representa la de datos internos de la misma manera que los

datos son representados en VRML-como un árbol. Aunque los medios más
eficientes para el almacenamiento y la búsqueda están disponibles usando
Java o Hashtable tipos de vectores, decidí que lo mantenga a la estructura de
árbol para que pueda reutilizar algunos de los actuales códigos que he
construido para representar a los tipos de datos VRML. Java-siempre como
tipos de datos Vector y Hashtable son sin duda mucho menos eficiente que a
mano producidos tipos de datos, porque tienen que ser hilo de seguridad. En
Java esto se conoce muy importante para inducir a los gastos generales por el
sistema más lento por un factor de 5 a 10. Desde el interior de
almacenamiento de datos es sólo accede una vez a la vez, los gastos generales
son demasiado.
La estructura de datos elegida, que se presenta en el capítulo 23, imita los

nodos de VRML como clases Java. Esto tiene beneficios inherentes, en la
medida en que nos permite aplicar rápidamente la sintaxis correcta de VRML
utilizando Java la clase de normas y el compilador.
Estos tipos de datos se han modificado de manera que la estructura de datos

se escribe a sí mismo el flujo apropiado y, a continuación, llamar a cualquier
niño que puede tener un nodo. El resultado es un archivo VRML bien
formateado, con la sintaxis correcta garantizada por la estructura de datos.
Un pequeño problema que debemos abordar es cómo tratar con la raíz de la

escena gráfica. En un archivo VRML 2.0, usted puede tener múltiples nodos en
el nivel superior (que no es padre de nodo en el archivo de texto).
Afortunadamente, tenemos nuestra respuesta ya prevista en el Grupo de nodo
que se define en el archivo VRML basic.wrl. Una categoría especial se ha
creado para el nodo raíz. El nodo raíz de clase (conocida como VrmlRoot) actúa
como un nodo de grupo subclassing la GroupingNode interior de la biblioteca.
Sin embargo, contiene algunos extras, tales como la impresión de los
encabezados de archivo.
Nota: La estructura de la representación de datos VRML como clases Java es tratado en su

propio derecho en el caso de estudio en el capítulo 23. Voy a explicar lo menos posible aquí
sobre la forma en que se codifica, en lugar utilizar el espacio para tratar principalmente con la
interfaz de usuario y diseño general.
Además de la estructura de datos interna, necesitamos alguna forma de

10
relacionar la información a la pantalla de información interna. Porque no quiero

líos con el interior de las estructuras de datos demasiado, sigo en el enlace de
información a los distintos nodos en la pantalla de manipulación lado. Voy a
explicar más acerca de este breve.
Código para el interior de las estructuras de datos proviene de la biblioteca

JVerge, que existe como su propio sistema autónomo. Normalmente, esto sería
instalado en un lugar como c: \ java \ clases. El nombre del paquete es
vlc.vrml.external.geometry.
La ventana del editor de
Esta es la parte más importante de la aplicación, por lo que pasará bastante

tiempo explicarlo. En el exterior, que parece bastante normal de un tipo de
ventana. Tenemos la habitual barra de menú en la parte superior, una fila de
botones en el lado derecho, y la representación gráfica de la escena como la
característica principal.
La funcionalidad de la ventana del editor se guarda en el archivo

EditWindow.java, lo que está en el paquete de interfaz de usuario.
La barra de menú
La barra de menús consta de tres menús. Existe la costumbre menú Archivo

utilizable con dos opciones, una para mostrar el texto de salida y el otro para
cerrar la ventana. (Como se señaló anteriormente, no podemos guardar la
salida en el archivo en esta versión.) Junto a que es el menú Edición, con las
opciones estándar. He incluido dos opciones para la operación de pegar: Pegar
Antes y Después de Pegar. Si usted tiene un nodo seleccionado en un nodo de
agrupación, es posible que desee pegar en un nodo antes de que el nodo
seleccionado actualmente.
Nota: A diferencia de VRML 1.0, nodo pedido no es normalmente importante en VRML 2.0.
Todo lo que necesita para asegurarse de que cada nodo tiene la DEF declaró en el expediente
antes de que se utilice.
Por último, está el menú de nodo, lo que crea un nuevo nodo del tipo
seleccionado. Tengo los nodos agrupados en grupos más o menos la misma
que se utilizan en la especificación de VRML (aunque esto sería muy sencillo
para ti a cambio), pero más ordenado a lo largo de líneas funcionales. Por
ejemplo, poner la forma de nodo en la parte superior de la geometría de menú,
ya que será necesario muy a menudo y se utiliza siempre en combinación con
la geometría de los nodos.
He creado el menú de códigos de barras utilizando el código de Java, que

11
puede encontrar en el CD-ROM. Una cosa para notar es que cada menú tiene
una variable global, como se explicará en una sección posterior.
General de la ventana de diseño
La ventana principal, que se muestra en la Figura 12.1, tiene la barra de

accesos directos en el lado derecho y el diagrama de árbol a la izquierda. La
barra de accesos directos se mantiene en un ancho fijo a causa de una
colección de diseño de los administradores.
Figura 12.1 La ventana del editor de
Si tuviera que incluir el editor en la principal página HTML, que dejaría muy
poco espacio para nada más. Con esto en mente, he utilizado un marco como
la clase base para la clase EditWindow. El constructor se utiliza para configurar
la ventana de diseño básico y se muestra es Listado de 12.3.
Listado de 12,3 EditWindow Clase Esquema y Constructor
/ / Generador de VRML
/ / (C), Justin Sofá
/ /
/ / Desde el capítulo 12: Late Night VRML 2.0 y Java
/ /
/ / El contenedor de la ventana que tiene la ventana de edición
ui paquete;
importación java.awt .*;

importación java.net .*;
vrml.external.Browser de importación;
VrmlScene de importación;
VrmlTypes de importación;
12
ui.ImageButton de importación;
ui.VrmlTree de importación;
importación ui.dialogs .*;
clase pública se extiende EditWindow Marco

{
/ / Lotes privados de las variables aquí para los menús
privado NotImpDialog advertir;
NoSelectionDialog select_warn privado;
código de cadenas privadas;
VrmlTre screen_data privado;
VrmlScene vrml_data privado;
VrmlCheck vrml_checker privado;
/ / El constructor - crear la ventana de marco básico

público EditWindow (String code_base)
}
super ( "Generador de VRML");
Codebase = code_base;
/ / Limpieza de base para el marco

tamaño (400, 600);
setBackground (Color.lightGray);
setLayout (nuevo BorderLayout ());
/ / Crear el menú
createMenu ();
/ / Crear el panel lateral

añadir ( "Oriente", createPanel ());
/ / Crear el árbol de la lista

screen_data = new VrmlTree ( "Nuevo Archivo", code_base);
agregar ( "Centro", screen_data.display);
/ / Crear la talla única de diálogo de advertencia

advertir = new NotImpDialog (este);
select_warn = new NoSelectionDialog (este);
}
Para realizar las distintas subpartes se sientan en la correcta puntos, he usado

un administrador por defecto BorderLayout. Para arreglar la barra de accesos
13
directos a la derecha, he añadido como componente de la zona oriental. Luego

llena el resto de la ventana con el árbol subventana por lo que la convierte en
centro de tema.
También puede ver que debo hacer para establecer un tamaño fijo de la
ventana aquí. Esto podría ser fácilmente modificado para establecer el tamaño
sobre la base de las etiquetas PARAM en el archivo HTML, si es necesario.
Code_base la cadena pasada al constructor nos permite ubicar dónde nos
encontramos en el disco duro y poner en la ruta correcta de las imágenes.
Después de la limpieza general, viene el código para generar las distintas

partes de la ventana en diferentes métodos. Estos métodos serán cubiertos en
sus respectivas secciones a seguir.
Por último, se puede ver un ejemplo de cada uno de los dos cuadros de diálogo
en la parte inferior de la constructora. Estos están ahí para que yo puedo
llamar al método show en ellos cada vez que desee hasta el pop, que es mucho
más rápido que tener que crear nuevas instancias cada vez que quiero usar
una.
Barra de acceso directo
Me gusta trabajar con los botones de acceso directo a las solicitudes. Para
hacer mi vida más fácil, he decidido añadir un acceso directo a la barra para el
editor de nodos más comunes.
En mi experiencia de escritura a mano de los archivos, he encontrado que los

nodos más comúnmente utilizados son las primitivas (Caja, cono, cilindro, y
Esfera), aparición de propiedades como el color y texturas, y el Grupo
Transformar y nodos. Usando esta experiencia como una guía, me han puesto
estos temas en la barra de accesos directos.
La construcción de la barra de botones es muy simple: crear un grupo y usar

un gestor GridLayout para los botones. Con un Gridlayout, los botones están
siempre ajustados a ser del mismo tamaño. La otra opción disponible es para
configurar el gestor de diseño y, a continuación, de forma nula posición de los
botones en el panel. En esta primera etapa, este método es demasiado trabajo
en comparación con sólo dejar de Java manejar todo con el gestor de diseño,
por lo que se dejará para más adelante poner en orden, una vez que el código
principal se ha completado.
14
La determinación de la Entrada de usuario
Habiendo todos estos botones y los elementos de menú no es bueno a menos

que podamos determinar cuál fue seleccionado y, a continuación, realizar la
acción solicitada. La ventana de edición utiliza el método de acción de su padre
Marco para manejar todas las entradas del usuario de los botones y menús.
En este punto, la ventana se muestra en la Figura 12-1 con 10 o menos

elementos de menú en los menús Archivo y Edición, y un elemento de menú
para cada tipo de nodo de VRML disponibles. Hay otros 14 botones para hacer
frente a nosotros, incluso antes de empezar con los menús de cualquier otro
que podría añadir más tarde. Todos estos detalles de la interfaz se suman a
alrededor de 80 temas separados que hay que abordar. Algunos de
particionado con el fin de hacer más fácil nuestra tarea.
La primera división es el origen del evento, a saber, la separación de los

eventos de menú en el botón opciones. Listado de 12,4 indica que la forma
más sencilla de hacerlo es la comprobación de qué tipo de nodo objeto
generado el caso, con instanceof.
12.4 La lista de eventos de acción para la ventana principal
boolean acción pública (de evento e, Objeto arg)

{
if (e.target instanceof MenuItem)

processMenu (e, arg);
else if (e.target instanceof Botón)
processButton (e, arg);
return true;
Las dos llamadas a los métodos processMenu y processButton lidiar con sus
respectivos aportes. ProcessButton es muy simple: Hay sólo 14 opciones para
los botones, por lo que construir un gran si-otra escalera para hacer frente a
todas las posibilidades.
Nota: Es posible que haya notado que, para salvar los dos temas que estoy haciendo nada,
salvo que muestra el cuadro de diálogo de advertencia. Como he mencionado antes, la escritura
en un archivo de salida no se incluye en la limitación de la funcionalidad de este sistema.
15
El problema de la barra de menú es otro asunto por completo, ya que tenemos

tantas opciones adicionales para hacer frente a. De nuevo derribar la
transformación más, esta vez de acuerdo a los elementos de menú que viene.
Para obtener información acerca de este menú que se utilizó, utilizamos el
método de la getParent MenuItem. Listado de 12,5 como se muestra, esto
requiere, en primer lugar el caso de la fundición a un MenuItem objetivo y, a
continuación, la recuperación de los padres.
Listado de 12,5 subdividir el menú de entrada aún más
private void processMenu (Event e, Objeto arg)

{
Menú = padre (Menú) ((MenuItem) e.target). GetParent ();
if (padre == file_menu)
{
if ( "Nuevo". iguala (arg))
{
screen_data.deleteAll ();
vrml_data.deleteAll ();
}
else if ( "Guardar". iguala (arg))
warn.show ();
else if ( "Guardar como". iguala (arg))
warn.show ();
else if ( "Cerrar". iguala (arg))
this.hide ();
}
else if (padre == edit_menu)
processEditMenu (e, arg);
algo más
processNodeMenu (e, arg, padre);
}
Ya que había muy poco que ver en el menú Archivo, me han tratado esta línea
en lugar de crear un nuevo método.
Dentro de processNodeMenu, entonces subdividir aún más las tareas. El menú

principal se pasa como argumento a los padres y el menú se compara con la
referencia de cada menú que se creó cuando hice el menú en el constructor. Al
hacer esto, normalmente puede mantener el número de comparaciones en
cadena a menos de 10. Cadena de comparaciones son mucho más lentos que
una recta de referencia entre dos referencias instancia, por lo que el poco de
procesamiento adicional vale la pena por la rapidez.
16
El Árbol de la pantalla
Ahora que hemos construido todos los periféricos, podemos pasar a la parte
principal del programa: la pantalla gráfica del archivo VRML. En su propio
derecho, esta es la parte más compleja del editor, y que obtiene su propio
paquete-ui.tree.
Esta pantalla se compone de varios componentes: un panel desplegable

(ScrollPanel.java), el lienzo que se refiere a las entradas de usuario
(TreeCanvas.java), el árbol de estructura de datos (Tree.java), y los distintos
sectores que componen el árbol ( TreeNode.java). Para asegurarnos de que
tenemos el marco adecuado cuando se trata de la entrada del usuario, también
existe una interfaz llamada TreeToolObserver.
Hacer frente a la Entrada de usuario
Manejo de los comentarios de los usuarios de un lienzo no es una tarea fácil.

Para describir todo el diseño del sistema tendrá más espacio que tengo para
este capítulo. Voy a pasar por alto la mayoría de los detalles, así que si usted
está interesado en ver cómo funciona todo esto, eche un vistazo al código de
este sistema, que se incluye en el CD-ROM.
El sistema básico es que el lienzo "mouseDown recibe acontecimientos y, a

continuación, busca en el nodo de árbol para el que pertenece a este evento. Si
el nodo no ha sido seleccionada, se destacó, la clase y la aplicación de la
TreeTool-Obeserver se notifica. Si el nodo ha sido seleccionado y, a
continuación, o bien se abre o se cierra esa rama (en función de su estado
anterior) o bien llamando a la openNode o closeNode método de ese nodo. De
aquí el nodo o bien abre o cierra la subbranches según el caso (que recuerda el
estado de la subarbol). Al final de toda esta actividad, el nuevo estado del árbol
está pintado en la pantalla.
Conexión de la pantalla a la interna de datos
Si esto es todo lo que era, las cosas serían muy simples. El problema al que nos
enfrentamos es entonces, ¿cómo asociar a lo que se visualiza en la pantalla a
nuestro interior la estructura de datos?
Una solución sería construir un sistema completamente personalizado para

este proyecto. Cada nodo contendrá no sólo los datos de VRML, pero también
la pantalla de datos. Sin embargo, es posible recordar que en el comienzo de
este capítulo, he dicho que quería volver a utilizar mi código existente para el
VRML estructuras de datos. Esto significa que tendría que sea subclase de cada
una de estas clases (todos los 54 de ellos) o agregar código y métodos, por lo
17
tanto, ya sea destruyendo su uso en futuros proyectos o exigiendo a mantener

varias versiones del código.
Nuestra otra opción es utilizar Java subclassing capacidad de crear una

subclase de la única TreeNode e incluir cualquier información adicional. Esta
opción es preferido por obvias razones. Con este método, no es necesario tocar
cualquiera de los códigos internos de cualquiera de la interfaz de usuario o el
VRML estructuras; simplemente construir encima de ellos. La belleza de este
enfoque es que muy poco más de código debe ser escrito. Listado de 12,6
contiene el código completo necesario para asociar la VRML de datos con la
interfaz de usuario sin alterar tampoco.
Listado de 12,6 VrmlTreeNode Proporciona la cola entre el interno de datos y la

interfaz de usuario
/ / (C) 1996 Justin Sofá
/ /
/ / Desde el capítulo 12 Late Night VRML 2.0 y Java
/ /
/ / Subclassed versión de TreeNode que también mantiene el puntero
/ / A la estructura interna y VRML. Esto es así cuando el
/ / Objeto está seleccionado también sabe dónde insertar el
/ / Objeto en la escena gráfica.
ui.tree paquete;
ui.tree.TreeNode de importación;
geometry.VrmlObject de importación;
clase pública se extiende VrmlTreeNode TreeNode

{
VrmlObject vrmlNode público;
VrmlTreeNode público (VrmlObject nodo,
Cadena de título,
OpenFolder cadena,
Cadena ClosedFolder)
{
super (título, OpenFolder, ClosedFolder);
vrmlNode = nodo;
}
18
Como se puede ver en el Listado de 12.6, es realmente muy poco existe en

absoluto. Acabo de la subclase de la clase TreeNode y luego añadir un adicional
variable pública, que es una referencia a la estructura de datos en VRML que se
pasa al constructor. Siempre que un nodo está seleccionado en la pantalla,
ahora podemos inmediatamente se refieren a la estructura de datos VRML que
representa por colada a VrmlTreeNode (el árbol alrededor de los objetos
TreeNode en respuesta a la entrada del usuario) y busca en el nodo.
El interno de referencia es un VrmlObject clase. Esta es la clase base de que

todos mis VrmlObjects subclase. Al utilizar este como el tipo, no puedo colocar
cualquiera de los nodos en VRML aquí para su uso en una etapa posterior.
Añadiendo a la escena
Por supuesto, tener un editor no es bueno si no vamos a editar archivos. Para

que esta funcionalidad, tenemos que prestar un poco de pegamento entre la
barra de menú / barra de accesos directos, el árbol de la ventana, y el interior
de las estructuras de datos.
Una de las mejores características que me gustaría ver en un editor es la

capacidad para producir archivos correctos sintácticamente como que usted
está escribiendo ellos. Esta es una característica de este editor: Se tirará hasta
que muy temprano en el proceso de agregar un nodo.
Dónde Añadir un nuevo nodo
Después de haber decidido que vamos a añadir un nodo a la escena (utilizando

el método processButton o processNodeMenu), la primera cosa que queremos
hacer es asegurarnos de que un nodo de destino ha sido seleccionado. Esto es
muy simple: todos los que tenemos que hacer es comprobar que la variable
seleccionada del árbol no es nulo. Si es nulo, el pop hasta un cuadro de diálogo
para indicar al usuario que deberá seleccionar un nodo de salida y la primera
transformación, de este modo:
if (screen_data.selected == null)
{
select_warn.show ();
retorno;
}
19
Así que ahora sabemos que tenemos un nodo padre, y también sabemos qué
tipo de nodo está a punto de ser añadido. Lo único que queda es dibujar en la
pantalla y añadir a la estructura de datos interna, ¿no? Bueno, de tipo.
Leyendo.
Comprobación de la coherencia
Hay dos partes a la coherencia en el control de este programa. La primera es

asegurarse de que siempre la interpretación de las cosas de la misma manera
en todo el programa, y el otro es para asegurarse de que la pantalla de datos
coincide con los datos internos, que a su vez coincide con los requisitos
establecidos en la especificación de VRML.
La clase VrmlType
Una de las muchas cosas que constantemente se generan errores de código

diferentes interpretaciones de los argumentos que se pasaron en torno a un
programa. Para asegurarse de que no caigan en esta trampa, he creado una
clase que se utiliza en los casos en VRML tipo de nodo es la información que se
pasa a través de llamadas a los métodos.
La clase consiste VrmlType puramente como una lista de los tipos de nodo de
VRML. Cada nodo se representa como una final entero. Siempre que un tipo de
nodo que se pasa entre los métodos, se usa un número, y esta clase es para
ser utilizado como la interpretación de ese número entero.
Nodo a nodo Coherencia
Antes de solicitar al usuario definir los detalles del pedido nodo, tenemos que
pasar por una prueba más. Esta vez se trata de mantener la correcta sintaxis
de VRML, por lo que necesitamos para determinar el nodo padre a la que
estamos añadiendo el nuevo nodo.
Ya tenemos el nodo padre a nuestra disposición, cortesía de nuestro

VrmlTreeNode clase. Sabemos lo que el niño se de el botón / menú que fue
seleccionado. Sabemos también lo que el padre vaya a ser, por recuperar el
nodo desde el nodo seleccionado en la pantalla. Cada tipo de nodo tiene sus
propias reglas en cuanto a lo que el padre puede ser, pero podemos hacer
algunas generalizaciones. Por ejemplo, podemos añadir un nodo sólo desde el
tipo de geometría nodos (recuadro, cilindro, etc) a un tipo de figura nodo.
Comprobación de la correcta padre es tan simple como comprobar que el padre
20
es una instancia de la clase correcta tipo.
Digamos que desea añadir una casilla a la escena. Para comprobar que el
padre es una forma de nodo, que se utiliza el siguiente código:
if (! (padre instanceof Forma))

{
gen_warn.show ( "Usted necesita una forma para la" +
"padre de la geometría nodos");
retorno;
}
Si la prueba anterior es verdad (es decir, el padre no es una forma), luego

aparecerá el cuadro de diálogo diciendo así, entonces la salida.
Demasiados niños?
Después de haber decidido que estamos añadiendo a los padres el tipo

correcto, necesitamos hacer un cheque a algunos nodos. Este paso se añade
una condición que he decidido llevar a la práctica.
Volver a mi viejo favorito-la Forma nodo. Las especificaciones de VRML, verá

que sólo tiene dos propiedades: un aspecto y una geometría. La pregunta que
ahora debemos abordar es: ¿Qué ocurre cuando un nodo de la geometría ya se
ha asignado y que tratan de agregar otro nodo de la geometría? Una serie de
posibilidades: Podríamos reemplazar el nodo actual con el nuevo un silencio,
que podríamos preguntar primero si se desea un reemplazo (y actuar en
consecuencia), o podemos rechazar el cambio y generar un error.
Porque (como ya he dicho al principio de este capítulo) que estamos

manteniendo este ejemplo simple, nos vamos con la última opción y no
permitir cambios en la geometría. Acción que sin duda quedan fuera de nuestro
alcance de este proyecto, ya que no estamos creando un programa capaz de
suprimir nodos o ajustar las propiedades. Cambio de la geometría sin duda cae
en la última categoría. Si decide añadir capacidades de edición en una fecha
posterior, es posible la plena aplicación de la presente edición y reemplazar la
propiedad.
Propiedades de la definición de nodo
Simplemente añadiendo nodos por defecto a la escena y luego no da al usuario

la posibilidad de editar las propiedades, o incluso eliminarlos, no es muy
21
agradable. Tenemos que darles al menos una oportunidad para modificar las
cosas.
Para ello, tenemos la obligación de cuadro de diálogo. Sin embargo, tenemos

54 de estos nodos por defecto para construir antes de finales de este proyecto.
Corte el código para que muchos cuadros de diálogo sería tedioso, por no
hablar de la pesadilla del mantenimiento de todos ellos en el comportamiento
coherente. Nunca entrar en la clase base útil de nuevo.
Creación de base de diálogo
Hacer la vida más fácil para nosotros por la reutilización de código es uno de
los objetivos de la programación orientada a objetos. Podemos construir una
sola clase base y luego cada uno se derivan sobre la base de ese diálogo.
Podemos ir un paso más que esto: La clase base proporcionará toda la
funcionalidad que necesitamos en términos de los botones y pantalla de
gestión básica, por lo que todos tenemos que hacer para cada nodo es facilitar
la etiquetas y campos de texto para reunir la información.
¿Cómo es esto posible? Clases abstractas. Nuestra base de clase,

VrmlBaseDialog, figura en el Listado de 12.7.
Dónde Añadir un nuevo nodo
Después de haber decidido que vamos a añadir un nodo a la escena (utilizando

el método processButton o processNodeMenu), la primera cosa que queremos
hacer es asegurarnos de que un nodo de destino ha sido seleccionado. Esto es
muy simple: todos los que tenemos que hacer es comprobar que la variable
seleccionada del árbol no es nulo. Si es nulo, el pop hasta un cuadro de diálogo
para indicar al usuario que deberá seleccionar un nodo de salida y la primera
transformación, de este modo:
if (screen_data.selected == null)
{
select_warn.show ();
retorno;
}
Así que ahora sabemos que tenemos un nodo padre, y también sabemos qué
tipo de nodo está a punto de ser añadido. Lo único que queda es dibujar en la
pantalla y añadir a la estructura de datos interna, ¿no? Bueno, de tipo.
Leyendo.
22
Comprobación de la coherencia
Hay dos partes a la coherencia en el control de este programa. La primera es

asegurarse de que siempre la interpretación de las cosas de la misma manera
en todo el programa, y el otro es para asegurarse de que la pantalla de datos
coincide con los datos internos, que a su vez coincide con los requisitos
establecidos en la especificación de VRML.
La clase VrmlType
Una de las muchas cosas que constantemente se generan errores de código

diferentes interpretaciones de los argumentos que se pasaron en torno a un
programa. Para asegurarse de que no caigan en esta trampa, he creado una
clase que se utiliza en los casos en VRML tipo de nodo de información es que
se pasa a través de llamadas a los métodos.
La clase consiste VrmlType puramente como una lista de los tipos de nodo de
VRML. Cada nodo se representa como una final entero. Siempre que un tipo de
nodo que se pasa entre los métodos, se usa un número, y esta clase es para
ser utilizado como la interpretación de ese número entero.
Nodo a nodo Coherencia
Antes de solicitar al usuario definir los detalles del pedido nodo, tenemos que
pasar por una prueba más. Esta vez se trata de mantener la correcta sintaxis
de VRML, por lo que necesitamos para determinar el nodo padre a la que
estamos añadiendo el nuevo nodo.
Ya tenemos el nodo padre a nuestra disposición, cortesía de nuestro

VrmlTreeNode clase. Sabemos lo que el niño se de el botón / menú que fue
seleccionado. Sabemos también lo que el padre vaya a ser, por recuperar el
nodo desde el nodo seleccionado en la pantalla. Cada tipo de nodo tiene sus
propias reglas en cuanto a lo que el padre puede ser, pero podemos hacer
algunas generalizaciones. Por ejemplo, podemos añadir un nodo sólo desde el
tipo de geometría nodos (recuadro, cilindro, etc) a un tipo de figura nodo.
Comprobación de la correcta padre es tan simple como comprobar que el padre
es una instancia de la clase correcta tipo.
Digamos que desea añadir una casilla a la escena. Para comprobar que el
padre es una forma de nodo, que se utiliza el siguiente código:
if (! (padre instanceof Forma))

23
{
gen_warn.show ( "Usted necesita una forma para la" +
"padre de la geometría nodos");
retorno;
}
Si la prueba anterior es verdad (es decir, el padre no es una forma), luego

aparecerá el cuadro de diálogo diciendo así, entonces la salida.
Demasiados niños?
Después de haber decidido que estamos añadiendo a los padres el tipo

correcto, necesitamos hacer un cheque a algunos nodos. Este paso se añade
una condición que he decidido llevar a la práctica.
Propiedades de la definición de nodo
Volver a mi viejo favorito-la Forma nodo. Las especificaciones de VRML, verá

que sólo tiene dos propiedades: un aspecto y una geometría. La pregunta que
ahora debemos abordar es: ¿Qué ocurre cuando un nodo de la geometría ya ha
sido asignado y se trata de añadir otro nodo de la geometría? Una serie de
posibilidades: Podríamos reemplazar el nodo actual con el nuevo un silencio,
que podríamos preguntar primero si se desea un reemplazo (y actuar en
consecuencia), o podemos rechazar el cambio, y generar un error.
Porque (como ya he dicho al principio de este capítulo) que estamos

manteniendo este ejemplo simple, nos vamos con la última opción y no
permitir cambios en la geometría. Acción que sin duda quedan fuera de nuestro
alcance de este proyecto, ya que no estamos creando un programa capaz de
suprimir nodos o ajustar las propiedades. Cambio de la geometría sin duda cae
en la última categoría. Si decide añadir capacidades de edición en una fecha
posterior, es posible la plena aplicación de la presente edición y reemplazar la
propiedad.
Simplemente añadiendo nodos por defecto a la escena y luego no da al usuario

la posibilidad de editar las propiedades, o incluso eliminarlos, no es muy
agradable. Tenemos que darles al menos una oportunidad para modificar las
cosas.
Para ello, tenemos la obligación de cuadro de diálogo. Sin embargo, tenemos

54 de estos nodos por defecto para construir antes de finales de este proyecto.
Corte el código para que muchos cuadros de diálogo sería tedioso, por no
hablar de la pesadilla del mantenimiento de todos ellos en el comportamiento
coherente. Nunca entrar en la clase base útil de nuevo.
24
Creación de base de diálogo
Hacer la vida más fácil para nosotros por la reutilización de código es uno de
los objetivos de la programación orientada a objetos. Podemos construir una
sola clase base y luego cada uno se derivan sobre la base de ese diálogo.
Podemos ir un paso más que esto: La clase base proporcionará toda la
funcionalidad que necesitamos en términos de los botones y pantalla de
gestión básica, por lo que todos tenemos que hacer para cada nodo es facilitar
la etiquetas y campos de texto para reunir la información.
¿Cómo es esto posible? Clases abstractas. Nuestra base de clase,

VrmlBaseDialog, figura en el Listado de 12.7.
Listado de 12,7 VrmlBaseDialog-la clase base de todos los diálogos que tratan
de Entrada de usuario de VRML-Información Relacionada
/ /
/ /
/ / El contenedor de diálogo para editar las propiedades de cada nodo
/ / Esto debería subclassed para producir el diálogo
ui.dialogs paquete;

vrml.external.Browser de importación;
clase abstracta VrmlBaseDialog público se extiende de diálogo
navegador navegador protegidas;

VrmlTree screen_data protegidas;
VrmlScene vrml_data protegidas;
Botón bien protegidas;

Botón de cancelar protegidas;
Botón de protección aplicables;
25
protegidas de texto nombre;

Grupo content_panel protegidas;
protegidas VrmlBaseDialog (Frame padre, Cadena de título)

{
super (padre, el título, false);
Button_panel panel = new Panel ();

Top_panel panel = new Panel ();
setLayout (nuevo BorderLayout (15, 10));
/ / Crear los botones de la parte inferior

ok = nuevo botón ( "OK");
Botón de cancelar = new ( "Cancelar");
= Botón de aplicar las nuevas ( "Aplicación");
button_panel.setLayout (nuevo FlowLayout (FlowLayout.CENTER,

10, 10));
button_panel.add (bien);
button_panel.add (cancelar);
button_panel.add (aplicar);
añadir ( "Sur", button_panel);
/ / Crear ahora la mitad superior del cuadro de diálogo.

top_panel.setLayout (nuevo BorderLayout (15, 10));
top_panel.add ( "Oeste", nueva etiqueta ( "Nombre"));
name = nuevo texto (null, 20);

top_panel.add ( "Oriente", nombre);
agregar ( "Norte", top_panel);
content_panel = new Grupo ();

agregar ( "Centro", content_panel);
/ / Este método debe aplicarse antes de la clase derivada.

resumen público applyInformation boolean ();
public void setBrowser (navegador b)

{
navegador = b;
26
/ / Manejador para el evento de los botones.

{
if (e.target == ok)
}
ocultar ();
return (applyInformation ());
}
else if (e.target == cancelar)
{
ocultar ();
return true;
}
else if (e.target == apliquen)
return (applyInformation ());
algo más
return false;
}
}
PRECAUCIÓN: Hay una serie de lugares en el listado 12.7 y 12.8 que se refieren a la
aprobación de alrededor de los casos el navegador de VRML. Esta es una kludge para evitar una
serie de problemas con los principios de los navegadores de VRML no aplicación de la
especificación correcta de EAI. En el momento de la escritura, la EAI es algo todavía en un estado
de flujo. Es probable que el código incluido en el CD-ROM puede ser diferente (y más precisa)
que lo que se muestra aquí, y el código en mi sitio web será diferente de nuevo. Para la última
versión que funciona con los navegadores de VRML más reciente, consulte
http://www.vlc.com.au/VermelGen/.
A partir de este código, se puede observar una serie de puntos. En primer

lugar, toda la base de diálogo se aplica el diseño de pantalla, botones, todo. En
segundo lugar, la clase es una clase abstracta con un método abstracto sólo en
ella. Por último, hay un campo de texto en la parte superior con la etiqueta
"Nombre" asociados a ella-lo que es eso?
Comenzando con el último punto en primer lugar: Cada nodo que puede
colocar en la escena puede tener un nombre asociado a él por la palabra clave
DEF, como se explicó en el Capítulo 1. Este campo de texto es común en todos
los nodos y, por tanto, pertenece a la base de la aplicación.
Los botones están todos declarados y gestionados de la clase base, pero las
necesidades de la funcionalidad que se incluirá en las clases derivadas. ¿Cómo
podemos solucionar este problema? En Java, podemos crear un método
27
abstracto y luego llamar a ese método. Esto nos da lo mejor de ambos mundos:
El compilador sabe que existe el método en tiempo de compilación, y usted
tiene la función personalizada en cada clase derivada que se llama
correctamente.
Personalización de la interfaz de usuario
Adición de una interfaz de usuario personalizada es muy simple. Tenemos las

propiedades básicas ya creados, y todos los que tenemos que hacer es rellenar
los espacios en blanco. El blanco se presenta en la forma de la content_panel,
que es una variable.
Para crear nuestro cuadro de diálogo personalizado, que acabamos de asignar

un gestor de diseño y agregar los componentes de la interfaz de usuario según
sea necesario. Echemos un vistazo en el código de uno de los cuadros de
diálogo más simple-la Esfera, que figura en el Listado de 12.8. Puede ver el
cuadro de diálogo que aparece en la Figura 12.2.
Figura 12.2 La Esfera cuadro de diálogo resultante del código de los anuncios
en 12.7 y 12.8
Listado de 12.8 El cuadro de diálogo de Esfera
/ /
/ /
/ / El Grupo de diálogo nodo. Sólo tiene que obtener el tamaño de caja
/ / Y centro, así como un nombre DEF.
ui.dialogs paquete;

ui.dialogs.VrmlBaseDialog de importación;
geometry.Sphere de importación;
VrmlTypes de importación;
28
exceptions.NoSelectedNodeException de importación;
clase pública SphereDialog extiende VrmlBaseDialog

{
radio privada de texto;
público SphereDialog (Frame padre,

VrmlTree árbol,
VrmlScene datos)
}
super (padre, "Editar Esfera Nodo");
vrml_data = datos;
screen_data = árbol;
content_panel.setLayout (nuevo BorderLayout (15, 10));
content_panel.add ( "Oeste", nueva etiqueta ( "Radio"));
= radio de nuevo texto ( "1", 4);

content_panel.add ( "Oriente", radio);
pack ();
}
/ / Leer toda la información de vuelta del grupo y pasarlo

/ / Al lugar apropiado.
boolean applyInformation público ()
{
Cadena str;
flotador rad;
Esfera esfera;
rad = Float.valueOf (radius.getText ()). floatValue ();
/ / Somos la creación de un nodo predeterminado? Esta prueba para un sí

if (rad! = 2)
esfera = new Esfera (navegador, rad);
algo más
esfera = new Esfera (navegador);
str = name.getText ();
if (str.equals (""))
sphere.name = null;
29
intentar
{
vrml_data.addNode (VrmlTypes.Sphere, esfera);
}
de capturas (NoSelectedNodeException e)
{
System.out.println ( "No nodo seleccionado");
}
return false;
}
}
Como se puede ver en la Figura 12.2, con sólo cuatro líneas de código en el
constructor que ahora tenemos un cuadro de diálogo de trabajo. Obviamente,
la otra, más compleja nodos tendrá mucho más líneas de código para crear.
Echa un vistazo en el cuadro de diálogo para la transformación de nodo-
TransformDialog.java-como un complejo ejemplo.
Crear el Nodo
Ahora que estamos llegando al final del proyecto, finalmente llegar a crear ese
nodo. Mirar hacia atrás a la applyInformation método en el Listado 12.8.
Recuerde que este es el método abstracto de la VrmlBaseDialog en el Listado
12.7. Una serie de acciones se llevan a cabo cuando se decide a golpear bien el
botón Aceptar o Aplicar.
En primer lugar, recuperar la información de los diferentes campos del diálogo.

En este caso, sólo tenemos una cosa para obtener el radio de valor. Pasando la
cadena en un número es un enrevesado proceso (que se hace todo en una
línea de código!): En primer lugar obtener la cadena del campo de texto y, a
continuación, utilizar el flotador de clase (la clase java.lang.Float no-
incorporado flotar en el tipo) que a su vez en un número, a continuación, pedir
a la flotación para convertirlo en un flotador. Acostumbrarse a ver a esta línea
de código, porque parece que todo el mundo hay diálogos campos de
interpretar.
Una vez que tengamos los valores de campo, comprobamos que la versión del
nodo que vamos a construir y crear adecuadamente. Después de que el nodo
de base se construye, se rellena el campo del nombre. Si el campo está vacío,
nos ponemos el nombre a null; de lo contrario, asigne una nueva cadena para
30
ello. Hay un error aquí: Si la cadena contiene un blanco, como un espacio o una
ficha y, a continuación, se reproduce este personaje como una cadena, lo que
causa problemas más adelante. Una manera simple de esto es la subclase AWT
de texto y realizar un seguimiento de la clave de entrada, en sustitución de
caracteres como usted va.
NOTA: La razón de las múltiples constructores para cada tipo de nodo se trata en el Capítulo
23, cuando miro en el VRML de datos.
Por último, pedimos la escena gráfica y decirle que agregar el nodo a la

escena. La excepción es la captura en caso de la cadena se ha convertido de
alguna manera seleccionada. No debería haber un caso en que la cadena se ha
convertido de repente en deseleccionado, pero tenemos que tener cuidado de
todos modos.
Ordenar
Qué! Hay más ...? Después de haber ido a todos los problemas de este control
y que esta y la producción de cuadros de diálogo y hacer aportaciones y que
piensas ... Voy a pie y realmente no se molesta en agregar el nodo a la escena?
Para agregar el nodo a la escena, tenemos que añadir a dos lugares de la

pantalla de la estructura de árbol del proyecto y la estructura de datos interna.
Ambas incorporaciones se manejan en el método addNode que has visto se
llama al final de la applyInformation método.
Para cada tipo de nodo, tenemos que emitir el padre (que todavía se conserva
como una VrmlObject) para el tipo correcto y, a continuación, llamar al método
apropiado para ese tipo de niños. Volver a la Forma nodo (de nuevo): Para
agregar un cuadro de ella, escribimos las siguientes líneas de código:
screen_list.addNode (nodo, node_name);

((Forma) de padres). Set_geometry ((Geometría) node);
La primera línea añade el nodo a la pantalla, mientras que el segundo añade la

caja a la forma nodo. Ahora que realmente ha terminado.
La comunicación entre el navegador y Applet
Yo al igual que dar un paso atrás para un segundo y examinar lo que acabamos
de hacer. En las últimas páginas, hemos creado un nodo y, a continuación, se
añade a la escena, sin explicar realmente lo que está ocurriendo internamente.
Para entender lo que está ocurriendo, tenemos que mirar en el código que
31
forma la base de la clase nodo JVerge.
En el corazón de nuestro nodo de la estructura de datos, hay una llamada a

createVrmlFromString (esta es la razón de tener que pasar todo el navegador
de referencia en todo el lugar). La llamada de crear la cadena se convierte en
una representación que el navegador de VRML sabe comprender, pero nunca
realmente añade el nodo de la escena visible.
Para hacer visible el nodo, tenemos que decirle al navegador de VRML para
añadirlo pulg Ahora, piensa en el caso de VRML sistema, la única manera que
usted puede hacer es pasar de un evento a otro nodo que contiene una
referencia a la nodo que desee agregar. El problema es que el applet existe
fuera del entorno del navegador, mientras que el nodo de destino existe dentro
de él.
El método SetValue (que se llama en respuesta a la forma de nodo de la clase

set_geometry método) efectivamente logra la conexión entre los dos mundos.
El _set_geometry variable es como crear una ruta entre el applet y un nodo
dentro del navegador de VRML medio ambiente. Llamando a la SetValue
método es entonces como la generación de un evento diciendo la forma para
cambiar el nodo de la geometría para el nuevo valor.
Escritura del archivo
Como he mencionado antes, podría tener problemas para escribir la

información en un archivo en el disco, así que haremos una alternativa: una
ventana de texto con una simple barra de menús.
La ventana está encapsulado en la clase OutputWindow.java, que se extiende

Marco para convertirlo en una ventana aparte. Esta clase forma parte del
paquete de interfaz de usuario.
Creación de la ventana de salida
Sin entrar en detalles farragosos, la ventana es un marco con una simple barra
de menú (dos puntos: guardar y cerrar) y un texto como el cuerpo de la
ventana.
Listado de 12,9 indica que no hay mucho que puede hacer en el constructor.
Sólo tienes que configurar la barra de menús y, a continuación, el contenido de
32
texto como el lugar el Centro de BorderLayout. Esto asegura que el tamaño de

texto que siempre se llenan la ventana (y es también la razón para usar el
constructor por defecto para el texto).
Listado de la ventana de salida 12.9 Cuando la Fuente de VRML archivos se

muestran

//
//
/ / La ventana de texto que contiene la impresión del código de VRML
/ / Se trata de una simple barra de menús, así como el área de texto no
editables
ui paquete;

importación java.io. *;
ui.dialogs.NotImpDialog de importación;
clase pública se extiende OutputWindow Marco

{
privado NotImpDialog advertir;
textarea text_area privado;
OutputWindow público ()
{
/ / Crear de diálogo de advertencia
advertir = new NotImpDialog (este);
/ / Crear la barra de menú

MenuBar menu_bar = new MenuBar ();
Menú file_menu = new Menú ( "& Archivo", false);
file_menu.add (nuevo MenuItem ( "& Guardar"));

file_menu.addSeparator ();
file_menu.add (nuevo MenuItem ( "Cerrar"));
menu_bar.add (file_menu);
setMenuBar (menu_bar);
/ / Crear el área de texto que se llevará a la salida.

setLayout (nuevo BorderLayout ());
33
text_area textarea = new ();

text_area.setEditable (false);
agregar ( "Centro", text_area);
tamaño (600, 400);

}
/ / Copia a la cadena para el área de texto. Pide la setText

/ / Método por lo que reemplaza completamente el contenido que ya están
/ / Allí.
public void setContents (String contenido)
{
text_area.setText (contenido);
}

{
if (e.target instanceof MenuItem)
{
if ( "Cerrar". iguala (arg))
ocultar ();
else if ( "& Guardar". iguala (arg))
warn.show ();
return true;
}
return false;
}
}
Observe que, para que el texto que se mostrará, debe ir a través de un método
de llamada. La otra opción-dejar el texto como una variable pública y dejar que
llamar a su método setText directamente era demasiado de un riesgo. Código
puede ser escrito por un usuario desinformado que modifica otras propiedades,
que no quería que esto ocurra.
Envío de Información a la ventana
La clase abstracta VrmlObject, que forma la base de todas las clases de VRML,
define un método llamado WriteToFile:
resumen público WriteToFile vacío (PrintStream fp, int guión);
De este código se puede ver que WriteToFile toma un argumento de un

34
PrintStream, pero nuestra clase de ventana quiere editar una cadena. ¿Cómo
solucionar este problema? La solución reside en el paquete java.io. Este
paquete es útil para todo tipo de cosas, y vale la pena saber lo de adentro
hacia fuera.
"En caso de duda, siempre a su vez de una variable en una matriz de bytes y, a
continuación, volver a interpretar los datos" es un buen lema que C / C
programadores han utilizado desde el principio. No hay diferencia aquí. La
solución a un PrintStream convertir en una cadena es el primero en escribir
todo a una matriz de bytes.
Nosotros no podemos usar cualquier tipo de matriz de bytes, aunque todavía

tenemos que usar el Java de E / S de los arroyos en la forma de la
ByteArrayOutputStream.
ByteArrayOutputStream os = new ByteArrayOutputStream ();

PrintStream ps = new PrintStream (os);
file_root.writeToFile (ps);
vrml_output.setContents (os.toString ());
Después de crear el flujo de salida, podemos crear el PrintStream, diciéndole

que utilizar nuestra matriz de bytes. Pedimos WriteToFile el método con el
recién creado printstream para generar la salida y, a continuación, mostrar que
mediante el establecimiento de los contenidos. No, no hay un error en el
método setContents. Que llamamos el método toString de la
ByteArrayOutputStream porque esta es la salida donde se almacenan los
datos, no en el PrintStream. Impresión actuar como un conducto a otros
dispositivos, no como el propio dispositivo (de impresión son una subclase de
FilterOutputStream).
La belleza de la utilización de este enfoque es que podría sustituir un archivo

en lugar de manejar la matriz de bytes y de imprimir al instante la escena
VRML. No tengo necesidad de modificar el VRML clases en todos y sólo hay que
escribir unas cuantas líneas de código adicional a la llamada clase (en este
caso, VrmlScene).
Borrado de nodos
Ahora hemos terminado la base de editor. Es el momento de añadir algunos

extras, tales como la supresión capacidades.
Con la estructura básica ya presentadas en este capítulo, agregando nodo

35
supresión requiere muy poco trabajo. Puede utilizar esto como una directriz
para la aplicación de sus propias extensiones a este código básico.
Para agregar el nodo supresión capacidad, hemos seguido estos pasos, se

muestra en el código:
1. Hemos ampliado el VrmlTreeNode para añadir un campo adicional. Este

entero indica el tipo de nodo representado por el VrmlObject, utilizando los
valores de VrmlTypes. Hemos modificado el constructor y VrmlScene (el único
código que crea instancias de VrmlTreeNode) apropiadamente.
2. Hemos añadido un método privado EditWindow llamado a eliminar Nodo
(). Esto hace lo mismo que el de verificación para asegurarse de agregar un
nodo que se ha seleccionado. A continuación, pide deleteNode () en
VrmlCheck.
3. VrmlCheck.deleteNode () entonces el árbol de consultas para mostrar el
actual nodo seleccionado y de su padre. Si el padre de nodo es nulo, sabemos
que la raíz de la escena gráfica ha sido seleccionado. Estamos notificar al
usuario de este y, a continuación, llamar al eliminar los métodos para la
pantalla de información (VrmlTree) y la estructura interna (VrmlScene).
4. VrmlTree de borrar es muy simple, y pide a la escena, ya sea para
eliminar por completo si el nodo seleccionado fue la raíz, o pasa por la solicitud
de dibujo en el árbol de código. Instalaciones para añadir y eliminar nodos de
la pantalla ya existen, por lo que no se necesita trabajo adicional.
5. VrmlScene es casi tan fácil. Hemos añadido un método deleteNode. Para
realizar la supresión realmente fácil, que van pasando los padres y el niño
VrmlObjects y también un número entero que indique el tipo de cada uno. Esta
información puede obtenerse en el modificado VrmlTreeNode descrito en el
paso 1.
6. Estamos frente a dos de los más comunes los casos en primer lugar: Es
un padre para comprobar que un nodo de agrupación o el niño de ser un nodo
de la geometría. Por estas que llamamos los métodos apropiados para eliminar
el nodo seleccionado. Después de esto, está la difícil sudar tinta de tan sólo un
gran switch para cada uno de los restantes tipos de nodos. Esto probablemente
se desglosa en una serie de métodos como privado más nodos se agregan al
sistema.
Eso es todo lo que hay es demasiado. Me tomó alrededor de una hora y media
para ir a través de todo el código y hacer los cambios para agregar este pulg
Usted puede encontrar el código completo de este proyecto en el CD-ROM y un
ejemplo del resultado final en la Figura 12.3.
36
Figura 12.3 Terminado! El editor de base en la acción.

Uso del Editor
Ahora que tenemos esta gloriosa nuevo editor de VRML 2.0, tenemos que
aprender a conducirlo. Afortunadamente, no hay mucho que aprender.
Después de la espera de editor para empezar, sólo hay una cosa que puedes
hacer: Añadir un nodo a la escena. Si usted va directamente a la barra de
accesos directos y seleccione un nodo, es probable que se muestre el cuadro
de diálogo de advertencia que dice que usted necesita para seleccionar un
nodo en primer lugar. Haga clic en la raíz del mundo (el nodo etiquetado
Unknown.wrl). Ahora trate de añadir un nodo.
Va a encontrar que hay algunos que sólo se pueden añadir de forma-, de

transformación, y el grupo que son. Esto se debe a que sólo se le pueden
añadir nodos de los niños a la raíz del scenegraph. Aunque VRML 2.0 le
permitirá añadir cualquier nodo aquí, no tiene mucho sentido para añadir un
nodo Material que no es bueno.
Después de este comienzo, es sólo un caso de la siguiente sintaxis de VRML

normas. Añadir o eliminar los nodos que lo desee. El error sólo es para ver que,
con anterioridad a la beta 3 de Cosmo Player (la versión incluida en el CD-
ROM), la capacidad de eliminar un nodo desde el navegador no se aplicó. Así
que, a pesar de que se suprime interna y externamente, el navegador sigue
aferrándose a él.
Incluso con esta base de la mayoría de los editores, debería ser capaz de
generar algunos modelos realmente agradable. Cuando esté satisfecho, pulse
el botón Escribir salida, y el código se mostrará. A continuación, puede cortar y
pegar en un editor de texto y trabajar en él a partir de ahí.
¿Qué es la izquierda?
Hay una serie de respuestas inmediatamente obvia de lo que debería añadirse

a este código para hacerlo más completo. Siéntase libre de experimentar por
su cuenta para añadir esta funcionalidad:
• En primer lugar, debemos ampliar el código para incluir a varios de los

37
nodos de VRML. Esto es simplemente un caso de escribir el cuadro de diálogo

apropiado, la eliminación de diálogo de advertencia de la entrada en el
procesamiento EditWindow, añadiendo los controles oportunos en VrmlCheck y,
a continuación, añadir el último código en VrmlScene.
• Cortar y Pegar. Esto es realmente una extensión de añadir y eliminar la
rutina: En lugar de descartar nodos después de la cancelación, sólo podemos
mantener la referencia y añadirlo a otra rama del árbol. Copiar es similar para
todos que tenemos que hacer es llamar a la clon () el método de la parte
superior de la rama que queremos clon antes de añadir que el código.
• DEF / USO de nodos. Por el momento podemos dar nodos DEF un nombre,
pero no podemos hacer otro nodo estos USO.
• Añadir otros VRML construye como RUTA, PROTO, y EXTERNPROTO.

Capítulo 12

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Capítulo 12

Uploaded by

Copyright:

Available Formats

1

VRML 2.0 con Java CAPÍTULO 12

La generación de VRML con

VRML 2.0 con Java CAPÍTULO 12

• Esquema del Proyecto

Esquema del Proyecto

VRML 2.0 con Java CAPÍTULO 12

diseño al tiempo que cubre la mayoría de las partes importantes de la EAI.

El objetivo de este capítulo es para escribir un generador de VRML utilizando

En el CD-ROM: Usted puede encontrar el código de la base de VRML

Esquema del interfaz de usuario

Uno de mis programas favoritos es el software de IDS V-Reino Builder, que

VRML 2.0 con Java CAPÍTULO 12

Voy a desarrollar el sistema, proporcionando un editor de base que puede

Después de desarrollar este sistema, voy a mostrar lo fácil que es extender la

Nuestro proyecto requiere de dos partes: un navegador VRML y añadido de un

No podemos decirle al navegador de VRML para situarse en la página HTML;

12.1 La lista de archivos HTML para el Generador de VRML

<! DOCTYPE HTML PUBLIC "- / / IETF / / DTD HTML / / EN">

VRML 2.0 con Java CAPÍTULO 12

El parámetro de la etiqueta de applet el directorio de fuentes de donde se

VRML 2.0 con Java CAPÍTULO 12

No necesito nada más en el archivo VRML, salvo las habituales de cabecera y un

12.2 La lista de archivos VRML basic.wrl que se ha incrustado en el Listado 12,1

# VRML V2.0 utf8

A pesar de que estamos creando un applet, el funcionamiento es realmente como una

VRML 2.0 con Java CAPÍTULO 12

Recursos del código de Java

VRML 2.0 con Java CAPÍTULO 12

Hay tres paquetes Java de la interfaz de usuario: la interfaz de usuario contiene

VRML 2.0 con Java CAPÍTULO 12

paquetes-ui.dialogs y ui.tree. El paquete contiene todos los cuadros de diálogo

Este proyecto representa la de datos internos de la misma manera que los

La estructura de datos elegida, que se presenta en el capítulo 23, imita los

Estos tipos de datos se han modificado de manera que la estructura de datos

Un pequeño problema que debemos abordar es cómo tratar con la raíz de la

Nota: La estructura de la representación de datos VRML como clases Java es tratado en su

Además de la estructura de datos interna, necesitamos alguna forma de

VRML 2.0 con Java CAPÍTULO 12

relacionar la información a la pantalla de información interna. Porque no quiero

Código para el interior de las estructuras de datos proviene de la biblioteca

Esta es la parte más importante de la aplicación, por lo que pasará bastante

La funcionalidad de la ventana del editor se guarda en el archivo

La barra de menús consta de tres menús. Existe la costumbre menú Archivo

He creado el menú de códigos de barras utilizando el código de Java, que

VRML 2.0 con Java CAPÍTULO 12

General de la ventana de diseño

La ventana principal, que se muestra en la Figura 12.1, tiene la barra de

Figura 12.1 La ventana del editor de

Listado de 12,3 EditWindow Clase Esquema y Constructor

importación java.awt .*;

VRML 2.0 con Java CAPÍTULO 12

clase pública se extiende EditWindow Marco

/ / El constructor - crear la ventana de marco básico

super ( "Generador de VRML");

/ / Limpieza de base para el marco

/ / Crear el panel lateral

/ / Crear el árbol de la lista

/ / Crear la talla única de diálogo de advertencia

Para realizar las distintas subpartes se sientan en la correcta puntos, he usado

VRML 2.0 con Java CAPÍTULO 12

directos a la derecha, he añadido como componente de la zona oriental. Luego

Después de la limpieza general, viene el código para generar las distintas