Uso básico de elementos Swing con NetBeans – 03 – Uso básico de JRadioButton con eventos.

En esta guía veremos cómo se agrupa y utiliza un JRadioButton, como se ver en el diseño más abajo serán cinco los JRadioButton que agruparemos utilizando ButtonGroup, esto permitirá que el usuario solo pueda seleccionar un elemento cada vez. La aplicación es sencilla, cuando el usuario seleccione uno de los JRadioButton se cargará en el JLabel la imagen que representa. El grupo de cinco imágenes es a griterío de cada uno.
Como indicamos en las guías anteriores, para facilitar el diseño debemos de crear paquetes, una para nuestros formularios y otra para las imágenes que se usan habitualmente, en cuestión de imágenes para botones es recomendable “png” con una dimensión 32x32 para los demás usos es a criterio de cada uno. En la imagen del diseño que se expone más abajo se especifican los puntos importantes.
Diseñamos un formulario utilizando un JFrame, este formulario tendrá como vemos en la imagen cinco JRadioButton, un JPanel para agregar nuestro JLabel con imagen y otro JLabel para el título. 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)
Creamos los métodos siguiente en modo fuente, los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre general. Se agregan comentario para aclarar la función de cada línea de código.
Código Java
//Método que arranca con el constructor del JFrame
private void inicio(){
//Utilizamos ButtonGroup para agrupar los jRadioButton.
//Agrupar es ideal para permitir que se seleccione solo un elemento a la vez.
ButtonGroup group = new ButtonGroup();
group.add(jRadioButton1);
group.add(jRadioButton2);
group.add(jRadioButton3);
group.add(jRadioButton4);
group.add(jRadioButton5);
//Al arrancar indicamos el este seleccionado el primer jRadioButton.
jRadioButton1.setSelected(true);
//Cargamos la imagen indicada al JLabel.
//La URL debe indicar el paquete en el que está la imagen.
//El paquete sería en este caso com.swing.basic.img
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/computer.png"));
}
//Método que nos permitira cargar una imagen como icono pasandole una url
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = UsoJRadioButton.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Archivo no encontrado: " + path);
return null;
}
}
Antes de continuar veremos que método se llama desde el constructor y que importaciones son las necesarias. La imagen y más abajo las importaciones necesarias.
Código Java
//Importaciones necesarias.
import javax.swing.ButtonGroup;
import javax.swing.ImageIcon;
El siguiente paso es establecer los eventos, cada JRadioButton deberá implementar uno para que tenga funcionalidad. El evento que normalmente se utiliza para este tipo de elementos es el ActionPerformed. En la imagen más abajo se ve como es la implementación y seguido el código para los eventos.
Código Java
    private void jRadioButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                              
//Para que se ejecute el código el jRadioButton deberá estar seleccionado.
if(jRadioButton1.isSelected()){
//Utilamos nuestro método creado para cargar la imagen.
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/computer.png"));
}
}

private void jRadioButton2ActionPerformed(java.awt.event.ActionEvent evt) {
if(jRadioButton2.isSelected()){
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/key.png"));
}
}

private void jRadioButton3ActionPerformed(java.awt.event.ActionEvent evt) {
if(jRadioButton3.isSelected()){
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/userr.png"));
}
}

private void jRadioButton4ActionPerformed(java.awt.event.ActionEvent evt) {
if(jRadioButton4.isSelected()){
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/client2.png"));
}
}

private void jRadioButton5ActionPerformed(java.awt.event.ActionEvent evt) {
if(jRadioButton5.isSelected()){
imgLabel.setIcon(createImageIcon("/com/swing/basic/img/note.png"));
}
}
Al entrar en modo fuente todo deberá quedar de esta forma, la mayor parte son códigos generados automáticamente al crear el JFrame y al agregar los objetos. Lo importante es donde ubicamos cada línea de código que creamos más arriba.
En este punto ya podremos ejecutar nuestro formulario y comprobar su funcionalidad.

