Siguiente
Prólogo |
Paintable, que se utiliza para serializar ("pintando") los componentes para el cliente, y la interfaz inversa VariableOwner, que es necesaria para des serializar el estado del componente o la interacción del usuario desde el cliente.java.io.Serializable para permitir la serialización. La serialización es necesaria en muchas agrupaciones y soluciones de computación en la nube (cloud computing).ComponentComponent se combina con la clase AbstractComponent, que implementa todos los métodos definidos en la interfaz.ComponentContainer. Este contenedor es el padre de los componentes contenidos.getParent() permite recuperar el componente padre de un componente. Si bien existe un setParent(), que rara vez se necesita cuando por lo general agrega componentes con el método addComponent() de la interfaz ComponentContainer, el cual establece automáticamente al padre.getParent(). Además, no es posible traer una referencia al objeto application con getApplication() antes de tener un padre. Por ejemplo, lo siguiente es inválido:
public class EjemploAcoplar extends CustomComponent {
public EjemploAcoplar() {
// ERROR: No podemos tener acceso al objeto de application aún.
ClassResource r = new ClassResource("smiley.jpg",
getApplication());
Embedded image = new Embedded("Image:", r);
setCompositionRoot(image);
}
}
attach() para el componente. En consecuencia, la eliminación de un componente de un contenedor activa el llamado al método detach(). Si el padre de un componente agregado ya está conectado a la aplicación, attach() es llamado inmediatamente desde setParent().
public class EjemploAcoplar extends CustomComponent {
public EjemploAcoplar() {
}
@Override
public void attach() {
super.attach(); // Debe llamar.
// Ahora sabemos quién es finalmente nuestro dueño.
ClassResource r = new ClassResource("sonriente.jpg",
getApplication());
Embedded imagen = new Embedded("Imagen:", r);
setCompositionRoot(imagen);
}
}
AbstractComponent, tal como se describe en la Sección 5.2.2, "AbstractComponent".AbstractComponentAbstractComponent es la clase base para todos los componentes de interfaz de usuario. Se trata (sólo) de la implementación de la interfaz Component, implementando todos los métodos definidos en la interfaz.AbstractComponent tiene un único método abstracto, getTag(), el cual devuelve el identificador de la serialización de la clase de un componente en particular. Este tiene que ser implementado cuando (y sólo cuando) se creen componentes totalmente nuevos. AbstractComponent administra gran parte de la serialización de los estados de los componentes entre el cliente y el servidor. La creación de nuevos componentes y la serialización se describe en el Capítulo 11, Desarrollar Nuevos Componentes, y la API de serialización del lado del servidor en el Apéndice A, Definicion del Lenguaje de Interfaz de Usuario (UIDL).Field y AbstractField)
Field y de la clase base AbstractField.Property del componente field. Los campos de selección permiten la administración de elementos seleccionables a través de la interfaz Container.FieldField hereda la superinterface Component y también la interfaz Property para tener un valor para el campo. AbstractField es la única clase que implementa directamente la interfaz Field. Las relaciones se ilustran en la Figura 5.4, "Diagrama de Herencia de la Interfaz Field".Field
setValue() y leerlo con el método getValue() definido en la interfaz Property. El tipo de valor actual depende del componente.Field define una serie de atributos, que se pueden recuperar o manipular con el setters y getters correspondiente.descriptionField, el cual es implementado en AbstractField, que no implementa directamente a Field, pero sólo a través de la clase AbstractField.requiredrequiredError (ver más abajo), se muestra un indicador de error y el error del componente se establece en el texto definido con la propiedad error. Sin la validación, el indicador requerido no es más que una guía visual.requiredErrorForm puede mostrar el mensaje de error en un área indicadora de error especial.Field hereda a Property.ValueChangeListener para permitir escuchar los cambios de valor en los campos y Property.Editor para permitir editar los valores.Property.ValueChangeEvent para el campo. No debería implementar el método valueChange() en una clase que herede a AbstractField, ya que se ha implementado en AbstractField. En su lugar, debe implementar el método explícitamente añadiendo la implementación del objeto como un oyente.AbstractFieldAbstractField es la clase base para todos los componentes field. Además de las características de los componentes heredadas de AbstractComponent, esta implementa varias características definidas en las interfaces Property, Buffered, Validatable, y Component.Focusable.
Anterior Capítulo 5. Componentes de Interfaz de Usuario |
Siguiente 5.3. Características Comunes de los Componentes |
Component. En la parte superior de la jerarquía de clases, tenemos la clase AbstractComponent. Que es heredada por otras dos clases abstractas AbstractField, heredada ademas por campos de componentes, y AbstractComponentContainer, heredada de varios contenedores y componentes de diseño. Los componentes que no están vinculados a un contenido de modelo de datos, tales como etiquetas y enlaces, heredan directamente de AbstractComponent.CustomLayout, puede escribir un diseño personalizado como una plantilla XHTML que incluye la ubicación de cualquiera de los componentes contenido. Al mirar el diagrama de herencia, podemos ver que los componentes de diseño heredan las interfaces AbstractComponentContainer y Layout. Los componentes de diseño se describen en detalle en el Capítulo 6, Administrar el Diseño.Window, que contiene una jerarquía de componentes de diseño, que a su vez contienen otros componentes de diseño, componentes de campo, y otros componentes visibles.Anterior 4.8. Configurar el Entorno de la Aplicación |
Siguiente 5.2. Interfaces y Abstracciones |
.war).lib.WEB-INF/lib o como clases en WEB-INF/classesVAADIN/themes/nombretema.VAADIN/widgetset/.web.xmlweb.xml en el directorio WEB-INF de una aplicación web. Se trata de un componente estándar en Java EE que describe cómo una aplicación web debe ser desplegada. La estructura del descriptor de despliegue se ilustra en el siguiente ejemplo. Sólo tiene que desplegar aplicaciones como servlets implementado por el contenedor de la clase especial com.vaadin.terminal.gwt.server.ApplicationServlet. La clase de la aplicación actual se especifica proporcionando el parámetro application con el nombre de la clase específica de la aplicación para el servlet. El servlet es entonces conectado a una URL de una manera estándar para Servlets Java.
<?xml version="1.0" encoding="UTF-8"?>
<web-app
id="WebApp_ID" version="2.4"
xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<servlet>
<servlet-name>miservlet</servlet-name>
<servlet-class>
com.vaadin.terminal.gwt.server.ApplicationServlet
</servlet-class>
<init-param>
<param-name>application</param-name>
<param-value>MiClaseAplicacion</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>miservlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
miservlet. La clase del servlet, com.vaadin.terminal.gwt.server.ApplicationServlet, es proporcionada por el framework Vaadin y debe ser el mismo para todos los proyectos Vaadin. El servlet toma el nombre de la clase Calc de la clase de la aplicación del usuario como parámetro, incluyendo la ruta completa del paquete a la clase. Si la clase está en el paquete por defecto, la ruta del paquete obviamente no es utilizada.url-pattern es definida arriba como /*. Esto coincide con cualquier URL en el contexto del proyecto. Hemos definido anteriormente el contexto del proyecto como miproyecto por lo que la URL de la aplicación será http://localhost:8080/miproyecto/. Si el proyecto fuese a tener varias aplicaciones o servlets, tendrían que tener diferentes nombres para distinguirlos. Por ejemplo, url-pattern /miapp/* coincidiría con una URL como http://localhost:8080/miproyecto/miapp/. Observe que la barra y el asterisco deben ser incluidos al final del patrón./* (por ejemplo /miapp/*), también tendrá que hacer un mapeo de servlet a /VAADIN/* (a menos que lo sirva estáticamente como se indica a continuación). Por ejemplo:
...
<servlet-mapping>
<servlet-name>myservlet</servlet-name>
<url-pattern>/myurl/*</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>myservlet</servlet-name>
<url-pattern>/VAADIN/*</url-pattern>
</servlet-mapping>
/VAADIN/*. No importa a que servlet mapee el patrón, siempre y cuando se trate de un servlet Vaadin./VAADIN/* si sirve tanto en el conjunto de widgets como en los temas estáticos (personalizado y por defecto) en el directorio WebContent/VAADIN/. El mapeo permite simplemente servirlos dinámicamente desde el JAR de Vaadin. Se recomienda servirlos estáticamente para entornos de producción, ya que es mucho más rápido. Si va a servir el contenido dentro de la misma aplicación web, no puede tener el patrón raíz /* para el servlet Vaadin, ya que entonces todas las solicitudes se mapearían al servlet.http://java.sun.com/products/servlet/.web.xml el siguiente parámetro:<context-param> <param-name>productionMode</param-name> <param-value>true</param-value> <description>Vaadin production mode</description> </context-param>
<session-config>
<session-timeout>30</session-timeout>
</session-config>
close() de la clase Application. Debe implementarlo si desea controlar situaciones de tiempo de espera.
Anterior 4.7. Controlar Errores |
Siguiente Capítulo 5. Componentes de Interfase de Usuario |
setComponentError() o se puede activar implícitamente si la validación del componente falla. Como con el componente caption, la ubicación del indicador es manejado por el diseño en el que se encuentre el componente. Por lo general, el indicador de error es ubicado a la derecha del texto del título. Al pasar el puntero del ratón sobre el campo muestra el mensaje de error.
// Crear un campo.
final TextField campoTexto = new TextField("Introduzca el código");
principal.addComponent(campoTexto);
// Deje que el componente de error sea limpio inicialmente .
campoTexto.setComponentError(null); // (realmente el valor predeterminado)
// Tener un botón a la derecha del campo (y alinearlo apropiadamente).
final Button boton = new Button("Aceptar!");
principal.addComponent(boton);
((VerticalLayout)principal.getContent())
.setComponentAlignment(boton, Alignment.BOTTOM_LEFT);
// Controlar los clics del botón
boton.addListener(new Button.ClickListener() {
public void botonClick(ClickEvent event) {
// Si el valor del campo es incorrecto, establecer su error.
// (Permitir sólo caracteres alfanuméricos.)
if (! ((String) campoTexto.getValue()).matches("^\\w*$")) {
// Colocar el componente en estado de error y
// establecer el mensaje de error.
campoTexto.setComponentError(
new UserError("Debe ser letras y números"));
} else {
// De lo contrario, limpiarlo.
campoTexto.setComponentError(null);
}
}
});
Form controla y muestra también los errores de los campos contenidos de modo que se muestra tanto el indicador de error como el mensaje en un área especial del indicador de error. Consulte la Sección 5.19, "Form" y la Sección 5.19.3, "Validar la Entrada del Formulario" para obtener detalles sobre el componente Form y la validación de la entrada del formulario.Window proporciona un método showNotification() para mostrar las notificaciones. El método lleva como parámetros un título y una descripción opcional y el tipo de notificación. El método también acepta un objeto de la notificación del tipo Window.Notification, como se describe más adelante.
ventanaPrincipal.showNotification("Este es el título",
"Esta es la descripción");
<br/>". Puede utilizar cualquier código XHTML en el título y la descripción de una notificación. Si es posible obtener el contenido de la notificación desde la entrada del usuario, debería sanear cuidadosamente el contenido, como se señala en la Sección 12.9.1, "Sanear la Entrada del Usuario para Prevenir Agujeros de Seguridad".
principal.showNotification("Esta es una advertencia",
"<br/>Esta es la <i>última</i> advertencia",
Window.Notification.TYPE_WARNING_MESSAGE);
Window.Notification.TYPE_HUMANIZED_MESSAGE |  |
TYPE_WARNING_MESSAGE |  |
TYPE_ERROR_MESSAGE |  |
TYPE_TRAY_NOTIFICATION |  |
Window.Notification. Puede pasar explícitamente un objeto de notificación creado al método showNotification().
// Crear una notificación con la configuración por defecto para una advertencia.
Window.Notification notif = new Window.Notification(
"Tenga cuidado!!",
"Este mensaje se esconde en la esquina superior izquierda!",
Window.Notification.TYPE_WARNING_MESSAGE);
// Establecer la posición.
notif.setPosition(Window.Notification.POSITION_TOP_LEFT);
// Que se quede allí hasta que el usuario haga clic en él
notif.setDelayMsec(-1);
// Mostrar en la ventana principal.
principal.showNotification(notif);
setPosition() permite establecer la posición de la notificación. El método toma como parámetro cualquiera de las constantes:Window.Notification.POSITION_CENTERED
Window.Notification.POSITION_CENTERED_TOP
Window.Notification.POSITION_CENTERED_BOTTOM
Window.Notification.POSITION_TOP_LEFT
Window.Notification.POSITION_TOP_RIGHT
Window.Notification.POSITION_BOTTOM_LEFT
Window.Notification.POSITION_BOTTOM_RIGHTsetDelayMSec() le permite establecer el tiempo en milisegundos durante cuánto tiempo se muestra la notificación. El valor del parámetro -1 significa que el mensaje se muestra hasta que el usuario haga clic en el cuadro de mensaje. Esto también impide la interacción con otras partes de la ventana de la aplicación, como es el comportamiento predeterminado de los mensajes de error. Sin embargo, esto no, agrega el cuadro de cierre que tiene la notificación de error.SystemMessages.session-timeout en web.xml, como se describe en la Sección 4.8.3, "El Descriptor de Despliegue web.xml".getSystemMessages() en la clase application. El método debe devolver un Application.SystemMessages. La manera más fácil de personalizar los mensajes es utilizar un objeto CustomizedSystemMessages de la siguiente manera:
// Sobreescribe la implementación predeterminada
public static SystemMessages getSystemMessages() {
CustomizedSystemMessages mensajes =
new CustomizedSystemMessages();
mensajes.setSessionExpiredCaption("Ohno, la sesión ha finalizado!");
mensajes.setSessionExpiredMessage("No funciona en reposo!");
mensajes.setSessionExpiredNotificationEnabled(true);
mensajes.setSessionExpiredURL("http://vaadin.com/");
return mensajes;
}
getSystemMessages() no está definido en una interfaz, tampoco existe en la superclase Application.
final Button boton = new Button ("Fállame");
boton.addListener(new Button.ClickListener() {
public void botonClick(ClickEvent event) {
// Lanzar alguna excepción.
throw new RuntimeException("Usted no puede atrapar esto.");
}
});
ApplicationServlet, el componente de más bajo nivel que recibe las peticiones del cliente. El adaptador de terminal pasa todas las excepciones como eventos al oyente de error de la instancia Application a través de la interfaz Terminal.ErrorListener. La clase Application por defecto, no lanza, reenvió de excepciones.Terminal.ErrorListener en la clase Application simplemente imprime el error en la consola. Este también intenta encontrar un componente relacionado con el error. Si la excepción se produjo en un oyente vinculado a un componente, el componente es considerado como el componente relacionado a la excepción. Si es encontrado un componente relacionado, el controlador de errores establece el error del componente para él, puede establecer el mismo atributo con setComponentError().
terminalError() en su clase de aplicación (la que hereda Application) o estableciendo un oyente de error personalizado con el método setErrorHandler. Puede descartar con seguridad el control por defecto o ampliar su uso con su control de error personalizado o sistema de registro. En el siguiente código de ejemplo, las excepciones también son reportadas como notificaciones en la ventana principal.
@Override
public void terminalError(Terminal.ErrorEvent event) {
// Llamar a la implementación por defecto.
super.terminalError(event);
// Algún comportamiento personalizado.
if (getMainWindow() != null) {
getMainWindow().showNotification(
"Se produjo una excepción sin control!",
event.getThrowable().toString(),
Notification.TYPE_ERROR_MESSAGE);
}
}
Anterior 4.6. Apagar una Aplicación |
Siguiente 4.8. Configurar el Entorno de la Aplicación |
close() en la clase Application para cerrar la sesión.
Button botonCerrar = new Button("Salir");
botonCerrar.addListener(new Button.ClickListener() {
@Override
public void buttonClick(ClickEvent event) {
getMainWindow().getApplication().close();
}
});
principal.addComponent(botonCerrar);
Application. Puede configurar la ventana para redirigir a una dirección URL diferente (que no recarga la aplicación) con setLogoutURL. En su clase application, escriba:
setLogoutURL("/salir.html");Window.CloseEvent para la ventana cerrada. Puede controlar el evento con un Window.CloseListener. En caso de que el usuario cierre el navegador, el evento es disparado para cada ventana abierta.
// Cerrar la aplicación si la ventana principal es cerrada.
principal.addListener(new Window.CloseListener(){
@Override
public void windowClose(CloseEvent e) {
System.out.println("Cerrando la aplicación");
getMainWindow().getApplication().close();
}
});
Anterior 4.5. Referenciar Recursos |
Siguiente 4.7. Controlar Errores |
Embedded (imágenes) o Link (archivos descargables). Varios componentes, tales como TabSheet, también pueden incluir iconos, los cuales también son manejados como recursos.Application puede proporcionarnos. Para los recursos dinámicos, la aplicación de usuario debe ser capaz de crearlos dinámicamente. Vaadin proporciona interfaces de petición de recursos para las aplicaciones de modo que puedan devolver los diversos tipos de recursos, tales como archivos o recursos creados dinámicamente. Esto incluye las clases StreamResource y URI y controladores de parámetros descritos en la Sección 12.5.1, "Controlador de URI" y la Sección 12.5.2, "Controlador de Parametros", respectivamente.Resource y una interfaz ApplicationResource más específica para los recursos proporcionados por la aplicación.
ApplicationResource son manejados por la clase Application. Cuando usted crea tal recurso, le da el objeto application al constructor. El constructor registra el recurso en la aplicación usando el método addResource.Application maneja peticiones de los recursos y permite acceder a los recursos utilizando un URI. El URI consiste en el nombre de la base de la aplicación y un nombre relativo del recurso. El nombre relativo es "APP/"+iddelrecurso+"/"+nombredelarchivo, por ejemplo "APP/1/miimagen.png". iddelrecurso es un identificador numérico generado para hacer recursos únicos, y nombredelarchivo es el nombre de fichero del recurso proporcionado en el constructor de su clase. Sin embargo, la aplicación que utiliza un recurso no suele tener en cuenta su URI. Sólo tiene que dar el recurso a un Embedded o Link apropiado o a algún otro componente de interfaz de usuario, que maneje el renderizado del URI.java.io.File. Puede crear el archivo, ya sea con una ruta absoluta o con una relativa, pero la ruta base de la ruta de acceso relativa depende de la instalación del servidor web. Por ejemplo, en Apache Tomcat, el directorio actual por defecto es la ruta de instalación de Tomcat.ClassResource permite que los recursos sean cargados desde el paquete desplegado de la aplicación utilizando el Cargador de Clase de Java. En el ejemplo de una línea más abajo, se carga un recurso de imagen desde el paquete de la aplicación y es mostrado en un componente Embedded.
ventanaPrincipal.addComponent(new Embedded ("",
new ClassResource("sonriente.jpg",
ventanaPrincipal.getApplication())));
ThemeResource son archivos, generalmente imagenes, incluidas en un tema. Un tema es localizado en la ruta camino VAADIN/themes/nombredeltema en una aplicación web. El nombre de un recurso de tema es proporcionado como parámetro para el constructor, con una ruta relativa a la carpeta themes.
// Un recurso de tema en el actual tema ("book-examples")
// Localizado en: VAADIN/themes/book-examples/img/themeimage.png
ThemeResource recurso = new ThemeResource("img/themeimage.png");
// utilizar el recurso
Embedded imagen = new Embedded("Mi Imagen del Tema", recurso);
StreamResource.StreamSource y su método getStream. El método debe devolver un InputStream desde el cual el flujo pueda ser leído.
import java.awt.image.*;
public class MiFuenteImagen
implements StreamResource.StreamSource {
ByteArrayOutputStream bufferImagen = null;
int recargas = 0;
/* Necesitamos implementar este método que devuelve
* el recurso como un flujo. */
public InputStream getStream () {
/* Crear una imagenn y dibujar algo en ella. */
BufferedImage imagen = new BufferedImage (200, 200,
BufferedImage.TYPE_INT_RGB);
Graphics dibujable = imagen.getGraphics();
dibujable.setColor(Color.lightGray);
dibujable.fillRect(0,0,200,200);
dibujable.setColor(Color.yellow);
dibujable.fillOval(25,25,150,150);
dibujable.setColor(Color.blue);
dibujable.drawRect(0,0,199,199);
dibujable.setColor(Color.black);
dibujable.drawString("Recargas = " + recargas, 75, 100);
recargas++;
try {
/* Escriba la imagen en un búfer. */
bufferImagen = new ByteArrayOutputStream();
ImageIO.write(imagen, "png", bufferImagen);
/* Devolver un flujo desde el buffer. */
return new ByteArrayInputStream(
bufferImagen.toByteArray());
} catch (IOException e) {
return null;
}
}
}
ImageIO escribe la imagen para un flujo de salida, mientras, tuvimos que devolver un flujo de entrada, por lo que almacenamos los contenidos de la imagen en un búfer temporal.Link y Embedded, toman sus parámetros como un recurso.Embedded. El constructor StreamResource obtiene una referencia de la aplicación y se registra en los recursos de la aplicación. Supongamos que principal es una referencia a la ventana principal y this es el objeto application.
// Crear una instancia de nuestra fuente de flujo.
StreamResource.StreamSource fuenteImagen = new MiFuenteImagen();
// Crear un recurso que utiliza el origen de flujo y proporcinarle un nombre.
// El constructor registrará automáticamente el recurso en
// la aplicación.
StreamResource recursoImagen =
new StreamResource(fuenteImagen, "miImagen.png", this);
// Crear un componente integrado que recibe su contenido
// del recurso.
principal.addComponent(new Embedded("Titulo de la imagen", recursoImagen));
miImagen.png. La aplicación agrega una llave de recurso al nombre de archivo del recurso para hacerlo único. El URI completo será como http://localhost:8080/bancodepruebas/APP/1/miImagen.png. El APP/1/miImagen.png al final es la parte relativa del URI. Puede obtener la parte relativa de los recursos del URI desde la aplicación con Application.getRelativeLocation().Anterior 4.4. Controlar Eventos con Oyentes |
Siguiente 4.6. Apagar una Aplicación |
Button y un oyente que se encarga de la interacción del usuario (clics) comunicado a la aplicación por eventos. Aquí definimos una clase que escucha los eventos clic.
public class ElBoton implements Button.ClickListener {
Button elBoton;
/** Crear el botón en el contenedor proporcionado. */
public ElBoton(AbstractComponentContainer contenedor) {
elBoton = new Button ("No presione este botón");
elBoton.addListener(this);
contenedor.addComponent(elBoton);
}
/** Controlar los eventos clic del boton para el boton. */
public void buttonClick (Button.ClickEvent event) {
elBoton.setCaption ("No presione este botón de nuevo");
}
}
public class ElBoton implements Button.ClickListener {
Button elBoton;
Button segundoBoton;
/** Crear dos botones en el contenedor proporcionado. */
public ElBoton(AbstractComponentContainer contenedor) {
elBoton = new Button ("No presione este botón");
elBoton.addListener(this);
contenedor.addComponent(elBoton);
segundoBoton = new Button ("Yo soy un botón también");
segundoBoton.addListener(this);
contenedor.addComponent (segundoBoton);
}
/** Controlar los eventos clic del boton para los dos boton. */
public void buttonClick (Button.ClickEvent event) {
if (event.getButton() == elBoton)
elBoton.setCaption("No presione este botón de nuevo");
else if (event.getButton() == segundoBoton)
segundoBoton.setCaption("Yo no soy un número");
}
}
addListener(), el cual toma el método que maneja el evento como un parámetro. El método puede ser pasado ya sea por el nombre del método o como un objeto Method. En el siguiente ejemplo, utilizamos el nombre del método como una cadena (el cual no es comprobado en tiempo de compilación).
public class ElBoton2 implements Button.ClickListener {
Button elBoton;
Button segundoBoton;
/** Crear dos botones en el contenedor proporcionado. */
public ElBoton2(AbstractComponentContainer contenedor) {
elBoton = new Button ("No presione este botón");
elBoton.addListener(Button.ClickEvent.class, this,
"elButtonClick");
contenedor.addComponent(elBoton);
segundoBoton = new Button ("Yo soy un botón también");
segundoBoton.addListener(Button.ClickEvent.class, this,
"segundoButtonClick");
contenedor.addComponent (segundoBoton);
}
public void elButtonClick (Button.ClickEvent event) {
elBoton.setCaption ("No presione este botón de nuevo");
}
public void segundoButtonClick (Button.ClickEvent event) {
segundoBoton.setCaption("Yo no soy un número");
}
}
addListener() es realmente sólo un wrapper que crea un objeto oyente com.vaadin.event.ListenerMethod, que es un adaptador desde una clase oyente a un método. Este implementa la interfaz java.util.EventListener y por lo tanto puede trabajar para cualquier origen de eventos utilizando la interfaz. Tenga en cuenta que no todas las clases oyentes necesariamente heredan la interfaz EventListener.Button.ClickListener e implementa el método buttonClick().
public class ElBoton3 {
Button elBoton;
Button segundoBoton;
/** Crear dos botones en el contenedor proporcionado. */
public ElBoton3(AbstractComponentContainer contenedor) {
elBoton = new Button ("No presione este botón");
/* Define un oyente en una clase anonima. */
elBoton.addListener(new Button.ClickListener() {
/* Controlar el clic. */
public void buttonClick(ClickEvent event) {
elBoton.setCaption (
"No presione este botón de nuevo");
}
});
contenedor.addComponent(elBoton);
segundoBoton = new Button ("Yo soy un botón también");
segundoBoton.addListener(new Button.ClickListener() {
public void buttonClick(ClickEvent event) {
segundoBoton.setCaption ("Yo no soy un número!");
}
});
contenedor.addComponent (segundoBoton);
}
}
fireEvent(Component.Event) de AbstractComponent. El evento entonces es retransmitido a todos los oyentes del evento en particular de la clase para el objeto. Algunos componentes tienen un tipo de evento por defecto, por ejemplo, un Button tiene una clase Button.ClickEvent anidada y una correspondiente interfaz Button.ClickListener. Estos eventos pueden ser desencadenados con fireComponentEvent().
Anterior 4.3. Ventanas Secundarias |
Siguiente 4.5. Referenciar Recursos |
Window y agregarlo a la ventana principal con el método addWindow() de la clase Application.
miVentana = new Window("Mi Ventana");
ventanaPrincipal.addWindow(miVentana);
removeWindow() de la clase Application.miAplicacion.removeWindow (miVentana);
setReadOnly(true). Tenga en cuenta que también puede deshabilitar el botón haciéndolo invisible en CSS con el formato "display: none". El problema con esta deshabilitación estética es que un usuario malintencionado podría volver a habilitar el botón y cerrar la ventana, lo que podría causar problemas y, posiblemente, ser un agujero de seguridad. Configurando la ventana como de sólo lectura no sólo desactiva el botón de cierre del lado del cliente, sino que también impide procesar el evento cerrar del lado del servidor.
/** El componente contiene un botón que permite abrir una ventana. */
public class AbridorVentana extends CustomComponent
implements Window.CloseListener {
Window ventanaPrincipal; // Referencia a la ventana principal
Window miVentana; // La ventana que se abrirá
Button botonAbrir; // El botón para abrir la ventana
Button botonCerrar; // Un botón en la ventana
Label explicacion; // Un texto descriptivo
public AbridorVentana(String label, Window principal) {
ventanaPrincipal = principal;
// El componente contiene un botón que abre la ventana.
final VerticalLayout disenio = new VerticalLayout();
botonAbrir = new Button("Abrir Ventana", this,
"abrirButtonClick");
explicacion = new Label("Explicación");
disenio.addComponent(botonAbrir);
disenio.addComponent(explicacion);
setCompositionRoot(disenio);
}
/** Controlar los clics de los dos botones. */
public void abrirButtonClick(Button.ClickEvent event) {
/* Crear una nueva ventana. */
miVentana = new Window("Mi Cuadro de Diálogo");
miVentana.setPositionX(200);
miVentana.setPositionY(100);
/* Agregar la ventana dentro de la ventana principal. */
ventanaPrincipal.addWindow(miVentana);
/* Escuchar los eventos 'cerrar' para la ventana. */
miVentana.addListener(this);
/* Agregar los componentes en la ventana. */
miVentana.addComponent(
new Label("Una etiqueta de texto en la ventana."));
botonCerrar = new Button("Cerrar", this, "cerrarButtonClick");
miVentana.addComponent(botonCerrar);
/* Permitir abrir sólo una ventana a la vez. */
botonAbrir.setEnabled(false);
explicacion.setValue("Ventana abierta");
}
/** Controlar el clic del botón botonCerrar y cierre de la ventana. */
public void cerrarButtonClick(Button.ClickEvent event) {
/* Las ventanas son manejadas por el objeto application. */
ventanaPrincipal.removeWindow(miVentana);
/* Volver al estado inicial. */
botonAbrir.setEnabled(true);
explicacion.setValue("Cerrado con el botón");
}
/** En caso de que la ventana sea cerrada de otro modo. */
public void windowClose(CloseEvent e) {
/* Volver al estado inicial. */
botonAbrir.setEnabled(true);
explicacion.setValue("Cerrado con controles de la ventana");
}
}
CustomComponent. Este consiste de un Button que se utiliza para abrir una ventana y un Label para describir el estado de la ventana. Cuando la ventana es abierta, el botón es deshabilitado. Cuando la ventana es cerrada, el botón es habilitado de nuevo.
public void init() {
Window principal = new Window("La Ventana Principal");
setMainWindow(principal);
principal.addComponent(new AbridorVentana("Abridor de Ventana", principal));
}
setHeight() y setWidth(). Puede establecer la posición de la ventana con los métodos setPositionX() y setPositionY().
/* Crear una ventana nueva. */
miVentana = new Window("Mi Cuadro de Dialogo");
/* Establecer el tamaño de la ventana. */
miVentana.setHeight("200px");
miVentana.setWidth("400px");
/* Establecer la posición de la ventana. */
miVentana.setPositionX(200);
miVentana.setPositionY(50);
getHeight y getWidth devolverán -1.overflow: auto en CSS.Window extiende a Panel, las ventanas también son Scrollable. Tenga en cuenta que la interfaz define un desplazamiento programático, no un desplazamiento por el usuario. Por favor, consulte la Sección 6.6, "Panel".
Anterior 4.2. Administrar la Ventana Principal |
Siguiente 4.4. Controlar Eventos con Oyentes |
setMainWindow() de la clase Application.
import com.vaadin.ui.*;
public class HolaMundo extends com.vaadin.Application {
public void init() {
Window principal = new Window("La Ventana Principal");
setMainWindow(principal);
... llene la ventana principal con componentes ... }
}
addComponent(), que en realidad añade el componente al componente de diseño raíz vinculado a la ventana. Si desea utilizar otro diseño raíz por defecto, puede establecerlo con setContent(), como se explica en la Sección 6.2, "Diseño Raiz Window y Panel".Anterior Capítulo 4. Escribir una Aplicación Web |
Siguiente 4.3. Ventanas Secundarias |
com.vaadin.Application. La clase application debe implementar el método init().
public class MiApp extends com.vaadin.Application {
public void init() {
... el código de inicialización va aquí ...
}
}
Application proporciona facilidades para acceder a la ventana, el control de ejecución y la selección de temas. La API de application puede parecer similar a la API de Java Servlet, pero sólo es superficial. El framework Vaadin asocia las peticiones con sesiones, de modo que una instancia de la clase application es realmente un objeto de sesión. Debido a esto, puede desarrollar aplicaciones web, como lo haría con el desarrollo de aplicaciones de escritorio.?restartApplication en la URL le indica al servlet Vaadin que cree una nueva instancia de Application cuando se recarge la página.CustomComponent".Anterior 3.5. Eventos y Oyentes |
Siguiente 4.2. Administrar la Ventana Principal |
addListener(). El método tiene una versión genérica definida en el nivel de AbstractComponent, la clase base de todos los componentes.Button tiene eventos Button.ClickEvent, el cual puede ser escuchado a travéz de la interfaz Button.ClickListener.
final Button button = new Button("Presionalo!");
button.addListener(new Button.ClickListener() {
public void buttonClick(ClickEvent event) {
button.setCaption("Lo presionaste!");
}
});
Button.ClickListener capaz de escuchar eventos clic de button. La aplicación debe crear instancias de la clase oyente y registrarla con addListener(). Cuando ocurre un evento, el evento de un objeto es instanciado, en este caso un ClickEvent. El evento del objeto conoce el componente de interfaz de usuario relacionado, en este caso Button.
MethodListener.java.util.EventListener, pero generalmente no es necesario heredarlo.Anterior 3.4. Motor del Lado del Cliente |
Siguiente Capítulo 4. Escribir una Aplicación Web |