Como incluir una historia de ficheros usados
domingo, diciembre 16, 2001 at 1:00AM ¿No sabes mucho acerca de como implementar un Historial de archivos?
Resalta tus aplicaciones de procesamiento de archivos agregandoles un mecanismo que
proporcione un historial.
Resumen
Muchas aplicaciones que utilizan archivos tienen un mecanismo de historial que rastrea los últimos archivos procesados. Típicamente estos nombre de archivos se agregan al fondo del menú
File en el orden que los has utilizado. Este artículo proporciona una clase que encapsula todo el código que necesitas para agregar dicho mecanismo a tu propia aplicación.
Descubre la clave "hot spot" para unir el mecanismo mencionado
anteriormente con el frame principal de tu aplicación. El código esta basado en
Swing, proporcionado con el JDK 1.2 o JDK 1.3. ( 2 de Noviembre de 2001)
Autor: Klaus Berg
Traductor: RuGI
URL Original: http://www.javaworld.com/javaworld/javatips/jw-javatip119.html?
Cada programador o está familiarizado con un editor del texto como parte de un IDE o como una herramienta aislada. A menudo debes reeditar el código de fuente que has cerrado recientemente. En lugar de usar el cuadro de dialogo
Open File.., seleccionando primero la opcion Open del Menu
File (proceso que consume tiempo en ocasiones), puedes simplemente hacer click en el menú
File y obtener una lista de tus últimos archivos revisados. Esta lista se enumera y se ordena típicamente colocando en la cima los nombres de los archivos
más recientemente utilizados.
En este artículo, desarrollaremos tres clases para mejorar una aplicación sencilla con un mecanismo que proporcione un historial. La clase
DemoFileHistory es una aplicación de demostración sencilla basada en GUI.
(Observa que esta demostración usa un
JButton que requiere JDK 1.3 o superior para poder compilarlo y ejecutarlo.) La clase
FileHistory encapsula todo el código que necesitas para crear el mecanismo de
historial; mantiene la lista del archivo, guarda y restaura la lista después de que
la aplicación se cierra o vuelve a abrirse, respectivamente. La tercera clase es
IFileHistory una interface de Java que se define dentro de la clase FileHistory.
IFileHistory encapsula los cinco métodos que tu Frame-GUI debe implementar para satisfacer las necesidades del mecanismo.
Desarrollando la Aplicación de Demostración
Empecemos desarrollando una aplicación de demostración sencilla. Esta aplicación extiende un
JFrame de Swing. Tiene un JMenuBar y un JToolBar en la parte
superior, un TextCanvas en el centro, y un JLabel como linea de
estado en la parte inferior. La figura 1
muestra esta aplicación.
Figura 1. La aplicación de demostración sencilla con opciones de menu
File y Options. Haz click sobre la imagen para verla de tamaño completo.
El JMenubar contiene dos opciones: File y Options. El menú
File tiene la opción New que limpia el área principal de la pantalla. La activación de la opción
New del menú File se refreja en la línea de estado. Mejoraremos la opcion
Open del menú File con nuestro mecanismo de historial. Tenemos los iconos correspondientes
a New y Open en nuestro JToolBar. Las acciones del JMenuBar
se conectan a las acciones del JToolBar utilizando los abjetos Action de
Swing. Si revisas el código fuente,
veras que hasta ahora éste se a desarrollado como una clasica aplicación
Swing.
El usuario mantiene la lista del historial de archivos usando el menú Options. Para nuestra demostración, el menú
Options tiene solamente una opción llamada File History, que
se activa para obtener la lista actual del historial. ( Figura 2.) Haciendo click sobre un elemento de la lista (es decir un nombre de archivo) puedes seleccionarlo para abrirlo o borrarlo de la lista con el botón
Delete mostrado en Figura 2. Usando la tecla shift, puede seleccionar continuamente varios elementos de la lista; usando la tecla
CTRL, puedes seleccionar varios elementos que no se encuentren de manera continua en la lista -como se hace
en otras aplicaciones.
Figura 2.Ventana de mantenimiento del Historial. Haz click sobre la imagen para verla de tamaño completo.
Si abres un archivo con el menú Open o el icono Open obtienes un JFileChooser que te pide selecciones un archivo. Después de seleccionar el nombre del archivo,
éste se despliega y se refleja en el centro de la aplicación. La línea de estado refleja la ruta completa del archivo y simula su procesamiento. Si abres tres archivos diferentes y accionas el menú
Open, consigues una lista como la que se muestra en la Figura 3.
Figura 3. La aplicación de demostración con la lista del Historial. Haz click sobre la imagen para verla de tamaño completo.
Cada ruta de cada archivo es abreviada usando un algoritmo especial que muestra la primera y última parte de la ruta de
un archivo. Actualmente, la abreviación se muestra de la manera a la que estan acostumbrados los usuarios de MS Windows, si mueves el puntero del ratón encima de un elemento de la lista, obtienes un
tooltip que te muestra la ruta completa del archivo. El tooltip se alinea para que puedas ver el número del elemento. Nota que
esto es debido a una restricción de Swing que hace que los tooltip sólo
puedan ser tan anchos como el tamaño del JFrame principal de la aplicación.
Hot spot.
Ahora me gustaría hacer mencion un poco sobre el termino "hot spot" utilizado en nuestra aplicación de demostración. El término
hot spot también se usa con los frameworks e indica el punto a partir del cual puedes
extenderlo para utilizarlo y personalizarlo para tus necesidades. En nuestro contexto, estos puntos son los enlaces a los que conectaremos
la aplicación de demostración con la clase
FileHistory.
Primero, tienes que iniciar la clase FileHistory:
fileHistory = new FileHistory(this);
// Iniciamos FileHistory con nuestro frame como unico parametro.
fileHistory.initFileMenuHistory();
// Comienza la inicializacion del historial.
Segundo, debes escribir un pequeño método exit() y lo llamas desde tu metodo
windowClosing() y desde el manejador del JMenuItem de Exit,
utilizando el método actionPerformed():
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e) {
exit();
}
});
JMenuItem exitMenuItem = new
JMenuItem("Exit");
exitMenuItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
exit();
}
});
el método exit() debe parecerse a lo siguiente:
/**
* Cerramos el frame, guardamos las entradas del historial y salidos de la
demostracion.
*/
private void exit() {
setVisible(false);
dispose();
fileHistory.saveHistoryEntries(); //
Guardamos las entradas para la proxima sesión
System.exit(0);
}
La llamada al método fileHistory.saveHistoryEntries() en el metodo exit() es la parte más interesante del codigo anterior. Esa llamada guarda la lista de los nombres de archivos abiertos durante la sesion en un archivo con una configuración especial para que se pueda usar en la proxima sesion.
Tercero, tienes que implementar la interface FileHistory.IFileHistory en tu aplicación. La interface consiste en cinco métodos faciles de implementar:
/**
* Obtiene el nombre de la aplicación para identificar
* el archivo de configuración en
el directorio USER_HOME.
* Este nombre debe ser único en este directorio.
*
* @retorna el nombre de la aplicación.
*/
public String getApplicationName();
/**
* Obtiene un manejador para el menu File del frame
*
* @retorna el menu File del Frame.
*/
public JMenu getFileMenu();
/**
* Retorna el tamaño del Frame principal de la aplicación.
* Se usa para centrar la ventana File History.
*
* @retorna el tamaño del frame principal.
*/
public Dimension getSize();
/**
* retorna el frame principal de la aplicación.
* se usa para centrar la ventana File History
*
* @retorna la instancia del frame principal.
*/
public JFrame getFrame();
/**
* Realiza la actividad que se requiera al cargar el archivo.
(NT: en la aplicacion de demostracion sólo se encarga de
asignar la ruta del archivo a la barra de estado)
* @el parametro pathname es la ruta del archivo seleccionado.
*/
public void loadFile(String pathname);
Ahora debes conectar la seleccion de archivos con el objeto FileHistory en la clase interna
OpenAction:
private final class OpenAction
extends AbstractAction {
OpenAction() {
super("Open...");
}
public void actionPerformed(ActionEvent e) {
JFileChooser fileChooser = new
JFileChooser();
fileChooser.setCurrentDirectory(new
File(System.getProperty("user.dir")));
int result =
fileChooser.showOpenDialog(DemoFileHistory.this);
if (result ==
JFileChooser.APPROVE_OPTION) {
File f =
fileChooser.getSelectedFile();
if (f ==
null) {
return;
}
if
(f.getName().equals("")) {
return;
}
String
path = f.getAbsolutePath();
status.setText("Open
" + path);
fileHistory.insertPathname(path);
//conectar con la clase FileHistory
loadFile(path);
// Es aca en donde debes hacer el procesamiento
// del archivo en la aplicación.
}
}
}
Después de que el usuario escoge un nombre de archivo, proporcionas al objeto
FileHistory la ruta completa del archivo llamando al método fileHistory.insertPathname(path).
Finalmente, tienes que proporcionar una clase interna, por ejemplo HistoryManagementAction, para manejar la opcion
File History del menú Options:
private final class HistoryManagementAction
extends AbstractAction {
HistoryManagementAction() {
super("File
History...");
}
public void actionPerformed(ActionEvent e) {
fileHistory.processList(); //
conectar con la clase FileHistory.
}
}
¡Éso es todo! tu aplicación se ha conectado al mecanismo del historial y está listo para ser usado.
A continuacion, daremos un vistazo a la clase FileHistory. Nota que necesitas el JDK 1.3 para compilar y ejecutar la demostración
DemoFileHistory.java, que te mostrara cómo proporcionar
a una aplicación Swing todas las
funcionalidades mencionadas arriba.
La clase FileHistory.
La clase FileHistory usa el concepto "hot spot" que proporcionas con la interface
IFileHistory y lleva a cabo las acciones necesarias para manejar todas las
funcionalidades del historial de archivos. Puedes ver el código fuente o
descargarlo.
El constructor de FileHistory crea el nombre del archivo usado para escribir y leer la lista
del historial del usuario. Puedes determinar el tamaño de la lista con una propiedad del sistema llamada
itemnames.max. Su valor por defecto es nueve y significa que el usuario puede ver un máximo de nueve elementos en la lista que se muestra en el menu File. Si agregas un décimo elemento, el elemento más antiguo en la lista se elimina.
Usamos el mecanismos de serializacion de Java para escribir las listas en un archivo y leer las listas desde ese mismo archivo durante el inicio de la aplicación. Hacemos esto en los métodos
initFileMenuHistory() y saveHistoryEntries() de la clase FileHistory. Debido a que deben abreviarse los elementos en la lista de menú
File, tenemos que manejar dos Arrays: uno para los nombres de los archivos y otro para las rutas completas. Las rutas completas son necesarias para los
tooltips y para método loadFile().
Para visualizar correctamente los tooltips, extendemos la clase JMenuItem
y sobreescribimos el método getToolTipLocation():
private final class
MenuItemWithFixedTooltip extends JMenuItem {
public MenuItemWithFixedTooltip(String text)
{
super(text);
}
public Point getToolTipLocation(MouseEvent
e) {
Graphics g = getGraphics();
FontMetrics metrics =
g.getFontMetrics(g.getFont());
String prefix =
itemnameHistory.size() <= 9 ? "8: " : "88: ";
int prefixWidth =
metrics.stringWidth(prefix);
int x = JButton.TRAILING +
JButton.LEADING -1 + prefixWidth;
return new Point(x, 0);
}
}
Este código, que alinea nuestro texto del tooltip a la derecha del número del elemento de la lista en el menú
File, es un poco intrincado (Figura 3). Establecemos uno o dos digitos para el número de elementos de la lista, representados por la cadena "8" o "88" segun la condición.
.
El trabajo principal para construir la lista de elementos se hace en el método
insertPathname(). Este procedimiento recursivo inserta el nombre del elemento en el lugar correcto, quita
elementos que sobrepasan el tamaño máximo de lista, y maneja la colocación de la línea de separación. El último método de la clase
FileHistory se relaciona con la opción File History y presenta una lista de nombres de archivos junto con los botones
Delete y Close. Con esta lista, el usuario puede configurar los elementos actuales de la lista que se muestran en el menu
File.
Conclusión.
En este artículo, hemos creado un mecanismo reusable para implementar un historial de archivos,
el cual puedes utilizar en cualquier aplicación GUI-Swing siguiendo solo unos cuantos pasos. La he probado con el
JDK 1.2 y e JDK 1.3 bajo Windows NT y Windows 2000. (El código tambien ha sido probado en el JDK 1.3 sobre
Linux). Esta es una poderosa herramienta y proporciona a tus aplicaciones de procesamiento de archivos un toque profesional.
|
|
|
|
Reader Comments