Uso básico de elementos Swing con NetBeans – 02 – Uso básico de JButton, JCheckBox y JList con eventos.

En la guía anterior vimos algunos usos básico del JButton, en este caso solo la utilizaremos con el evento ActionPerformed para ejecutar códigos sobre JCheckBox y JList. Los JCheckBox son útiles para seleccionar varios elementos de una lista de opciones y los JList pueden almacenar lista de elementos al igual que recuperarlas de forma sencilla. Para esta guía veremos una lista de opciones con JCheckBox, al seleccionar alguno, la etiqueta del mismo se cargará en la lista que tenemos a la derecha. Esto nos dará una idea de la forma de recuperar datos de una JCheckBox y saber cuándo esta seleccionado o no utilizando eventos. También podremos ver como se agregan datos a un JList y como vaciar de elementos utilizando los llamados DefaultModel.
Para facilitar el diseño debemos de crear paquetes, una para nuestros formularios y otra para las imágenes que se usan habitualmente, en cuestión de imágenes para botones es recomendable “png” con una dimensión 32x32 para los demás usos es a criterio de cada uno. En la imagen del diseño que se expone más abajo se especifican los puntos importantes.
Diseñamos un formulario utilizando un JFrame, este formulario contendrá varios JCheckBox, JButton, un JList y una imagen que se carga utilizando una etiqueta. 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)
Antes de continuar debemos de crear una variable de clase tipo DefaultListModel para agregar elementos a la lista y limpiarla. Esta variable de clase puede ir seguida del cierre de llave del constructor del JFrame.
Código Java
DefaultListModel modelo = new DefaultListModel();
Creamos el método “checkBox()” en modo fuente, los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre general. Este método no permitirá deseleccionar los JCheckBox y la enlazaremos con un JButton.
Código Java
private void checkBox(){
jcbUno.setSelected(false);
jcbDos.setSelected(false);
jcbTres.setSelected(false);
jcbCuatro.setSelected(false);
jcbCinco.setSelected(false);
}
El siguiente paso es establecer los eventos, cada botón y JCheckBox deberá implementar uno para que tenga funcionalidad. El evento que normalmente se utiliza para botones y JCheckBox es el ActionPerformed. En la imagen más abajo se ve como es la implementación y seguido el código para los eventos.
Código Java
    private void jcbUnoActionPerformed(java.awt.event.ActionEvent evt) {                                       
if(jcbUno.isSelected()){
jList.setModel(modelo);
modelo.addElement(jcbUno.getText());
}
}

private void jcbDosActionPerformed(java.awt.event.ActionEvent evt) {
if(jcbDos.isSelected()){
jList.setModel(modelo);
modelo.addElement(jcbDos.getText());
}
}

private void jcbTresActionPerformed(java.awt.event.ActionEvent evt) {
if(jcbTres.isSelected()){
jList.setModel(modelo);
modelo.addElement(jcbTres.getText());
}
}

private void jcbCuatroActionPerformed(java.awt.event.ActionEvent evt) {
if(jcbCuatro.isSelected()){
jList.setModel(modelo);
modelo.addElement(jcbCuatro.getText());
}
}

private void jcbCincoActionPerformed(java.awt.event.ActionEvent evt) {
if(jcbCinco.isSelected()){
jList.setModel(modelo);
modelo.addElement(jcbCinco.getText());
}
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
modelo.clear();
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
checkBox();
}
Al entrar en modo fuente todo deberá quedar de esta forma, la mayor parte son códigos generados automáticamente al crear el JFrame y al agregar los objetos. Lo importante es donde ubicamos cada línea de código que creamos más arriba.
En este punto ya podremos ejecutar nuestro formulario y comprobar su funcionalidad.

Uso básico de elementos Swing con NetBeans – 01 – Uso de JButton con eventos.

