Uso básico de elementos Swing con NetBeans – 35 – Uso de JToolBar, barra de herramientas.

Utilización de JToolBar, modo diseño en Netbeans

En este ejemplo sencillo veremos la utilidad de un “JToolBar”, objeto que puede contener botones u otros elementos, tiene ciertas ventajas como la posibilidad de flotar de forma libre o ubicarse fácilmente en cualquiera de los cuatro costados del formulario desplazando automáticamente otros elementos. En este ejemplo nuestra “Barra de Herramientas” contendrá cinco botones, cada una al hacer clic sobre ellas agregará una línea de texto al “Área de texto” indicando la procedencia del clic. En modo diseño podremos ver la distribución de los elementos. El nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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 ejemplo necesitamos una única importación y el método de inicio habitual.

package com.swing.basic;//Paquete

import java.awt.Color;//Importación

/**
 *
 * @author Ariel
 */
public class UsoJToolBar extends javax.swing.JFrame {

    /**
     * Creates new form UsoJToolBar
     */
    public UsoJToolBar() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de arranque
    }

El único método que necesitamos es “inicio()” la cual inicializará ciertas propiedades del área de texto como ya veremos.

    private void inicio(){
        //Pequeños ajuste para el Area de Texto.
        //Los ajustes para la barra de herramientas se hacen en modo diseño.
        jTextA.setEditable(false);
        jTextA.setBackground(Color.lightGray);
        jTextA.setForeground(Color.BLUE);
    }

Para los botones se utiliza el evento “ActionPerformed” que permitirá ejecutar los métodos. En las primeras guías de la serie vimos cómo se hacer para relacionar un evento con un objeto visual.

    private void btn01ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Abrir..." + "\n");
    }                                     

    private void btn02ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Buscar..." + "\n");
    }                                     

    private void btn03ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Consultar..." + "\n");
    }                                     

    private void btn04ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Imprimir..." + "\n");
    }                                     

    private void btn05ActionPerformed(java.awt.event.ActionEvent evt) {                                      
        jTextA.append("Clic botón Ayuda..." + "\n");
    }  

Llegado a este punto podremos ejecutar y probar 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 – 34 – Uso de JTextArea, cambio de fuente y tamaño de fuente.

Trabajando con JTextArea.

Ampliando el ejemplo anterior, veremos cómo obtener la lista de fuentes del sistema y aplicarlas a nuestro Área de Texto, también veremos cómo ajustar el tamaño de fuentes. El resto es totalmente igual al del ejemplo anterior. Para mostrar la lista de fuentes y tamaño de fuente utilizamos combos. Es necesario limpiar los ítems del “model” en modo diseño.

El nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

package com.swing.basic;//Paquete de fuente

import java.awt.Font;//Importación
import java.awt.GraphicsEnvironment;

/**
 *
 * @author Ariel
 */
public class EjJTextArea extends javax.swing.JFrame {

    /**
     * Creates new form EjJTextArea
     */
    public EjJTextArea() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de inicio
    }

Para el ejemplo utilizamos varios métodos que cumplen funciones específicas. El nombre que le damos a cada método nos da una idea de que función cumple. El método “inicio()” por ejemplo arranca desde el constructor del JFrame y nos permite inicializar algunas propiedades del área de texto. Se agregan comentarios para indicar la funciona de cada línea de código.

    private void inicio(){
        //-Establecemos propiedades para el JTextArea-
        //Establecemos tipo de fuente predeterminado, texto itálico, tamaño 15
        jTex.setFont(new Font("Default", Font.PLAIN, 15));
        //Especificamos que el texto se ajusta al tamaño del Área de texto
        jTex.setLineWrap(true);
        jTex.setWrapStyleWord(true);
        //Hacemos que el área de texto no sea editable
        jTex.setEditable(false);
        
        //Configuramos la lista de tipo de fuentes y tamaño
        //Obtenemos la lista de fuentes del sistema utilizando getAvailableFontFamilyNames()
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        String[] fonts = ge.getAvailableFontFamilyNames();
        
        //Agregamos cada nombre de fuente a nuestro combo.
        for (String string : fonts) { 
            fuenteTipo.addItem(string);
        }
        
        //Agregamos los tamaños de fuente, de 1 al 70
        for (int i = 1; i < 71; i++) {
            fuenteTam.addItem(i);
        }
        
        //Inicializamos el tamaño de fuente en 15.
        fuenteTam.setSelectedIndex(14);        
    }
    
    //Método para agregar texto al área de texto.
    private void agregar(){
        //Verificamos que el campo de texto no este vacío
        if(!jT.getText().isEmpty()){
            //Para agregar textos se utiliza append. "\n" indica salto de línea.
            jTex.append(jT.getText() + "\n");
            //Limpiamos el campo JTextField.
            jT.setText(null);
        }
    }
    
    //Método para manejar los cambios de fuente y tamaño
    private void tipoFuente(){
        //Obtenemos tipo y tamaño.
        String toString = fuenteTipo.getSelectedItem().toString();
        int selectedIndex = fuenteTam.getSelectedIndex() + 1;
        jTex.setFont(new Font(toString, Font.PLAIN, selectedIndex));
    }
}

