Diálogo “de detalles” JFace

Desde hace unas semanas, y sólo por curiosidad, decidimos buscar una clase de tipo Dialog del JFace o del SWT que implementara el clásico diálogo que:

• Muestra un icono.
• Muestra un mensaje principal.
• Muestra un botón de “detalles”. Si dicho botón es pulsado, se expande una región, debajo del diálogo, que muestra un texto predefinible por el usuario. Esta región viene a ser un “área de detalles” donde al usuario se le puede especificar un mensaje más explicativo que el mero mensaje principal del diálogo. Si el botón de “detalles” se vuelve a pulsar, este área de detalles es colapsada.

Eclipse muestra este tipo de diálogos en múltiples ocasiones. Así por ejemplo, cuando se está ejecutando una tera de larga duración, se muestra un diálogo como el siguiente:

Cuando se pulsa el botón “Details >>”, el diálogo se expande, mostrando el área de detalles en cuestión:

Por desgracia, tras diversas búsquedas, no pudimos dar con un código fuente que lo implementara. Con el deseo de ayudar a aquellos que, como nosotros, no encontraron este tipo de diálogo implementado, hemos decidido crear una clase propia que lo implemente.

Actualmente esta clase permite definir un área de detalles que está formada sólo por texto no editable. Esto, por supuesto, es una limitación, pero también es cierto que es trivial abstraer esta clase para que, en el área de detalles, se pueda mostrar cualquier tipo de contenido. Por falta de tiempo, sólo hemos implementado la clase que define un diálogo con un área de detalles de tipo textual. Esta clase, además, permite definir el tipo de icono mostrado en el diálogo. La clase, DialogoDetalles, puede ser accedida desde este link. Su aspecto es el que se muestra a continuación:

El código fuente de la clase es el siguiente:

[sourcecode language='java']

import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IconAndMessageDialog;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;