JButton es uno de los controles Swing más comunes y más utilizados, en este post veremos algunos de los usos básicos: deshabilitar y habilitar botones, establecer un botón por defecto que recibe foco al cargar el formulario y utilizar eventos para ejecutar métodos o líneas de códigos al hacer clic en el botón.
Para facilitar el diseño debemos de crear paquetes, una para nuestros formularios y otra para las imágenes que se usan habitualmente, en cuestión de imágenes es recomendable “png” con una dimensión 32x32. En la imagen del diseño que se expone más abajo se especifican los puntos importantes.
Diseñamos un formulario utilizando un JFrame, este formulario contendrá tres botones como se ve en la imagen más abajo. Es preciso establecer nombre de variable para cada botón, de esa forma las podremos referenciar y modificar sus propiedades. 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)
Tras completar el diseño el diseño agregamos dos líneas de código en el constructor del JFrame, esto pasando del modo de diseño al modo fuente, una sirve para centrar el formulario y la otra es un método que se crea más abajo para establecer propiedades de inicio para los objetos.
Código Java
setLocationRelativeTo(null);//Centrar formulario...
inicio();//Método que se carga al iniciar el formulario...
Creamos el método “inicio()” en modo fuente, los métodos creados por nosotros las ubicamos al final de la declaración de variables, justo antes de la llave de cierre general. Como vimos más arriba este método se referencia desde el constructor del JFrame para poder ejecutarla al lanzar el formulario.
Código Java
//Método único que utilizaremos.
private void inicio(){
//Se utiliza la propiedad Enabled pasándole "true" para habilitar y
//"false" para deshabilitar.
btUno.setEnabled(true);
btDos.setEnabled(true);
btTres.setEnabled(true);
//Se utiliza DefaultButton para establecer botón por defecto, pasándole como argumento el JButton.
getRootPane().setDefaultButton(btDos);
}
El siguiente paso es establecer los eventos, cada botón deberá implementar uno para que tenga funcionalidad. El evento que normalmente se utiliza para botones es el ActionPerformed. En la imagen más abajo se ve como es la implementación y seguido el código para los eventos.
Código Java
//Lista de eventos. Cada botón implementa el ActionPerformed.
private void btUnoActionPerformed(java.awt.event.ActionEvent evt) {
btTres.setEnabled(false);
}

private void btTresActionPerformed(java.awt.event.ActionEvent evt) {
btUno.setEnabled(false);
}

private void btDosActionPerformed(java.awt.event.ActionEvent evt) {
btUno.setEnabled(true);
btTres.setEnabled(true);
}
Al entrar en modo fuente todo deberá quedar de esta forma, la mayor parte son códigos generados automáticamente al crear el JFrame y al agregar los objetos. Lo importante es donde ubicamos cada línea de código que creamos más arriba.
Al llegar a este punto ejecutamos nuestro formulario y verificamos su funcionalidad. Nos es nada especial pero es un inicio para aprender java en modo de diseño.

Java + Swing 025. Modo diseño en NetBeans. Cargar imágenes “jpg” y “png” desde un directorio a un JTable.