En relación a los eventos, tanto para el botón agregar como en los dos combos utilizaremos el “ActionPerformed” que permitirá ejecutar los métodos. En las primeras guías de la serie vimos cómo se hacer para relacionar un evento con un objeto visual.

    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
        agregar();
    }                                       

    private void fuenteTipoActionPerformed(java.awt.event.ActionEvent evt) {                                           
        tipoFuente();
    }                                          

    private void fuenteTamActionPerformed(java.awt.event.ActionEvent evt) {                                          
        tipoFuente();
    }    

Llegado a este punto podremos ejecutar y probar 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 – 33 – Uso de JTextArea, agregar elementos desde JTextField.

Uso básico del elemento JTextArea

Anteriormente ya vimos la utilizando de un “JTextArea” o Área de Texto, en esta oportunidad daremos un pequeño ejemplo de cómo agregar texto desde un JTextField. El nombre que le demos al formulario es a criterio de cada uno. Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

package com.swing.basic;//Paquete de fuente

import java.awt.Font;//Importación

/**
 *
 * @author Ariel
 */
public class EjJTextArea extends javax.swing.JFrame {

    /**
     * Creates new form EjJTextArea
     */
    public EjJTextArea() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de inicio
    }

Para el ejemplo utilizamos varios métodos que cumplen funciones específicas. El nombre que le damos a cada método nos da una idea de que función cumple. El método “inicio()” por ejemplo arranca desde el constructor del JFrame y nos permite inicializar algunas propiedades del área de texto. Se agregan comentarios para indicar la funciona de cada línea de código.

    private void inicio(){
        //-Establecemos propiedades para el JTextArea-
        //Establecemos tipo de fuente predeterminado, texto itálico, tamaño 15
        jTex.setFont(new Font("Default", Font.ITALIC, 15));
        //Especificamos que el texto se ajusta al tamaño del Área de texto
        jTex.setLineWrap(true);
        jTex.setWrapStyleWord(true);
        //Hacemos que el área de texto no sea editable
        jTex.setEditable(false);
    }
    
    //Método para agregar texto al área de texto.
    private void agregar(){
        //Verificamos que el campo de texto no este vacío
        if(!jT.getText().isEmpty()){
            //Para agregar textos se utiliza append. "\n" indica salto de línea.
            jTex.append(jT.getText() + "\n");
            //Limpiamos el campo JTextField.
            jT.setText(null);
        }
    }

En este ejemplo tenemos un solo botón denominado “Agregar” la cual utilizará el evento “ActionPerformed” que permitirá ejecutar el método “agregar()”. En las primeras guías de la serie vimos cómo se hacer para relacionar un evento con un objeto visual.

    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
        agregar();
    } 

Llegado a este punto podremos ejecutar y probar 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 – 32 – Uso de JTable, agregar y eliminar elementos de tabla.

Trabajando con JTable en Java

Las tablas son uno de los elementos más utilizados dentro de cualquier lenguaje de programación, se puede utilizar para desplegar lista de datos similares ordenados de una forma específica. Su uso es bastante amplio pues es bastante versátil. En este ejemplo utilizaremos la tabla para mostrar datos ingresados por el usuario. Con esto podremos ver como se agregan y eliminan filas de una tabla. Como agregado veremos cómo agregar un JCheckBox a la tabla utilizando CellEditor y CellRenderer.

La tabla se puede manipular en modo diseño, se especifican los nombres y cantidad de columnas haciendo clic derecho sobre la tabla y accediendo a “Contenidos de tabla (Table Contents)”. Para el combo agregamos “Sí” y “No” en modo diseño desde la propiedad del objeto y en el apartado “model”. Agregar icono para los botones es opcional.

Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame y las variables de clase.