/**
*
* La clase DialogoDetalles representa un diálogo emergente que muestra un
* icono, un mensaje, y un área de detalles donde se puede mostrar texto plano.
*
* Está clase está pensada para mostrar al usuario el clásico diálogo en el que
* puede pulsar un botón de “detalles” para así visualizar un informe detallado
* del mensaje transmitido por el diálogo.
*
* Este diálogo consta de dos botones, uno de “cerrar” y otro de “detalles”. El
* botón de detalles permite hacer visible u ocultar el área de detalles del
* diálogo. El icono visualizado en el diálogo también puede ser especificado
* por el usuario.
*
* @author L.A González Jaime
* @author R.J Palma Durán
*/
public class DialogoDetalles extends IconAndMessageDialog{
/*
* Tipo de icono a usar. Es una de las constantes ERROR,
* WARNING,INFORMATIO,QUESTION.
*/
protected int tipoIcono;
/*
* Detalles del diálogo. Este texto es el mostrado en el área de detalles.
*/
protected String detalles;
/*
* Área de texto donde se muestran los detalles.
*/
protected Text textoDetalles;
/*
* Booleano que indica si el área de texto de los detalles (textoDetalles)
* está creada o no. La visualización y el ocultamiento del área de detalles
* se gestiona creando y destrullendo el textoDetalles. Este flag nos indica
* si, en efecto, el textoDetalles está o no creado.
*/
protected boolean textoDetallesCreado = false;
/**
* Constante que indica que el icono visualizado en el diálogo es de error.
*/
public static final int ERROR = 0;
/**
* Constante que indica que el icono visualizado en el diálogo es de
* advertencia.
*/
public static final int WARNING = 1;
/**
* Constante que indica que el icono visualizado en el diálogo es de
* información.
*/
public static final int INFORMATION = 2;
/**
* Constante que indica que el icono visualizado en el diálogo es de
* pregunta.
*/
public static final int QUESTION = 3;
/*
* Botón que permite mostrar y ocultar los detalles del diálogo.
*/
protected Button botonDetalles;
/*
* Título del diálogo.
*/
protected String titulo;

/**
* Cosntruye un DialogoDetalles. El estilo del diálogo creado (el estilo de
* la shell) es
* SWT.CLOSE | SWT.RESIZE | SWT.MAX | SWT.MODELESS.
*
* @param titulo título del diálogo.
* @param mensaje mensaje principal mostrado en el diálogo.
* @param detalles texto que se muestra en el área de detalles.
* @param tipoIcono tipo de icono a mostrar en el diálogo. Puede ser alguna de las constantes
* DialogoDetalles.ERROR, DialogoDetalles.WARNING, DialogoDetalles.INFORMATION
* , DialogoDetalles.QUESTION.
* @param parentShell la Shell padre de este diálogo. Si es null, se creará una shell de alto nivel.
*/
public DialogoDetalles(String titulo, String mensaje, String detalles, int tipoIcono, Shell parentShell){
this(titulo,mensaje,detalles,tipoIcono,parentShell,SWT.CLOSE | SWT.RESIZE | SWT.MAX | SWT.MODELESS);
}

/**
* Cosntruye un DialogoDetalles. Permite crear el estilo (estilo de la Shell) del
* diálogo creado.
*
* @param titulo título del diálogo.
* @param mensaje mensaje principal mostrado en el diálogo.
* @param detalles texto que se muestra en el área de detalles.
* @param tipoIcono tipo de icono a mostrar en el diálogo. Puede ser alguna de las constantes
* DialogoDetalles.ERROR, DialogoDetalles.WARNING, DialogoDetalles.INFORMATION
* , DialogoDetalles.QUESTION.
* @param parentShell la Shell padre de este diálogo. Si es null, se creará una shell de alto nivel.
* @param estiloShell el estilo de la Shell del diálogo.
*/
public DialogoDetalles(String titulo, String mensaje, String detalles, int tipoIcono, Shell parentShell,
int estiloShell){
super(parentShell);
if(mensaje == null){
throw new IllegalArgumentException(”The input message cannot be null”);
}
this.message = mensaje;
if(tipoIcono < 0 || tipoIcono > 3){
throw new IllegalArgumentException(”Invalid image type”);
}
if(detalles == null){
throw new IllegalArgumentException(”Details cannot be null”);
}
if(titulo == null){
throw new IllegalArgumentException(”Title cannot be null”);
}
this.detalles = detalles;
this.tipoIcono = tipoIcono;
this.titulo = titulo;
this.setBlockOnOpen(false);
this.setShellStyle(estiloShell);
}

/*
* (non-Javadoc)
* @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
*/
protected Control createDialogArea(Composite parent){
return createMessageArea(parent);
}

/*
* (non-Javadoc)
* @see
* org.eclipse.jface.dialogs.Dialog#createButtonsForButtonBar(org.eclipse
* .swt.widgets.Composite)
*/
protected void createButtonsForButtonBar(Composite parent){
createButton(parent, IDialogConstants.CLOSE_ID, IDialogConstants.CLOSE_LABEL, true);
this.botonDetalles = createButton(parent, IDialogConstants.DETAILS_ID, IDialogConstants.SHOW_DETAILS_LABEL,
false);
}

/*
* (non-Javadoc)
* @see org.eclipse.jface.dialogs.Dialog#buttonPressed(int)
*/
protected void buttonPressed(int buttonId){
if(buttonId == IDialogConstants.DETAILS_ID){
/*
* Si se ha pulsado el botón de “detalles”, se debe mostrar u ocultar el área de
* detalles, dependiendo de que estuviera o no oculta. Además, tras ocultar el
* área o visualizarla, se debe redimensionar el diálogo, para que así se ajuste
* al nuevo tamaño provocado por la aparición o desaparición del área de detalles.
*/
Point dimensionAnteriorDialogo = getShell().getSize();
if(this.textoDetallesCreado){
/*
* Si el área de texto está actualmente siendo mostrada, la eliminamos. Además,
* cambiamos la etiqueta del botón de “mostrar detalles”.
*/
this.botonDetalles.setText(IDialogConstants.SHOW_DETAILS_LABEL);
this.textoDetalles.dispose();
}
else{
/*
* Si el área de texto actualmente no está siendo visualizada, la mostramos. Para
* ello, iniciamos a this.textoDetalles. Además, debemos cambiar la etiqueta
* del botón de “mostrar detalles”.
*/
this.botonDetalles.setText(IDialogConstants.HIDE_DETAILS_LABEL);
this.textoDetalles = new Text((Composite)getContents(), SWT.BORDER | SWT.READ_ONLY | SWT.MULTI
| SWT.WRAP | SWT.H_SCROLL | SWT.V_SCROLL);
this.textoDetalles.setText(this.detalles);
GridData data = new GridData(SWT.FILL, SWT.FILL, true, true);
this.textoDetalles.setBackground(Display.getCurrent().getSystemColor(SWT.COLOR_WHITE));
data.horizontalSpan = 2;
this.textoDetalles.setLayoutData(data);
}
getContents().getShell().layout();
this.textoDetallesCreado = !this.textoDetallesCreado;

/*
* Se redimensiona el diálogo.
*/
Point dimensionNuevaDialogo = getShell().computeSize(SWT.DEFAULT, SWT.DEFAULT);
int altoPantalla = Display.getCurrent().getClientArea().height;
getShell().setSize(new Point(dimensionAnteriorDialogo.x, Math.min(dimensionNuevaDialogo.y, altoPantalla)));
}
else{
/*
* Si se pulsa el botón de “cerrar”, cerramos la ventana.
*/
close();
}
setReturnCode(buttonId);
}

/*
* (non-Javadoc)
* @see org.eclipse.jface.dialogs.IconAndMessageDialog#getImage()
*/
protected Image getImage(){
switch(this.tipoIcono){
case ERROR:
return getErrorImage();
case WARNING:
return getWarningImage();
case INFORMATION:
return getInfoImage();
case QUESTION:
return getQuestionImage();
default:
throw new RuntimeException(”Invalid image type”);
}
}

/*
* (non-Javadoc)
* @see
* org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets
* .Shell)
*/
protected void configureShell(Shell shell){
super.configureShell(shell);
// Título del diálogo
shell.setText(this.titulo);
}
}