Ejercicio: Realizar una pequeña aplicación que permita cargar imágenes tipo "jpg" y "png" desde un directorio a un JTable.
Gran parte del código que se implementa en esta aplicación es tomada y adaptada de otra fuente: referencia principal jc-mouse (http://goo.gl/uKrT2W).
Diseñamos el formulario utilizando un JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En la imagen podemos ver el diseño y los nombres de variables de cada objeto (etiquetas en rojo para los nombres de variable), esto es muy importante ya que cada método utiliza el nombre de variable correspondiente para referenciar al objeto en específico. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. El jTable posee tres columnas sin nombre, esta se agregará desde al “model”. (clic para ampliar imgen)
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para centrar el formulario. El método “tableModel()” que llamamos en el constructor se ejecutará al lanzar el formulario. Debemos de tener en cuenta también el paquete de nuestro jFrame.
Lista de Importaciones necesarias.
Código Java
import java.awt.Component;
import java.io.File;
import java.io.FileFilter;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.filechooser.FileNameExtensionFilter;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.DefaultTableModel;
Lista de Variables de clase.
Código Java
//Variables de clase.
private MyTableModel modelo = new MyTableModel();
private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Imagen","jpg","png");
Creamos los métodos y clases siguientes, cada método y clase posee un nombre que especifica de cierta forma su función. Las clases al igual que los métodos pueden ir dentro del mismo JFrame, es ideal si no se utiliza en otro formulario. En caso de ser necesaria su utilización en otros formularios debe de ir en un archivo independiente y dentro del mismo paquete si es posible. Se agregan comentarios para indicar en lo posible que función cumple cada línea de código.
Código Java

//Método para manejar jTable
private void tableModel(){
String[] nombreColumnas = {"Imagen","Imagen","Imagen"};
Object[][] datosFila = { };
modelo.setDataVector(datosFila, nombreColumnas);
tableImg.setModel(modelo);
tableImg.getColumnModel().getColumn(0).setCellRenderer( new ImageRenderer() );
tableImg.getColumnModel().getColumn(1).setCellRenderer( new ImageRenderer() );
tableImg.getColumnModel().getColumn(2).setCellRenderer( new ImageRenderer() );
tableImg.setRowHeight(256);

//Método para mostrar una vista previa de la imagen seleccionada del jtable.
tableImg.addMouseListener(new java.awt.event.MouseAdapter() {
@Override
public void mouseClicked(java.awt.event.MouseEvent evt) {
int row = tableImg.rowAtPoint(evt.getPoint());
int col = tableImg.columnAtPoint(evt.getPoint());
if ( row >= 0 && col >= 0 )
{
//si celda contiene imagen
if( modelo.getValueAt(row, col) != null )
{
//obtiene la ruta que corresponde a la celda donde se hizo el clic
File fichero = new File( modelo.getValueAt(row, col).toString() );
//se carga la imagen en un jlabel
JLabel picLabel = new JLabel(new ImageIcon( fichero.getAbsolutePath() ));
//se muestra la imagen en el jdialog
JOptionPane.showMessageDialog(null, picLabel, "Vista Previa", JOptionPane.PLAIN_MESSAGE, null);
}
}
}
});
}
//Permite seleccionar el directorio del cual cargaremos las imagenes.
private void selecDir(){
//JFileChooser como selector de archivos.
JFileChooser fileDir = new JFileChooser();
//Filtro que creamos más arriba como variable de clase. Permite mostra solo imagenes jpg y png
fileDir.setFileFilter(filter);
//Comprobamos que se apruebe la selección
if (fileDir.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
//Limpiamos las filas del jtable.
modelo.setRowCount(0);
//ImgFilter es una clase que se crea más abajo para filtrar la imagenes que se cargarán.
//Esto porque el anterior filtro que creamos es para filtrar las que se muestran.
ImgFilter filt = new ImgFilter();
//Cargamos en un array los orchivos de imagen especificando nuestro filtro.
File[] selectedFiles = fileDir.getCurrentDirectory().listFiles(filt);
//Recorremos el array y vamos cargando las imagenes en la tabla.
for (int id = 0; id < selectedFiles.length; id++) {
File selectedFile = selectedFiles[id];
int f = modelo.getRowCount();//cantidad de filas
int c = modelo.getColumnCount();//cantidad de columnas
boolean ok = true;
//recorre todo el TableModel buscando una celda vacia para agregar la imagen
for( int i=0; i<f;i++ )
{
if( ok )
{
for( int j=0; j<c; j++ ){

if( modelo.getValueAt(i, j) == null )
{
this.modelo.setValueAt( selectedFile.getAbsolutePath() , i, j );
tableImg.repaint();
ok=false;
break;
}
}
}
else
{
break;
}
}


if( ok ) //añade nueva fila
{
modelo.setRowCount( modelo.getRowCount() + 1 );
this.modelo.setValueAt( selectedFile.getAbsolutePath() , modelo.getRowCount()-1, 0 );
tableImg.repaint();
}
}
}


}


//Clase que extiende a DefaultTableModel, nos permite trabajar con tablas.
public class MyTableModel extends DefaultTableModel {

@Override
public boolean isCellEditable(int row, int column) {
return false;
}

}

//------------------------------------class ImageRenderer-----------------------------------------------------------------------------------------------------
//Clase que extiende a DefaultTableCellRenderer, nos permitira cargar una imagen a una celda seleccionada.
public class ImageRenderer extends DefaultTableCellRenderer{

private JLabel lb = new JLabel();
//imagen que se muestra cuando la celda esta vacia
private ImageIcon icon = new ImageIcon( getClass().getResource("conta.png") );
//para contener las imagenes que se vayan cargando
private Map iconos = new HashMap() ;

@Override
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,boolean hasFocus, int row, int column){
lb.setText((String) value);
File fichero;
//
if( value !=null )
{
fichero = new File( value.toString() );
//comprueba que fichero exista
if( fichero.exists() )
{
//busca la imagen en el MAP
if( ya_existe( value.toString() ) )
{
//si ya existe, extrae la imagen del MAP
lb.setIcon( getIcono( value.toString() ) );
}
else //No existe
{
//Agrega la imagen al map
iconos.put(value.toString(), bToIcon(fichero) );
//extrae y muestra
lb.setIcon( getIcono( value.toString() ) );
}

}
else //si no existe, muestra imagen por default
{
lb.setIcon(icon);
}
}
else
{
lb.setIcon(icon);
}
return lb;
}
/**
* Comprueba que una imagen ya exista en memoria
* @param String key identificador
*/

private boolean ya_existe( String key ){
Iterator it = iconos.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
if( e.getKey().equals(key) )
return true;
}
return false;
}
/**
* Extrae una imagen del MAP dado su KEY
* @param String key identificador unico
* @return ImageIcon
*/