package com.swing.basic;//Paquete

import java.awt.Color;
import java.awt.Component;
import javax.swing.DefaultCellEditor;
import javax.swing.JCheckBox;
import javax.swing.JComponent;//Importaciones
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;

/**
 *
 * @author Ariel
 */
public class UsoJTable extends javax.swing.JFrame {

    /**
     * Creates new form UsoJTable
     */
    public UsoJTable() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de inicio
    }
    private DefaultTableModel model;//Modelo para tabla
    private int sel;//Variable para obtener fila seleccionada de tabla.

Para el ejemplo utilizamos varios métodos que cumplen funciones específicas. El nombre que le damos a cada método nos da una idea de que función cumple. El método “inicio()” por ejemplo arranca desde el constructor del JFrame y nos permite inicializar algunas propiedades de la tabla. Se agregan comentarios para indicar la funciona de cada línea de código.

    private void inicio(){ 
        //Método para configurar el DefaultTableModel de la tabla.
        //Especificamos el tamaño de cada columna
        jTb.getColumnModel().getColumn(0).setPreferredWidth(100);
        jTb.getColumnModel().getColumn(1).setPreferredWidth(100);
        jTb.getColumnModel().getColumn(2).setPreferredWidth(50);
        jTb.getColumnModel().getColumn(3).setPreferredWidth(100);
        jTb.getColumnModel().getColumn(4).setPreferredWidth(100);
        //Indicamos el DefaultTableModel de nuestra tabla
        model = (DefaultTableModel) jTb.getModel();
        //Indicamos el número de filas
        model.setNumRows(0);        
    } 
    
    //Método para agregar datos a la tabla.
    private void agregar(){
        //También mostramos como agregar un JCheckBox a la tabla
        JCheckBox check = new JCheckBox();
        //Comprobamos que los campos de datos no esten vacíos
        if(!nombre.getText().isEmpty() || !apellido.getText().isEmpty() ||
                !edad.getText().isEmpty() || !profesion.getText().isEmpty()){ 
            //Utilizamos un boolean para obtener el valor del combo.
            boolean rp = casado.getSelectedItem().toString().equals("Sí");  
            //Utilizamos try para la controlar posibles errores de conversión.
            try {
                //Convertimos en entero lo obtenido del campo edad.
                int edd = Integer.parseInt(edad.getText());
                //agregamos los datos a la tabla utilizando Object[]
                model.addRow(new Object[]{
                    nombre.getText(),apellido.getText(),edd, profesion.getText(),rp
                }); 
                limpiar();
            } catch (NumberFormatException e) {
                JOptionPane.showMessageDialog(null, "Edad debe ser numérico");
            }
            
        }
        //Agregamos el JCheckBox utilizando CellEditor y la clase CellRenderer creado más abajo
        jTb.getColumnModel().getColumn(4).setCellEditor(new DefaultCellEditor(check));
        jTb.getColumnModel().getColumn(4).setCellRenderer(new Render_CheckBox());
    }
    //Método para obtener la fila seleccionada de la tabla
    private void seleccion(){
        if(jTb.getRowCount() > 0 ){
            sel = jTb.getSelectedRow();
        }
    }
    //Método para obtener la fila seleccionada de la tabla.
    private void eliminar(){
        if(sel >= 0){
            model.removeRow(sel);
            sel = -1;
        }
        else{
            JOptionPane.showMessageDialog(null, "Selecciona una fila.");
        }
    }
    
    //Método para limpiar campos después de agregar los datos a la tabla
    private void limpiar(){
        nombre.setText(null);
        apellido.setText(null);
        edad.setText(null);
        profesion.setText(null);
        casado.setSelectedIndex(-1);
    }
    //Clase para manejar el TableCellRenderer, que permitirá mostrar el JCheckBox
    class Render_CheckBox extends JCheckBox implements TableCellRenderer {
    //
        private final JComponent component = new JCheckBox();

        /** Constructor de clase */
        public Render_CheckBox() {
            setOpaque(true);
    }

            @Override
      public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
          //Color de fondo de la celda
          ( (JCheckBox) component).setBackground( new Color(98,138,183) );
          //obtiene valor boolean y coloca valor en el JCheckBox
          boolean b = ((Boolean) value).booleanValue();
          ( (JCheckBox) component).setSelected( b );
          return ( (JCheckBox) component);
      }
    }
    

