Uso básico de elementos Swing con NetBeans – 14 – Uso básico de JFileChooser, diálogo de apertura con filtro de imagen y vista previa.

Segundo ejemplo de la utilización del JFileChooser, en esta ocasión a diferencia de la anterior le agregamos un filtro de imágenes y la posibilidad de obtener una vista previa de la imagen antes de abrirla, esto con solo seleccionarla. El ejemplo utiliza dos clases preestablecidas, que están disponibles en la página oficial de java, las clases son: “Utils” e “ImagePreview”, ambas clases deben estar en el mismo paquete que nuestro JFrame. El ejemplo es sencillo a diferencia de las clases que se implementan.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJFileChooser2). Para el diseño utilizamos un botón de comando (el icono para nuestro botón la obtenemos de nuestra carpeta de imágenes, como vimos en los primeros tutoriales de la serie), el botón lanzará en método que crea el JFileChooser junto con las implementaciones, debajo del botón tenemos nuestro área de texto que almacenará los resultados de cada operación. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Estas clases servirán de soporte para establecer un filtro de imágenes y la posibilidad de tener una vista previa de esas imágenes.

Clase Utils. Tomar en cuenta el paquete en donde se almacena la clase.

Código Java

package com.swing.basic;

import java.io.File;
import javax.swing.ImageIcon;

/**
* Clase disponible en la página de JAVA Oracle.
* Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
*/

class Utils {
public final static String jpeg = "jpeg";
public final static String jpg = "jpg";
public final static String gif = "gif";
public final static String tiff = "tiff";
public final static String tif = "tif";
public final static String png = "png";

/*
* Método para obtener la extensión de cada archivo desde nuestro JFileChooser .
*/

public static String getExtension(File f) {
String ext = null;
String s = f.getName();
int i = s.lastIndexOf('.');

if (i > 0 && i < s.length() - 1) {
ext = s.substring(i+1).toLowerCase();
}
return ext;
}

//Método para obtener una imagen desde una URL.
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = Utils.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}

}

Clase ImagePreview. Tomar en cuenta el paquete en donde se almacena la clase.

Código Java
/**
* Clase disponible en la página de Java Oracle
* Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
*/


import javax.swing.*;
import java.beans.*;
import java.awt.*;
import java.io.File;

//Vista previa de la imagen seleccionada desde nuestro JFileChooser.
public class ImagePreview extends JComponent implements PropertyChangeListener {
ImageIcon thumbnail = null;
File file = null;

public ImagePreview(JFileChooser fc) {
setPreferredSize(new Dimension(100, 50));
fc.addPropertyChangeListener(this);
}

public void loadImage() {
if (file == null) {
thumbnail = null;
return;
}

//Método para obtener la imagen desde la URL
ImageIcon tmpIcon = new ImageIcon(file.getPath());
if (tmpIcon != null) {
//Mostramos la imagen en un tamaño tipo vista previa.
//Si la imagen es grande la disminuimos hasta lograr un thumbnail.
if (tmpIcon.getIconWidth() > 90) {
thumbnail = new ImageIcon(tmpIcon.getImage().
getScaledInstance(90, -1,
Image.SCALE_DEFAULT));
}
//No se ejecuta el proceso si la imagen es pequeña.
else {
thumbnail = tmpIcon;
}
}
}

//Método predeterminado, para manejar los thumbnail.
@Override
public void propertyChange(PropertyChangeEvent e) {
boolean update = false;
String prop = e.getPropertyName();

if (JFileChooser.DIRECTORY_CHANGED_PROPERTY.equals(prop)) {
file = null;
update = true;

} else if (JFileChooser.SELECTED_FILE_CHANGED_PROPERTY.equals(prop)) {
file = (File) e.getNewValue();
update = true;
}

if (update) {
thumbnail = null;
if (isShowing()) {
loadImage();
repaint();
}
}
}

//Método para dibujar los thumbnail.
@Override
protected void paintComponent(Graphics g) {
if (thumbnail == null) {
loadImage();
}
if (thumbnail != null) {
int x = getWidth()/2 - thumbnail.getIconWidth()/2;
int y = getHeight()/2 - thumbnail.getIconHeight()/2;

if (y < 0) {
y = 0;
}

if (x < 5) {
x = 5;
}
thumbnail.paintIcon(this, g, x, y);
}
}
}
Para el proyecto tenemos dos métodos, la primera se ejecuta al crearse el JFrame ya que se llama desde el constructor del mismo. El segundo no lanza nuestro JFileChooser con sus implementaciones.
Código Java
    private void inicio(){
//Método que llamaremos desde el constructor del JFrame.
//Especificamos algunas propiedades de nuestro JTextArea.
//Opción no editable.
jt.setEditable(false);
//Color de fondo.
jt.setBackground(Color.GRAY);
//Color de texto
jt.setForeground(Color.GREEN);
}
private void abrir(){
//Método para apertura de archivo.
//Creamos un objeto JFileChooser
JFileChooser jf = new JFileChooser();
//Creamos un filtro de imágenes utilizando nuestra clase Utils
jf.addChoosableFileFilter(new FileFilter() {
//Los métos siguientes son implementaciones
@Override
public boolean accept(File f) {
if(f.isDirectory()){
return true;
}
String exts = Utils.getExtension(f);
if (exts != null) {
if (exts.equals(Utils.tiff) ||
exts.equals(Utils.tif) ||
exts.equals(Utils.gif) ||
exts.equals(Utils.jpeg) ||
exts.equals(Utils.jpg) ||
exts.equals(Utils.png)) {
return true;
}
else {
return false;
}
}

return false;

}

@Override
public String getDescription() {
return "Imágenes";
}
});
//Establecemos un accesorio que será nuestra vista previa.
jf.setAccessory(new ImagePreview(jf));
//showOpenDialog para JFileChooser de apertura.
//Guardamos el valor en un entero, pues es lo que retorna.
int rs = jf.showOpenDialog(this);
//Comprabamos el retorno como vemos más abajo.
if(rs == JFileChooser.APPROVE_OPTION){
//Creamos una variable tipo File para obtener el archivo seleccionado.
File fl = jf.getSelectedFile();
//Agregamos una línea de texto a nuestro JTextArea para indicar la acción realizada.
jt.append("Se ha abierto el archivo con nombre: " + fl.getName() + "\n" );
}
//Si retorna diferente a APPROVE_OPTION.
else{
jt.append("Operación cancelada..." + "\n" );
}
}
En la imagen siguiente vemos las importaciones que necesitamos, nuestro paquete si la utilizamos y el método que llámanos desde el constructor.

Lista de Importaciones.

Código Java
import java.awt.Color;
import java.io.File;
import javax.swing.JFileChooser;//Importaciones necesarias
import javax.swing.filechooser.FileFilter;
Para los botones como siempre se utiliza el evento “ActionPerformed”, en guías anteriores de esta serie vimos como se implementan los eventos. Seguido el evento para nuestro botón Abrir.
Código Java
    private void abrirActionPerformed(java.awt.event.ActionEvent evt) {                                      
abrir();
}
Llegado a esta parte podremos ejecutar nuestro formulario. (Por si hay alguna duda en el proceso, debemos hacer clic derecho sobre nuestro archivo fuente y presionar “ejecutar archivo” ya que nuestro proyecto no tiene una clase principal definida)

No hay comentarios :

Publicar un comentario en la entrada