private ImageIcon getIcono( String key ) {
ImageIcon imageIcon = icon;
Iterator it = iconos.entrySet().iterator();
while (it.hasNext()) {
Map.Entry e = (Map.Entry)it.next();
if( e.getKey().equals(key) )
{
imageIcon = (ImageIcon) e.getValue();
break;
}
}
return imageIcon;
}

/**
* Dado la ruta de un archivo de imagen, carga este en un ImageIcon y retorna
* @param File fichero
*/

private ImageIcon bToIcon( File fichero ){
ImageIcon imageIcon = new ImageIcon( fichero.getAbsolutePath() );
return imageIcon;
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------

//Clase que permite filtrar tipos de arhivos, extiende a FileFilter.
//Esta clase la utilizaremos para filtrar los archivos de una carpeta selecionada.
public class ImgFilter implements FileFilter{
//Se retorna true o false según corresponda o no al filtro indicado.
@Override
public boolean accept(File f)
{
if (f != null && f.getName().toLowerCase().endsWith(".jpg") ||f.getName().toLowerCase().endsWith(".png") )
{
return true;
}
else
{
return false;
}
}

public String getDescription()
{
return "Filtro para imagenes.";
}
}
Utilizamos el evento “ActionPerformed” para llamar nuestro método “selecDir()” desde el botón “cargar” de nuestro diseño. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
Código Java
    private void cargarActionPerformed(java.awt.event.ActionEvent evt) {                                         
//Método para seleccionar una imagen y poder cargar el directorio completo en la que se encuentra.
selecDir();
}
Ejecutamos nuestro formulario y vemos los resultados. El tamaño del jFrame como el de las columnas de la tabla se puede ajustar. (Clic para ampliar la imagen)

Java + Swing 024. Modo diseño en NetBeans. Abrir imagen "jpg" y "png" desde aplicación Java.

Ejercicio: Realizar una pequeña aplicación que permita abrir imágenes tipo "jpg" y "png" en Java.
Diseñamos el formulario utilizando un JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En la imagen podemos ver el diseño y los nombres de variables de cada objeto (etiquetas en rojo para los nombres de variable), esto es muy importante ya que cada método utiliza el nombre de variable correspondiente para referenciar al objeto en específico. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. El jPanel donde esta insertado el campo de texto y el botón posee un borde con título, es opcional, en la imagen se ve como es el proceso para poner el título. El jPanel donde se mostrará la imagen que carguemos se puede establecer un tamaño a criterio de cada uno. (Clic para ampliar la imagen)
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para centrar el formulario. El método “inicio()” que llamamos en el constructor se ejecutará al lanzar el formulario. Debemos de tener en cuenta también el paquete de nuestro jFrame.

Lista de Importaciones
Código Java
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.filechooser.FileNameExtensionFilter;
Declaración de variables de clase.
Código Java
    //Variables de clase
private BufferedImage img;
//FileNameExtensionFilter para especificar tipo de archivos a manejar...
private FileNameExtensionFilter filter = new FileNameExtensionFilter("Archivo de Imagen","jpg","png");
Creamos los métodos siguientes, cada método posee un nombre que especifica de cierta forma su función. Seguido de los método también se agrega una clase (mipanel) que servirá para manejar la imagen y pintarla en al jPanel de nuestro diseño. Se agregan comentarios que tratan de aclarar la función de cada línea de código.
Código Java
    
//Método que retorna un "BufferedImage" pasándole como argumento una "URL"
private BufferedImage cargarImagen(URL url) throws IOException{
//Se vacia la variable de clase tipo "BufferedImage"
img = null;
//Se utiliza contro de excepciones
try {
//Se utiliza ImageIO.read(url) para leer la URL y cargar el "BufferedImage"
img = ImageIO.read(url);
//se retorna el valor.
return img;
} catch (IOException e) {
JOptionPane.showMessageDialog(null, "Error cargando imagen.");
//Si hay algun erro se retorna vacío.
return null;
}

}
//Método para abrir la imagen, se pasa como argumento una jPanel.
//En este caso el argumento será "imgPanel" que es el nombre de nuesto jPanel.
private void abrirImagen(JPanel jp) throws MalformedURLException, IOException{
//Se utiliza JFileChooser para la búsqueda de archivo.
JFileChooser fileChooser = new JFileChooser();
//Especificamos el filtro, utilzando la variable de clase "filter" que creamos.
fileChooser.setFileFilter(filter);
//Utilizamos una condicional para comprobar la apertura del archivo.
int result = fileChooser.showOpenDialog(null);
if(result == JFileChooser.APPROVE_OPTION){
//Limpiamos nuestro jPanel.
imgPanel.removeAll();
//Obtenemos la URL del archivo seleccionado
URL toURL = fileChooser.getSelectedFile().toURI().toURL();
//Agregamos la URL a nuestro campo de texto.
urlText.setText(toURL.getPath());
//Utilizamos nuestro método "cargarImagen(toURL)" pasando el argumento.
BufferedImage cargarImagen = cargarImagen(toURL);
//El jp será el argumento que le pasemos al método.
//"mipanel" es una clase que se crea más abajo.
//El primer argumento un BufferedImage,
//El segundo obtiene al tamaño "Dimension" del jPanel, por tanto la imagen se agusta al mismo.
jp.add(new mipanel(cargarImagen, jp.getSize()));
//La hacemos visible y le hacemos un repaint()
jp.setVisible(true);
jp.repaint();
}
}
//Esta clase se agrega seguido de los métodos de clase, igualmente funciona.
//La clase se crea utilizando de referencia un blog jCmouse.
//Es una clase que extiendo a un JPanel.
public class mipanel extends JPanel{

BufferedImage _image;
//Constructor
public mipanel(){}
//Constructor con dos argumentos.
//El primero será un BufferedImage, el segundo la dimesión.
//Por tanto al crear el jPanel se integra la imagen.
public mipanel( BufferedImage imagen, Dimension d ){
this._image = imagen;
this.setSize(d);
}

//Este método permitirá pintar el jPanel junto con la imagen.
//Es un método heredado del JPanel.
@Override
public void paint(Graphics g){
ImageIcon imagenFondo = new ImageIcon(_image);
g.drawImage(imagenFondo.getImage(),0,0,getWidth(),getHeight(), null);
setOpaque(false);
super.paintComponent(g);
}
}
Utilizamos el evento “ActionPerformed” para llamar nuestro método “abrirImagen(…)” desde el botón buscar. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
Código Java
    private void buscarActionPerformed(java.awt.event.ActionEvent evt) {                                         
//Se utiliza control de excepciones para manejar el método utilizado
try {
//Se pasa como parámetro nuestro jPanel del diseño.
abrirImagen(imgPanel);
} catch (MalformedURLException ex) {
Logger.getLogger(JFrameImage.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(JFrameImage.class.getName()).log(Level.SEVERE, null, ex);
}
}
Ejecutamos nuestro formulario y vemos los resultados. El tamaño del jFrame se puede aumentar, en tanto la imagen que carguemos se ajustará a ella. (Clic para ampliar la imagen)

Java + Swing 023. Modo diseño en NetBeans. Utilizar función autocompletar en JComboBox.

Ejercicio: Realizar una pequeña aplicación que permita utilizar la función de autocompletar en los JComboBox.
Diseñamos el formulario utilizando un JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En la imagen podemos ver el diseño y los nombres de variables de cada objeto (etiquetas en rojo para los nombres de variable), esto es muy importante ya que cada método utiliza el nombre de variable correspondiente para referenciar al objeto en específico. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. En la imagen también se ven las propiedades que debemos tener en cuenta para los tres JComboBox que agregaremos. (clic en la imagen para ampliar)
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para centrar el formulario. El método “inicio()” que llamamos en el constructor se ejecutará al lanzar el formulario. Debemos de tener en cuenta también el paquete de nuestro jFrame.
Antes de crear el único método que utilizaremos, debemos de crear una clase que llamaremos “AutoCompletarComboBox”, el cual manejará la función de autocompletar. Es una clase creada por terceros y compartida para su uso, está bien optimizada y testeada. Esta clase debemos de tenerla en el mismo paquete que nuestro JFrame, caso contrario toca hacer un “import”. En el código hay referencia a la web de origen.
Código Java
package com.java.swing;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import javax.swing.ComboBoxEditor;
import javax.swing.ComboBoxModel;
import javax.swing.JComboBox;
import javax.swing.text.AttributeSet;
import javax.swing.text.BadLocationException;
import javax.swing.text.JTextComponent;
import javax.swing.text.PlainDocument;

/**
*
* @author Ariel
* Referencia web: http://www.orbital-computer.de/JComboBox/
*/

public final class AutoCompletarComboBox extends PlainDocument {
JComboBox comboBox;
ComboBoxModel model;
JTextComponent editor;
boolean selecting=false;
boolean hidePopupOnFocusLoss;
boolean hitBackspace=false;
boolean hitBackspaceOnSelection;

KeyListener editorKeyListener;
FocusListener editorFocusListener;

public AutoCompletarComboBox(final JComboBox comboBox) {
this.comboBox = comboBox;
model = comboBox.getModel();
comboBox.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if (!selecting) highlightCompletedText(0);
}
});
comboBox.addPropertyChangeListener(new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent e) {
if (e.getPropertyName().equals("editor")) configureEditor((ComboBoxEditor) e.getNewValue());
if (e.getPropertyName().equals("model")) model = (ComboBoxModel) e.getNewValue();
}
});
editorKeyListener = new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
if (comboBox.isDisplayable()) comboBox.setPopupVisible(true);
hitBackspace=false;
switch (e.getKeyCode()) {
case KeyEvent.VK_BACK_SPACE : hitBackspace=true;
hitBackspaceOnSelection=editor.getSelectionStart()!=editor.getSelectionEnd();
break;
case KeyEvent.VK_DELETE : e.consume();
comboBox.getToolkit().beep();
break;
}
}
};
hidePopupOnFocusLoss=System.getProperty("java.version").startsWith("1.5");
editorFocusListener = new FocusAdapter() {
@Override
public void focusGained(FocusEvent e) {
highlightCompletedText(0);
}
@Override
public void focusLost(FocusEvent e) {
if (hidePopupOnFocusLoss) comboBox.setPopupVisible(false);
}
};
configureEditor(comboBox.getEditor());
Object selected = comboBox.getSelectedItem();
if (selected!=null) setText(selected.toString());
highlightCompletedText(0);
}

