Uso básico de elementos Swing con NetBeans – 16 – Uso básico de JFormattedTextField, campos para fechas y horas.

El elemento JFormattedTextField es de mucha utilidad para especificar formatos para fechas, horas, monedas, formatos personalizados y muchos más. Es en esta guía veremos cómo utilizarla para establecer formatos personalizados para las fechas y horas.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJFormattedTextField). Para el diseño utilizamos cuatro campos tipo JFormattedTextField, dos de los campos nos permitirán ingresar texto, las cuales serán fecha y hora respectivamente, las otras dos solo mostrarán la fecha y hora del sistema, que obtendremos utilizando el objeto Calendar. 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)
Utilizaremos un único método que se ejecutará al lanzar el JFrame, este método implementa todos los códigos que necesitaremos para hacer funcionar nuestro pequeño programa.
Código Java
private void inicio() throws ParseException{
//El método debe incluir ParseException.
fechaEt.setEnabled(true);
//Forma en que se indica el formato del JFormattedTextField. Para fecha.
fechaEt.setFormatterFactory(new DefaultFormatterFactory(new MaskFormatter("##/##/####")));
horaEn.setEnabled(true);
//Forma en que se indica el formato del JFormattedTextField. Para hora.
horaEn.setFormatterFactory(new DefaultFormatterFactory(new MaskFormatter("##:##:##")));

//Los campos de salida estarán deshabilitados
fechaSd.setEnabled(false);
hora.setEnabled(false);
fechaSd.setFormatterFactory(new DefaultFormatterFactory(new MaskFormatter("##/##/####")));

//Forma de recuperar la fecha del sistema y darle un formato.
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
Calendar cal = Calendar.getInstance();
String fch = sdf.format(cal.getTime());
fechaSd.setText(fch);

//Forma de recuperar la hora del sistema y darle un formato.
hora.setFormatterFactory(new DefaultFormatterFactory(new MaskFormatter("##:##:##")));
SimpleDateFormat sdff = new SimpleDateFormat("HH:mm:ss");
String hr = sdff.format(cal.getTime());
hora.setText(hr);
}
En la imagen siguiente vemos las importaciones que necesitamos, nuestro paquete si la utilizamos y el método que llámanos desde el constructor. También se muestran en la imagen puntos a tener en cuenta ya que es necesario para que funcione la aplicación.

Lista de Importaciones.

Código Java
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.logging.Level;//Importaciones necesarias
import java.util.logging.Logger;
import javax.swing.text.DefaultFormatterFactory;
import javax.swing.text.MaskFormatter;
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)

Uso básico de elementos Swing con NetBeans – 15 – Uso básico de JFileChooser, diálogo de apertura con filtro de imagen simple y carga de imagen.