Para el ejemplo utilizamos dos tipos de evento, “ActionPerformed” para los botones y “MouseClicked” para la tabla. Abajo la lista de eventos. Obs.: En las primeras guías de esta serie vimos cómo se agregan eventos a objetos en modo diseño.

    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
        agregar();
    }                                       

    private void eliminarActionPerformed(java.awt.event.ActionEvent evt) {                                         
        eliminar();
    }                                        

    private void jTbMouseClicked(java.awt.event.MouseEvent evt) {                                 
        seleccion();
    }   

Llegado a este punto podremos ejecutar y probar 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) (clic sobre la imagen para ampliar)

Uso básico de elementos Swing con NetBeans – 31 – Uso de JTabbedPane, divisor de paneles.

Uso del elemento JTabbedPane en Java

JTabbedPane es un elemento útil a la hora de dividir múltiples paneles en pestañas, lo cual permite incluir multitud de funcionalidades en un solo formulario, permitiendo compactarlas en paneles independientes y de fácil navegación. Para este ejemplo utilizaremos un JTabbedPane a la cual le incluiremos tres JPanel, cada una indicará una pestaña funcional por si sola. A cada JPanel le agregaremos un JScrollPane para ajustar el redimensionado y dentro de esta última un JLabel la cual utilizando ejemplos anteriores le agregaremos una imagen. Como se ver en el diseño más abajo, los ajustes básicos la hacemos en modo código, por tanto basta con agregar de forma correcta cada elemento.

Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

package com.swing.basic;//Paquete

import javax.swing.ImageIcon;//Importación

/**
 *
 * @author Ariel
 */
public class UsoJTabbedPane extends javax.swing.JFrame {

    /**
     * Creates new form UsoJTabbedPane
     */
    public UsoJTabbedPane() {
        initComponents();
        setLocationRelativeTo(null);//Centrar Formulario
        inicio();//Método de inicio
    }

Como es habitual utilizamos un método privado que arrancará junto con el formulario al llamarla desde el constructor, esto nos permitirá inicializar las propiedades necesarias de cada objeto del formulario. Se especifican con comentarios la funcionalidad de cada línea de código. Para este ejemplo no se aplican los eventos.

    private void inicio(){
        //Configuramos el primer tabbed, el primer parámetro indica el índice.
        jTabb.setTitleAt(0, "Primer Panel");
        jTabb.setIconAt(0, createImageIcon("/com/swing/basic/img/Search.png"));
        jTabb.setToolTipTextAt(0, "Esta es la primera pestaña");
        //Agregamos el icono al label
        jLab01.setText(null);
        //Depende de como tengamos oragnizado los paquetes para ubicar las imagenes
        jLab01.setIcon(createImageIcon("/com/swing/basic/img/aqua.png"));
        
        //Configuramos el segundo tabbed, el primer parámetro indica el índice.
        jTabb.setTitleAt(1, "Segundo Panel");
        jTabb.setIconAt(1, createImageIcon("/com/swing/basic/img/clients.png"));
        jTabb.setToolTipTextAt(1, "Esta es la segunda pestaña");
        jLab02.setText(null);
        jLab02.setIcon(createImageIcon("/com/swing/basic/img/kirito.png"));
        
        //Configuramos el tercer tabbed, el primer parámetro indica el índice.
        jTabb.setTitleAt(2, "Tercer Panel");
        jTabb.setIconAt(2, createImageIcon("/com/swing/basic/img/load.png"));
        jTabb.setToolTipTextAt(2, "Esta es la tercera pestaña");
        jLab03.setText(null);
        jLab03.setIcon(createImageIcon("/com/swing/basic/img/paisaje.png"));       
    }
    //Método que nos permitirá cargar una imagen como icono pasándole una url
    private 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;
        }
    }

Ahora sí, podemos 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 – 30 – Uso de JSplitPane, divisor de elementos.

Trabajando con JSplitPane desde Java