public static void enable(JComboBox comboBox) {
comboBox.setEditable(true);
new AutoCompletarComboBox(comboBox);
}

void configureEditor(ComboBoxEditor newEditor) {
if (editor != null) {
editor.removeKeyListener(editorKeyListener);
editor.removeFocusListener(editorFocusListener);
}

if (newEditor != null) {
editor = (JTextComponent) newEditor.getEditorComponent();
editor.addKeyListener(editorKeyListener);
editor.addFocusListener(editorFocusListener);
editor.setDocument(this);
}
}

@Override
public void remove(int offs, int len) throws BadLocationException {
if (selecting) return;
if (hitBackspace) {
if (offs>0) {
if (hitBackspaceOnSelection) offs--;
} else {
comboBox.getToolkit().beep();
}
highlightCompletedText(offs);
} else {
super.remove(offs, len);
}
}

@Override
public void insertString(int offs, String str, AttributeSet a) throws BadLocationException {
if (selecting) return;
super.insertString(offs, str, a);
Object item = lookupItem(getText(0, getLength()));
if (item != null) {
setSelectedItem(item);
} else {
item = comboBox.getSelectedItem();
offs = offs-str.length();
comboBox.getToolkit().beep();
}
setText(item.toString());
highlightCompletedText(offs+str.length());
}