[/sourcecode]

Mini-Articulo para Linux Magazine

Cool Imaging Project

Sistema de caracterización global y local de imágenes digitales mediante extracción de rasgos basados en contenido

Desarrollo software llevado a cabo por Luis A. González Jaime y Ricardo J. Palma Durán, estudiantes de Ingeniería Informática de la Universidad de Granada.

Motivación

Nuestro objetivo es el de contribuir al desarrollo científico, mediante un proyecto de caracterización de imágenes mediante la extracción de rasgos basados en contenido, donde se puedan realizar estudios globales y locales. El sistema permite, en última instancia, caracterizar tanto global como localmente una imagen digital, mediante rasgos matemáticos de utilidad para la propia caracterización. La idea que nos mueve es la de crear una herramienta de propósito general que aglutine una gran diversidad de técnicas de caracterización basadas en contenido, la cual pueda ser usada por todo tipo de especialistas, independientemente del campo en el que se muevan. Al tratarse de una aplicación de tratamiento de imágenes, ésta debe incluir herramientas clásicas de manipulación de imágenes digitales, independientemente de la caracterización que posteriormente se pudiera hacer de éstas.

La caracterización de imágenes es un campo en continuo avance. El avance científico en este área permite el desarrollo de nuevas técnicas de caracterización. Es por ello que el proyecto se ha desarrollado con la filosofía de ampliabilidad en mente: una estructura fácilmente extensible permitirá la incorporación de nuevas técnicas y algoritmos para los que no se haya dado soporte inicialmente.

Desarrollo y Funcionamiento

Teniendo en cuenta el concepto de ampliabilidad y que la aplicación pueda ser utilizada por cualquier tipo de especialista, el desarrollo del proyecto se ha visto altamente influenciado por la herramienta de desarrollo seleccionada. Se eligió el framework Eclipse Rich Client Platform por dos razones fundamentales. Por un lado, permite aprovechar la potencia del framework Eclipse para nuestra aplicación, especialmente el sistema de Plug-in’s, de manera que una persona con conocimientos de programación pueda implementar nuevas operaciones sin tener que saber el funcionamiento interno de la aplicación. Por otro lado, la estética homogénea que provee, que junto al diseño realizado, trata que la utilización de la aplicación sea intuitiva y homogénea, haciendo que las operaciones se puedan realizar a golpe de click e introduciendo los parámetros requeridos. Una operación en la aplicación se llevaría a cabo de la siguiente manera: se abre una imagen, se dirige uno al menú izquierdo de operaciones, selecciona la operación deseada, introduce los parámetros si la operación los requiere y aplica la operación sobre la imagen haciendo click en aplicar.

Más información: https://forja.rediris.es/projects/cusl3-coolimage/

Comienza la siguiente fase

Tras estos tres primeros meses dándonos tortas contra el Eclipse RCP, JAI y Java2D, hemos llegado a un primer modelo de nuestra aplicación, dando ya por finalizado, salvo detalles menores, la parte relativa al tratamiento digital de imágenes.

Actualmente, Cool Imaging es una aplicación que, dentro de un entorno bastante intuitivo, permite al usuario manipular imágenes mediante clásicos operadores de tratamiento de imágenes.

Además, actualmente, la aplicación está diseñada de tal modo que el añadir nuevas operaciones de tratamiento de imágenes puede hacerse sin excesiva dificultad, y, mejor aún, sin necesidad de modificar los archivos binarios (es decir, puede hacerse de forma “externa”). Basta que el usuario proporcione el archivo binario .class de la clase que implementa dicha operación, y ésta es automáticamente añadida a la aplicación.

El siguiente paso, que será el último y el más duro, es el relacionado con la caracterización de imágenes. Ahora toca diseñar todo aquello relativo a la caracterización de imágenes digitales. Ésta es, supuestamente, la parte más dura, pero partiendo de la base de que la arquitectura actualmente creada es bastante simple y flexible, no debería suponer un gran problema el llevarla a cabo.

En este enlace se encuentra disponible la última versión de la documentación.

Mostramos capturas de pantalla de la aplicación:

JAI-JDK integrado con Eclipse

Tal y como comentamos la solución de usar JAI como una biblioteca linkada no nos parecía una solución aceptable pudiendo hacer que esta forme parte de la máquina virtual. Por ello, decidimos emplear el tiempo necesario para solucionar este problema.
Al final y tras varios días de esfuerzo hemos conseguido utilizar JAI estando instalado en el JDK.

También funciona teniendo JAI instalado en el JRE,  pero debido a que estamos desarrollando la aplicación,  nosotros lo hemos instalado en el JDK.