El JSplitPane es un elemento muy útil que nos permite dividir objetos distintos en uno o varios paneles redimensionables. En este ejemplo agregamos una Lista de nombres de imágenes PNG, que se cargarán al seleccionarlas con un clic y que se mostraran en un Label, como se ve en el diseño el JSplitPane muestra la lista en la parte izquierda y al label en la parte derecha en el medio el divisor redimensionable. Como vemos en el diseño también necesitamos dos JScrollPane, que se puede agregar arrastrando y soltando en el punto específico, la misma forma el elemento que la utilizan se arrastra y suelta en su interior. Es más fácil mover elementos de un lugar a otro utilizando el “Navegador” como se muestra en la imagen más abajo.

Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

import javax.swing.DefaultListModel;
import javax.swing.ImageIcon;//Importaciones

/**
 *
 * @author Ariel
 */
public class UsoJSplitPane extends javax.swing.JFrame {

    /**
     * Creates new form UsoJSplitPane
     */
    public UsoJSplitPane() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de arranque
    }
    private DefaultListModel modelList;//Variable de clase.

Para el ejemplo utilizamos varios métodos que cumplen funciones específicas, la principal es “inicio” que nos permitirá inicializar la lista y configurar ciertas propiedades de cada elemento del diseño. Las propiedades de objetos se pueden editar en modo diseño, pero es más fácil entender cómo funcionan al hacerla en modo código.

    private void inicio(){
        //Incluye las fechitas de expanción rápida al JSplitPane
        jSp.setOneTouchExpandable(true);
        //Localización de divisor
        jSp.setDividerLocation(150);
        //Array de String con los nombres de archivos PNG que utilizaremos
        //Cada uno puede hacer su propia lista.
        String[] img = {"paisaje","bosque","kirito","Delete","Login","New","Save","Select","load","note","package",
        "print","userr","aqua"};
        //DefaultListModel para el JList
        modelList = new DefaultListModel();
        //Agregamos el array de String a la lista
        for (String string : img) {
            modelList.addElement(string);
        }
        //Específicamos el DefaultListModel para nuestro JList
        jLt.setModel(modelList);
        //Indicamos que el JLabel no muestre texto
        jLb.setText(null);
        
        /**
        Imagen tipo JPG para indicar una imagen incial al JLabel
        El resto de las imagenes utilizada son PNG
        Las imagenes debemos de tenerlas en un paquete dentro del mismo proyecto...
        O dentro del mismo paquete que nuestro JFrame, en tal caso solo indicamos el nombre y la extensión,
        Caso contrario debemos de indicar toda la ruta...
        * */        
        jLb.setIcon(createImageIcon("/com/swing/basic/img/" + "acercaFond" + ".jpg"));
    }
    //Método para actualizar la imagenes mostradas en el JLabel
    private void actualizar(){
        imageLabel(jLt.getSelectedValue().toString());
    }
    //Método que requiere como parámetro el nombre del la imagen para mostrar
    private void imageLabel(String nombre){
        jLb.setIcon(createImageIcon("/com/swing/basic/img/" + nombre + ".png"));
    }
    
    //Método que nos permitira cargar una imagen como icono pasándole una url
    private 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;
        }
    }

En este ejemplo el único elemento que maneja eventos es la lista, la cual utiliza el MouseClicked. En las primeras guías de la serie vimos cómo se implementan los eventos desde el entorno de diseño, si hay dudas se pueden consultar esas entradas.

    private void jLtMouseClicked(java.awt.event.MouseEvent evt) {                                 
        actualizar();
    }  

Ahora sí, podemos 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) (clic sobre la imagen para ampliar)

Uso básico de elementos Swing con NetBeans – 29 – Uso de Spinners, ejemplo 2.

Uso básico de Spinners en Java

Para este ejemplo utilizamos dos JSpinner, una para indicar fecha y otra para hora. Aparte de las etiquetas no se utiliza otro elemento, el diseño es bastante sencillo. El proceso es similar al ejemplo uno, se especifica el funcionamiento de cada línea de código con comentarios.

Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

import java.util.Calendar;
import java.util.Date;
import javax.swing.JSpinner;//Importaciones
import javax.swing.SpinnerDateModel;
import javax.swing.SpinnerModel;

/**
 *
 * @author Ariel
 */
public class UsoSpinnerDos extends javax.swing.JFrame {

    /**
     * Creates new form UsoJSliderDos
     */
    public UsoSpinnerDos() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de arranque
    }
    Calendar calendar = Calendar.getInstance();//Variable de Objeto Calendar