private void setText(String text) {
try {
super.remove(0, getLength());
super.insertString(0, text, null);
} catch (BadLocationException e) {
throw new RuntimeException(e.toString());
}
}

private void highlightCompletedText(int start) {
editor.setCaretPosition(getLength());
editor.moveCaretPosition(start);
}

private void setSelectedItem(Object item) {
selecting = true;
model.setSelectedItem(item);
selecting = false;
}

private Object lookupItem(String pattern) {
Object selectedItem = model.getSelectedItem();
if (selectedItem != null && startsWithIgnoreCase(selectedItem.toString(), pattern)) {
return selectedItem;
} else {
for (int i=0, n=model.getSize(); i < n; i++) {
Object currentItem = model.getElementAt(i);
if (currentItem != null && startsWithIgnoreCase(currentItem.toString(), pattern)) {
return currentItem;
}
}
}
return null;
}

private boolean startsWithIgnoreCase(String str1, String str2) {
return str1.toUpperCase().startsWith(str2.toUpperCase());
}
}
Creamos el método “inicio()” el cual llamaremos desde el constructor del jFrame. Normalmente los métodos los podemos agregar debajo del constructor del jFrame o al final de la declaración de variables. En este proyecto no utilizaremos eventos.
Código Java
private void inicio(){
//Instanciamos nuestra clase AutoCompletarComboBox pasando como argumento nuestro JComboBox.
AutoCompletarComboBox autoUno = new AutoCompletarComboBox(comboDias);
AutoCompletarComboBox autoDos = new AutoCompletarComboBox(comboMeses);
AutoCompletarComboBox autoTres = new AutoCompletarComboBox(comboNombres);
//La clase es sencilla de implementar, se puede utilizar en cualquier proyecto
}
Ejecutamos nuestro formulario y vemos los resultados.