Tercer ejemplo del uso que se le puede dar a un JFileChooser, esta vez el filtro que utilizaremos es simple y eficientes, no requiere de implementación alguna. También incluimos la posibilidad de abrir la imagen que se haya seleccionado.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJFileChooser3). 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á el método que crea el JFileChooser dependiendo de cuál de los JRadioButton esta seleccionado, debajo del botón y el panel de JRadioButton tenemos otro panel que almacena un JLabel, la cual podrá mostrar texto o imagen dependiendo del caso. 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)
Abajo los métodos que estaremos utilizado. Cada uno tiene una función específica, se agregan comentarios para facilitar la comprensión. El método “inicio()” se llama desde el constructor del JFrame.
Código Java
    private void inicio(){
//Grupo de botones para que se seleccione un solo JRadioButton a la vez.
ButtonGroup br = new ButtonGroup();
br.add(rb1);
br.add(rb2);
br.add(rb3);
}
private void ver(){
//Dependiendo cual este marcada se ejecuta un grupo de codigos.
if(rb1.isSelected()){
//Se crea el JFileChooser
JFileChooser fl = new JFileChooser();
//Indicamos que muestre solo directorios.
fl.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
//Con showOpenDialog se lanza el JFileChooser, si es "Abrir" retorna 1 o -1 "Cancelar".
if(fl.showOpenDialog(null)==JFileChooser.APPROVE_OPTION){
//Obtenemos el nombre del directorio
String fil = fl.getCurrentDirectory().getName();
//Borramos el icono de nuestro JLabel
jlb.setIcon(null);
//Mostramos los datos dentro de JLabel
jlb.setText("Opcion de directorio seleccionado: " + fil);
}
}
else if(rb2.isSelected()){
JFileChooser fl = new JFileChooser();
//Indicamos que muestre tanto directorios como archivos.
fl.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
if(fl.showOpenDialog(null)==JFileChooser.APPROVE_OPTION){
//Optenemos el nombre del directorio
String fil = fl.getCurrentDirectory().getName();
//Obtenemos el nombre del archivo que se haya seleccionado
String file = fl.getSelectedFile().getName();
jlb.setIcon(null);
//Mostramos en el JLabel tanto el nombre del directorio como el nombre del archivo
jlb.setText("Archivo o directorio: [Carpeta: " + fil + "] [Archivo: " + file + "]");
}
}
else if(rb3.isSelected()){
JFileChooser fl = new JFileChooser();
//Indicamos que muestre tanto directorios como archivos.
fl.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
//Creamos un filtro simple de formatos.
fl.setFileFilter(new FileNameExtensionFilter("Archivo de Imagen","jpg","png"));
if(fl.showOpenDialog(null)==JFileChooser.APPROVE_OPTION){
//Obtenemos el archivo seleccionado
File file = fl.getSelectedFile();
jlb.setText(null);
//Mostramos la imagen en nuestro JLabel.
//El método imgIcon() nos localiza el archivo y retorna como imagen.
jlb.setIcon(imgIcon(file));
}
}
}
//Método para retornar la imagen pasándole como parámetro un archivo.
private ImageIcon imgIcon( File fichero ){
ImageIcon imageIcon = new ImageIcon( fichero.getAbsolutePath() );
return imageIcon;
}
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.io.File;
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;//Importaciones necesarias.
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileNameExtensionFilter;
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 individual necesario.
Código Java
    private void verActionPerformed(java.awt.event.ActionEvent evt) {                                    
ver();
}
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)

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)

Uso básico de elementos Swing con NetBeans – 13 – Uso básico de JFileChooser, diálogo de apertura y guardado.

En esta ocasión veremos el manejo básico que se le puede dar a un JFileChooser. Este componente nos permite acceder a una pantalla, la cual según la configuración que le demos, podremos obtener acceso a las opciones de apertura y guardo de contenidos en nuestra pc. Para esta guía podremos configurar un JFileChooser para obtener acceso a las carpetas y archivos de nuestro computador, en caso de apertura podremos obtener el nombre del archivo y decir si optamos por abrirla o cancelar la operación; al igual podremos acceder a la pantalla de guardado y obtener el nombre que le damos al archivo o si cancelamos la operación. Cada resultado iremos almacenando en un JTextArea, la cual servirá como log del programa.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJFileChooser). Para el diseño utilizamos dos botones de comando (el icono para cada botón la obtenemos de nuestra carpeta de imágenes, como vimos en los primeros tutoriales de la serie), cada una lanzará un tipo de dialogo, debajo de los botones 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)
Para este proyecto creamos tres métodos específicos, la primera que arrancará al crearse el formulario, el segundo se encargará de manejar la apertura de archivos y la última para mostrar la pantalla de guardado.
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 open(){
//Método para apertura de archivo.
//Creamos un objeto JFileChooser
JFileChooser jf = new JFileChooser();
//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" );
}
}
private void save(){
//Método para guardar archivo.
JFileChooser jf = new JFileChooser();
//showSaveDialog para ventana de guardado.
int rs = jf.showSaveDialog(this);
//El procedimiento es igual al método de open()
if(rs == JFileChooser.APPROVE_OPTION){
File fl = jf.getSelectedFile();
jt.append("Se ha guardado un archivo con nombre: " + fl.getName() + "\n" );
}
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;//Importaciones necesarias
import javax.swing.JFileChooser;
Para cada botón utilizaremos el evento “ActionPerformed”, en guías anteriores de esta serie vimos como se implementan los eventos. Seguido los eventos.
Código Java
    private void abrirActionPerformed(java.awt.event.ActionEvent evt) {                                      
open();
}

private void guardarActionPerformed(java.awt.event.ActionEvent evt) {
save();
}
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)