Para este ejemplo requerimos de un solo método privado, que se iniciará desde el constructor del JFrame y permitirá inicializar los spinners. Se especifica el funcionamiento de cada línea de código utilizando comentarios. No se requieren eventos para este ejemplo.

    private void inicio(){
        //Obtenemos una fecha de inicio, será la fecha actual del sistema
        Date inicio = calendar.getTime();
        //Indicamos año hasta -100 del actual
        calendar.add(Calendar.YEAR, -100);
        //Guardamos la configuración en un DATE
        Date fechaAnterior = calendar.getTime();
        //Indicamos año hasta +200 del actual
        calendar.add(Calendar.YEAR, 200);
        //Guardamos la configuración en un DATE
        Date fechaPosterior = calendar.getTime();
        //Usamos el contructor de abajo para crear un modelo para el Spinner
        //SpinnerDateModel(Date value, Comparable start, Comparable end, int calendarField)
        //Utilizamos los datos que creamos más arriba
        //Para fecha utilizamos Calendar.YEAR y para hora Calendar.HOUR, el resto puede ser igual
        SpinnerModel fechaModel = new SpinnerDateModel(inicio, fechaAnterior, fechaPosterior, Calendar.YEAR);
        SpinnerModel horaModel = new SpinnerDateModel(inicio, fechaAnterior, fechaPosterior, Calendar.HOUR);
        //Indicamos el model para cada Spinner además del formato de fecha y hora según corresponda.
        fecha.setModel(fechaModel);
        fecha.setEditor(new JSpinner.DateEditor(fecha, "dd/MM/yyyy"));
        hora.setModel(horaModel);
        hora.setEditor(new JSpinner.DateEditor(hora, "HH:mm:ss"));
    }

Ahora sí, podemos 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) (clic sobre la imagen para ampliar)

Uso básico de elementos Swing con NetBeans – 28 – Uso de Spinners, lista de elementos.

Trabajando con Spinners desde Java.

En esta oportunidad pondremos en funcionamiento tres Spinnes, que contendrán una lista de días meses y años respectivamente. Como sabemos un spinner puede contener diferentes tipos de elementos sean estas numéricas o no. Para el ejemplo agregaremos tres Spinnes que contendrán cada uno un modelo específico de elementos que se contendrán en Arrays y enteros. Dependiendo del caso se pueden utilizar SpinnerListModel o SpinnerNumberModel.

Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

import java.util.Calendar;
import javax.swing.SpinnerListModel;
import javax.swing.SpinnerModel;//Importaciones
import javax.swing.SpinnerNumberModel;

/**
 *
 * @author Ariel
 */
public class UsoSpinner extends javax.swing.JFrame {

    /**
     * Creates new form UsoSpinner
     */
    public UsoSpinner() {
        initComponents();
        setLocationRelativeTo(null);//Centrar Formulario
        inicio();
    }
    Calendar calendar = Calendar.getInstance();//Variable de Objeto Calendar

Para este ejemplo requerimos de un solo método privado, que se iniciará desde el constructor del JFrame y permitirá inicializar los spinners. Se especifica el funcionamiento de cada línea de código utilizando comentarios. No se requieren eventos para este ejemplo.

    private void inicio(){
        //Array de String para los días y meses
        String[] d = {"Domingo","Lunes","Martes","Miércoles","Jueves","Viernes","Sábado"};
        //El array mes puede contener un registro vacío, se puede corregir con un pequeño ajuste...
        String[] mes = new java.text.DateFormatSymbols().getMonths();
        //Tipo entero para año
        int an = calendar.get(Calendar.YEAR);
        
        //Especificando modelos para cada Spinner
        SpinnerListModel modelDias = new SpinnerListModel(d);
        SpinnerListModel modelMes = new SpinnerListModel(mes);
        //Parámetro numéricos
        //public SpinnerNumberModel(int value, int minimum, int maximum, int stepSize)
        //Valor inicial - valor mínimo - valor máximo - incremento a 1
        SpinnerModel modelAnyo = new SpinnerNumberModel(an, an - 100, an + 100, 1);
        //Agregamos el modelo a cada Spinner
        dias.setModel(modelDias);
        meses.setModel(modelMes);
        anyos.setModel(modelAnyo);
    }

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) (clic sobre la imagen para ampliar)

Uso básico de elementos Swing con NetBeans – 27 – Uso de JSlider, regla interactiva.

Manejo de JSlider desde Java.

Para este ejemplo veremos el uso básico de un “JSlider”, que es similar a una regla interactiva con valores numéricos o etiquetas que indican propiedades. En esta aplicación utilizaremos un Área de Texto junto con el JSlider. Específicamente el JSlider contendrá valores numéricos que representaran tamaños de fuentes, el Área de Texto contendrá dos párrafos que irán variando el tamaño de texto conforme desplacemos los valores más o menos en el JSlider.

Tomar en cuenta los nombres de variable de cada objeto, se especifican los nombres en el diseño. Esto es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame.

import java.awt.Font;

/**
 *
 * @author Ariel
 */
public class UsoJSlider extends javax.swing.JFrame {

    /**
     * Creates new form UsoJSlider
     */
    public UsoJSlider() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de inicio
    }

Para este ejemplo requerimos un único método que llamaremos al ejecutar el formulario y esto nos permitirá inicializar los objetos que agregamos en modo de diseño. 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.

private void inicio(){
        //-Establecemos propiedades para el JTextArea-
        //Establecemos tipo de fuente Consolas, texto plano, tamaño 15
        jt.setFont(new Font("Consolas", Font.PLAIN, 16));
        //Especificamos que el texto se ajusta al tamaño del Área de texto
        jt.setLineWrap(true);
        jt.setWrapStyleWord(true);
        //Agregamos texto simple al Área de Texto como ejemplo.
        //El indicador \n sirve para salto de línea.
        jt.setText("Java Development Kit o (JDK), es un "
                + "software que provee herramientas de desarrollo "
                + "para la creación de programas en Java. "
                + "\nNetBeans IDE. Es un entorno de desarrollo integrado libre, "
                + "hecho principalmente para el lenguaje de programación Java."); 
        
        //Configurams el JSlider
        //Valor mínimo
        jl.setMinimum(8);
        //Valor máximo
        jl.setMaximum(44);
        //valor inicial
        jl.setValue(16);
        //Valores para mostrar regla
        //mínimo para mostrar
        jl.setMinorTickSpacing(1);
        //máximo para mostrar
        jl.setMajorTickSpacing(4);
        //Especificamos que se muestren los valores
        jl.setPaintTicks(true);
        jl.setPaintLabels(true);
    }

Para el JSlider utilizamos el evento “StateChanged”, que nos permitirá capturar el valor cuando se deslice el marcador en la regla. En las primeras guías de la serie vimos cómo se implementan los eventos desde el entorno de diseño, si hay dudas se pueden consultar esas entradas.

    private void jlStateChanged(javax.swing.event.ChangeEvent evt) {                                
        //Obtenemos valor del JSlider
        int value = jl.getValue();
        //Indicamos las propiedades de fuente del JTextArea
        //value será la que cambien según se mueva el marcador del JSlider.
        jt.setFont(new Font("Consolas", Font.PLAIN, value));
    }

En este punto ya podremos ejecutar nuestro formulario y comprobar su funcionalidad. (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 – 26 – Uso de JProgressBar, barra de progreso. Ejemplo 2.

Ejemplo de uso de JProgressBar desde Java

En esta guía veremos el funcionamiento de la barra de progresos “JProgressBar” de uso habitual en ciertos procesos que requieren tiempo de ejecución controlada. Para este segundo ejemplo realizaremos algo un poco más complejo, específicamente aplicaremos una método que calcula números primos. Este método la hemos creado como ejemplo para el curso en modo consola, realizaremos pequeñas modificaciones para ajustarla a este propósito. Para el diseño utilizamos un JFrame, la nombramos “UsoJProgressBar2”. Podemos utilizar “JPanel” para ordenar los elementos de forma independiente. En vista de diseño vemos en uno de los paneles dos campos de texto con sus etiquetas más los botones de comando que servirán para poner en marcha la aplicación. Seguido la barra de progresos. Por último dentro de un panel el “JList” que mostrará los números primos que obtengamos.

Tomar en cuenta los nombres de variable de cada objeto, en el diseño se especifican; es muy importante ya que desde los métodos se utilizan estos nombres para referencia a cada objeto. 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)

Lista de importaciones que necesitamos para trabajar con ciertos objetos. Además los métodos llamados desde el constructor del JFrame y variables de clase que necesitamos crear.

package com.swing.basic;//tomar en cuenta el paquete del JFrame

import javax.swing.DefaultListModel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.ListSelectionModel;

/**
 *
 * @author Ariel
 */
public class UsoJProgressBar2 extends javax.swing.JFrame {

    /**
     * Creates new form UsoJProgressBar2
     */
    public UsoJProgressBar2() {
        initComponents();
        setLocationRelativeTo(null);//Centrar formulario
        inicio();//Método de inicio
    }
    private DefaultListModel modelList;//Variable de clase.

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.

    private void inicio(){
        //Especificamos algunas propiedades de nuestra lista
        //Inicializamos la variable DefaultListModel
        modelList = new DefaultListModel();
         //Establecemos el modelo, nos permite agregar y eliminar elementos, etc.
        lista.setModel(modelList);
        //Intervalo de selección
        lista.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
        lista.setSelectedIndex(0);
        lista.setVisibleRowCount(-1);
        //Distribución horizontal
        lista.setLayoutOrientation(JList.HORIZONTAL_WRAP);        
        //Limpiamos los campos de texto
        desde.setText(null);
        hasta.setText(null);
        //Indicamos el valor que muestra JProgressBar al iniciar el programa
        jpb.setValue(0);
    }
    
    private void iniciar(){
        //Creamos un Thread para mejorar el ejemplo
        final Thread t;
        //Inicializamos
        t = new Thread(new Runnable() {
            //Implementamos el método run()
            @Override
            public void run() {
                //Permite mostrar el valor del progreso
                jpb.setStringPainted(true);
                //Comprobamos que no esten vacíos los campos de texto
                if(!desde.getText().isEmpty() && !hasta.getText().isEmpty()){
                    //Utilizamos try... por si falla la coversión numérica
                    try {
                        int d = Integer.parseInt(desde.getText());
                        int h = Integer.parseInt(hasta.getText());
                        //Verificamos que los datos numéricos sean mayor que cero-0
                        if(d > 0 && h > 0){
                            //Verificamos que h sea mayor que d
                            if(h > d){
                                //Establecemos el valor mínimo y máximo de nuestro barra de progreso
                                //Esta permitirá mostra el valor correcto del progreso
                                jpb.setMinimum(d);
                                jpb.setMaximum(h);
                                //Con un for iremos comprobando si el valor de i es primo
                                for (int i = d; i <= h; i++) {
                                    //i será el valor de la barra de progreso en cada momento, esta se ira incrementando
                                    jpb.setValue(i);
                                    //Comprobamos que el valor sea primo por cada ciclo
                                    if(!esPrimo(i)){
                                        modelList.addElement(i);
                                    }
                                    //Hacemos una interrupción de 100 milisegundos
                                    //Se puede disminuir o aumentar según se desee
                                    try {
                                        Thread.sleep(100);
                                    } catch (InterruptedException e) {
                                    }
                                }
                            }
                        }
                        
                    } catch (NumberFormatException e) {
                        JOptionPane.showMessageDialog(null, "Datos no numéricos" + e);
                    }
                }                
            }
        });
        //Se ejecuta el Thread
        t.start();
    }
    //Este método vimos su funcionamiento en modo consola
    //La función recibe un entero como argumento para calcular si es primo
    private boolean esPrimo(int n){
        //inicializamos una variable boolean
        boolean b = false;
        //Los números negativos no entran como primos, el 1-uno tampoco
        if(n <= 0 || n == 1){
            b = true;
        }
        //El 2,3,5 son primos conocidos por tanto las obviamos
        else if(n != 2 && n != 3 && n != 5){
            //Con un for recorremos los números intermedios en 1 y n
            //Comprobamos que el módulo con alguno de ellos de 0-cero
            for (int i = 2; i < n; i++) {
               //Si b es true, demuestra que n no es primo y salimos del bucle
               if(b){
                   break;
               }
               b = (n%i == 0);
            }            
        }
        //2,3 y 5 son los primeros primos conocidos
        else{
            b = false;
        }
        return b;
    }

Para los botones utilizamos el evento “ActionPerformed”. Si hay dudas sobre como agregar “Eventos” a objetos, en las primeras guías de la serie vimos con detalle ese punto.

    private void iniciarActionPerformed(java.awt.event.ActionEvent evt) {                                        
        iniciar();
    }                                       

    private void limpiarActionPerformed(java.awt.event.ActionEvent evt) {                                        
        inicio();
    }  

En este punto ya podremos ejecutar nuestro formulario y comprobar su funcionalidad. (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)