FranVarVil: input

Mostrando entradas con la etiqueta input. Mostrar todas las entradas

domingo, 20 de enero de 2013

Java: Swing: JFormattedTextField y MaskFormatter

Francisco 9:35 gui , input , java , jtextfield , por: Francisco Vargas , programación java , swing No hay comentarios :

Introducción

Existen ocasiones en que necesitamos que el Usuario ingrese algunos valores, pero estos valores debe tener un formato, por ejemplo en mi Universidad se una un carnet alfanumérico que consta de una letra y 5 números (ejemplo: A12345), entonces para no tener que hacer validaciones ni nada cada vez que el usuario ingrese los valores creamos máscaras, que sirven para especificar un formato de entrada.

Desarrollo

Estas máscaras se usan junto con los JFormattedTextField que son los campos donde el usuario va a escribir lo que se le solicita.

Primero vamos a crear nuestra máscara, para ello importamos la librería:

import javax.swing.text.MaskFormatter;

Y vamos a crear nuestro método de la máscara:

// Mascara para nuestra contraseña
 private MaskFormatter mascara() {
     // Inicializamos el objeto
     MaskFormatter mascara = new MaskFormatter();
     // Entramos en un try/catch por alguna eventualidad
     try {
         // Creamos el formato de nuestra contraseña
         // # -> un número U -> letra mayúscula L -> letra minúscula
         // * -> cualquier caracter ' -> caracteres de escape
         // A -> cualquier letra o número ? -> cualquier caracter
         // H -> cualquier caracter hexagonal (0-9, a-f or A-F).
         mascara = new MaskFormatter("A#####");
     } catch (ParseException e) {
         // Algún error que pueda ocurrir
         e.printStackTrace();
     }
     return mascara;
 }

Como podrán apreciar existen varios "caracteres" reservador para las diferentes combinaciones que queremos hacer, ese método es para los carnet de mi Universidad, una letra y luego cinco números. Además es necesario que esté en un Try/catch por cualquier excepción (acá se explican como funciona un try/catch).

Por cierto para este try/catch tienen que importar esto:

import java.text.ParseException;

Ya con nuestra máscara creada vamos a hacer el campo de texto que tiene ese formato específico para esto importamos la librería:

import javax.swing.JFormattedTextField;

Y nuestro método sería este:

 // Espacio para ingresar el nombre de usuario
 private JFormattedTextField jtaContrasenia(MaskFormatter mascara) {
     // Se inicializa el objeto
     JFormattedTextField contrasenia = new JFormattedTextField(mascara);
     // Asignamos posición y tamaño
     contrasenia.setBounds(200, 80, 150, 20);
     // Le colocamos un texto emergente
     contrasenia.setToolTipText("Formato de la contrasenia: (a-z)#####, ejemplo: A13455 ");
     return contrasenia;
 }

Este método recibe una mascara que es la que creamos anteriormente, se la enviamos en el constructor de la clase cuando añadimos el JFormattedTextField al JFrame, sería así:

add(jtaContrasenia(mascara()));

Y con eso ya aplicamos la mascara en nuestro campo de texto y hacemos que el usuario ingrese justo lo que nosotros deseamos, hay que tener en cuenta que si el usuario no llena, en este caso los seis espacios, cuando se quiera hacer una acción con lo que esté escrito hasta el momento trabajaria con un vacío ( "" ), y puede causar malestares en el programa si no se hacen las validaciones necesarias.

La clase final sería esta:

package Parapublicar;

import java.text.ParseException;

import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;
import javax.swing.text.MaskFormatter;

@SuppressWarnings("serial")
public class Mascaras extends JFrame {

    public Mascaras() {
        add(ingresarContrasenia());
        add(ingresarUsuario());
        add(jtaUsuario());
        // Le enviamos la mascara a nuestro JFormattedTextField
        add(jtaContrasenia(mascara()));
        inicializador();
    }

    // Inicializador de la Ventana
    private void inicializador() {
        setSize(400, 200);
        setLayout(null);
        setTitle("Login");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    // Texto que indica donde va el nombre de Usuario
    private JLabel ingresarUsuario() {
        JLabel usuario = new JLabel("Nombre de Usuario: ");
        usuario.setBounds(30, 30, 200, 20);
        return usuario;
    }

    // Texto que indica donde va la contraña
    private JLabel ingresarContrasenia() {
        JLabel contrasenia = new JLabel("Contrasenia: ");
        contrasenia.setBounds(30, 80, 200, 20);
        return contrasenia;
    }

    // Espacio para ingresar el nombre de usuario
    private JTextField jtaUsuario() {
        JTextField usuario = new JTextField();
        usuario.setBounds(200, 30, 150, 20);
        usuario.setToolTipText("Ingrese Nombre de Usuario");
        return usuario;
    }

    // Espacio para ingresar el nombre de usuario
    private JFormattedTextField jtaContrasenia(MaskFormatter mascara) {
        // Se inicializa el objeto
        JFormattedTextField contrasenia = new JFormattedTextField(mascara);
        // Asignamos posición y tamaño
        contrasenia.setBounds(200, 80, 150, 20);
        // Le colocamos un texto emergente
        contrasenia.setToolTipText("Ingrese la contrasenia");
        return contrasenia;
    }

    // Mascara para nuestra contraseña
    private MaskFormatter mascara() {
        // Inicializamos el objeto
        MaskFormatter mascara = new MaskFormatter();
        // Entramos en un try/catch por alguna eventualidad
        try {
            // Creamos el formato de nuestra contraseña
            // # -> un número U -> letra mayúscula L -> letra minúscula
            // * -> cualquier caracter ' -> caracteres de escape
            // A -> cualquier letra o número ? -> cualquier caracter
            // H -> cualquier caracter hexagonal (0-9, a-f or A-F).
            mascara = new MaskFormatter("A#####");
       } catch (ParseException e) {
           // Algún error que pueda ocurrir
           e.printStackTrace();
       }
       return mascara;
    }

    public static void main(String[] args) {
        new Mascaras();
   }

}

Documentación de Java sobre las máscaras: https://docs.oracle.com/javase/8/docs/api/javax/swing/text/MaskFormatter.html
Documentación de Java sobre JFormattedTextField: https://docs.oracle.com/javase/8/docs/api/javax/swing/JFormattedTextField.html

Conclusiones

Utilizar máscaras puede ser de gran utilidad en diversas aplicaciones, debido a que ayudan a validar que es lo que el usuario esta digitando.

Siempre que se utilice una máscara se le debe mostrar al usuario el formato correspondiente que se desea que introduzca en el campo, debido a que esto hará que el usuario tenga una mejor noción de que es lo que se solicita.

sábado, 19 de enero de 2013

Java: Swing: JPasswordField

Francisco 8:40 gui , input , java , jframe , jlabel , jtextfield , por: Francisco Vargas , programación java , swing , ventanas java 9 comentarios :

Introducción

Cuando vamos a escribir una contraseña o alguna otra palabra que deseamos que no aparezca visualmente en el campo sino más bien algún caracter (lo más común son unos puntitos), existe lo llamado JPasswordField. Es un campo de texto (como el JTextField) solo que cuando escribimos aparecerán los puntitos o el caracter que nosotros seleccionamos.

Desarrollo

Importamos la librería necesaria para utilizar el JPasswordField:

import javax.swing.JPasswordField;

Luego procedemos a crear nuestro método, el ejemplo que daré es de un Login o un área donde colocamos usuario y contraseña para ingresar a una cuenta.

// Espacio para ingresar la contraseña
 private JPasswordField jpfContrasenia() {
     // Se inicializa el Objeto
     JPasswordField contrasenia = new JPasswordField();
     // Asignamos posición y tamaño
     contrasenia.setBounds(200, 80, 150, 20);
     // Colocamos un símbolo personalizado(opcional)
     // Si no lo colocamos aparecen los puntitos predeterminados
     contrasenia.setEchoChar('+');
     // Le asignamos un texto emergente cuando nos posamos encima del objeto
     contrasenia.setToolTipText("Ingrese Contraseña");
     return contrasenia;
 }

Y con ese método creamos nuestro campo para una contraseña, coloqué un símbolo “mas” ( + ) solo para el ejemplo y para que se conozca el método para cambiar el símbolo pero esa característica es opcional, me gustan más los puntos tradicionales. Bueno luego creamos los JLabel y el JTextField para hacer nuestra ventana de “ingresar” y mi clase final quedaría así:

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;

@SuppressWarnings("serial")
public class Password extends JFrame {

    public Password() {
        add(ingresarUsuario());
        add(ingresarContrasenia());
        add(jtaUsuario());
        add(jpfContrasenia());
        inicializador();
    }

    // Inicializador de la Ventana
    private void inicializador() {
        setSize(400, 200);
        setLayout(null);
        setTitle("Login");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    // Texto que indica donde va el nombre de Usuario
    private JLabel ingresarUsuario() {
        JLabel usuario = new JLabel("Nombre de Usuario: ");
        usuario.setBounds(30, 30, 200, 20);
        return usuario;
    }

    // Texto que indica donde va la contraña
    private JLabel ingresarContrasenia() {
        JLabel contrasenia = new JLabel("Contrasenia: ");
        contrasenia.setBounds(30, 80, 200, 20);
        return contrasenia;
    }

    // Espacio para ingresar el nombre de usuario
    private JTextField jtaUsuario() {
        JTextField usuario = new JTextField();
        usuario.setBounds(200, 30, 150, 20);
        usuario.setToolTipText("Ingrese Nombre de Usuario");
        return usuario;
    }

    // Espacio para ingresar la contraseña
    private JPasswordField jpfContrasenia() {
        // Se inicializa el Objeto
        JPasswordField contrasenia = new JPasswordField();
        // Asignamos posición y tamaño
        contrasenia.setBounds(200, 80, 150, 20);
        // Colocamos un símbolo personalizado(opcional)
        contrasenia.setEchoChar('-');
        // Le asignamos un texto emergente cuando nos posamos encima del objeto
        contrasenia.setToolTipText("Ingrese Contraseña");
        return contrasenia;
    }

    public static void main(String[] args) {
        new Password();
    }

}

Como nota, también se puede agregar a un JOptionPane, elementos como paneles, labels, entre otros, acá les dejo un ejemplo para un JOptionPane tipo password.

// Objeto que hará que aparezcan los puntitos en la contraseña en vez de
// los caracteres ingresados
JPasswordField pwd = new JPasswordField();


// Primero null, luego pwd que es nuestro objeto jpassfield acá
// puedes colocar paneles, label entre otros objetos, nombre del
// titulo de la ventana, tipo de botones, sin icono

JOptionPane.showConfirmDialog(null, pwd, "Enter Password",JOptionPane.OK_CANCEL_OPTION, JOptionPane.PLAIN_MESSAGE);

Documentación: http://docs.oracle.com/javase/8/docs/api/javax/swing/JPasswordField.html

Conclusiones

No mostrar información sensible es un método para salvaguardar a los usuarios que utilicen la aplicación.

Tampoco es bueno exagerar y colocar todo con este tipo de elemento.

viernes, 18 de enero de 2013

Java: Swing: JTextArea y JScrollPane

Francisco 16:57 gui , input , java , jframe , jlabel , jtextfield , por: Francisco Vargas , programación java , swing No hay comentarios :

Introducción

Los JTextArea se utilizan cuando se le pide al Usuario que escriba por ejemplo un comentario, una sugerencia o cualquier otra cosa que lleve varias líneas, es algo muy parecido al JTextField, solo que para un texto más amplio.

Desarrollo

Lo primero que se hace es importar la librería:

import javax.swing.JTextArea;

Para crear nuestro objeto haríamos el siguiente método:

    // Crea un JTextArea para escribir un texto amplio
    private JTextArea jtaEscribir() {
        // Se inicializa la variable
        JTextArea area = new JTextArea();
        // Se define el salto de linea automático
        // (cuando llega al final del JTextArea hace un salto de línea)
        area.setLineWrap(true);
        // Se asigna posicion y tamaño al JTextArea
        area.setBounds(30, 30, 300, 200);
        // Le podemos asignar un color de fondo
        area.setBackground(new Color(0, 0, 0));
        // Por ende cambiamos el color de letra
        area.setForeground(new Color(255, 255, 255));
        return area;
    }

Las propiedades para definir el fondo y el color de letra solo las coloqué para que vean que si se pueden usar, mientras que el método .setLineWrap() es para cuando llegamos al final del tamaño de nuestro JTextArea salte automáticamente a la siguiente línea y eso evita que el usuario tenga que precionar enter cada vez que llegue al final o que siga escribiendo en una unica línea todo.

Ahora bien con esto existe un problema casi nunca funciona colocar los scrolls que trae por defecto el JTextArea por tanto si el usuario llega al final (de abajo en el eje Y) del JTextArea podrá seguir escribiendo pero no podrá ver que es lo que escribe, pero eso lo solucionamos con nuestro JScrollPane!!!

El JScrollPane es el que nos viene a solucionar ese pequeño defecto y a dar un toque más bonito a nuestro JTextArea, para las barra de desplazamiento importamos:

import javax.swing.JScrollPane;

Pues bien nuestro JScrollPane es un panel, ¿qué es un panel?, pues un panel es un objeto que almacena otros objetos dentro de el, por ejemplo imaginemos una cubeta en la cual colocamos algunos elementos dentro en cierto orden, cuando movemos la cubeta no hay que mover todos esos elementos dentro de ella porque ya están dentro y se mueven con ella , solo que nuestro JScrollPanel no solo contiene objetos sino que también da barras de desplazamiento.

Para crearlo haremos el siguiente método:

 // Se crea una barra de desplazamiento
 private JScrollPane jsbBarra() {
     // Se inicializa el objeto y se le agrega un JTextArea
     JScrollPane scroll = new JScrollPane(jtaEscribir());
     // Se le asigna una posicion y un tamaño
     scroll.setBounds(30, 30, 300, 200);
     return scroll;
 }

Nuestro ScrollPane va a recibir a nuestro método donde creamos nuestro JTextArea y en el JFrame no agregamos el JTextArea sino que agregamos el JScrollPane. Y a nuestro método del JTextArea le quitamos lo posición y el tamaño ya que no los necesitamos.

Al final nuestra clase quedaría así, es solo una ventana con un campo donde escribir:

import java.awt.Color;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

@SuppressWarnings("serial")
public class JTextAreaYJScrollPane extends JFrame {

    public JTextAreaYJScrollPane() {
        // add(jtaEscribir());
        add(jsbBarra());
        inicializador();
    }

    // Inicializador de la Ventana
    private void inicializador() {
        setSize(400, 300);
        setLayout(null);
        setTitle("Mi ventana");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    // Crea un JTextArea para escribir un texto amplio
    private JTextArea jtaEscribir() {
        // Se inicializa la variable
        JTextArea area = new JTextArea();
        // Se define el salto de linea automático
        // (cuando llega al final del JTextArea hace un salto de línea)
        area.setLineWrap(true);
        // Se asigna posicion y tamaño al JTextArea
        // area.setBounds(30, 30, 300, 200);
        // Le podemos asignar un color de fondo
        area.setBackground(new Color(0, 0, 0));
        // Por ende cambiamos el color de letra
        area.setForeground(new Color(255, 255, 255));
        return area;
    }

    // Se crea una barra de desplazamiento
    private JScrollPane jsbBarra() {
           // Se inicializa el objeto y se le agrega un JTextArea
           JScrollPane scroll = new JScrollPane(jtaEscribir());
           // Se le asigna una posicion y un tamaño
           scroll.setBounds(30, 30, 300, 200);
           return scroll;
    }

    // El MAIN
    public static void main(String[] args) {
        new JTextAreaYJScrollPane();
    }
}

Si quieren ver las diferencias con y sin el ScrollPane pueden comentar el add() del método del Scroll y descomentar el add() del método del JTextArea (y de este método descomentar el tamaño y posición) y así verán que es más estético con un JScrollPane (por lo menos ese es mi parecer).

La Documentación de Java al respecto:

JScrollPane: http://docs.oracle.com/javase/8/docs/api/javax/swing/JScrollPane.html

JTextArea: http://docs.oracle.com/javase/8/docs/api/javax/swing/JTextArea.html

Conclusiones

El textArea y el scrollPane son elementos que pueden servir de mucho en nuestras aplicaciones y gracias al scrollPane, se logra tener un mejor acabado

jueves, 6 de diciembre de 2012

Java: Swing: AWT: JButton y ActionListener

Francisco 10:40 action , actionlistener , botones , gui , input , java , jbuton , jframe , jlabel , jtextfield , por: Francisco Vargas , programación java , swing 3 comentarios :

Introducción

Los JButton, pues no hay mucho que decir son botones que se agregan en nuestro Frames para que ejecuten una acción al ser presionados por el Usuario.

Desarrollo

Primero tenemos que agregar la librería:

import javax.swing.JButton;

Ahora vamos a crear nuestro método para el botón:

private JButton verBoton() {
    //Inicializamos el botón
    JButton boton = new JButton();
    //agregamos texto al botón
    boton.setText("Botón");
    //agregamos coordenadas
    boton.setBounds(50, 50, 100, 50);
    //le damos una tipografía
    boton.setFont(new Font("Arial", 1, 18));
    //le damos un color a la fuente
    boton.setForeground(new Color(25,85,255));
 
    return boton;
 }

Con eso tendremos un botón con las letras azules (el color no es muy bonito pero es para que se aprecie el cambio). Nuestro botón si lo presionamos, no pasa nada entonces vamos a implementar una interface para que puedan ser "escuchados", con ser escuchados me refiero a que realicen algo cuando se les presione.

public class MiClase extends JFrame implements ActionListener {//nuestro código}

Cuando implementamos ActionListener tenemos que colocar el método de esta interface de lo contrario nos va a mostrar un error, para los que usan un IDE es muy fácil porque lo coloca automáticamente, pero para los que no, acá está el método que tenemos que colocar:

@Override
 public void actionPerformed(ActionEvent e) {
 }

En este método tenemos que colocar las acciones que van a ejecutar, en este caso nuestros botones.

Vamos a hacer un ejemplo reuniendo todo lo que vimos hasta ahora: JLabel, JTextField y JButton, vamos a escribir algo en un campo de texto y lo vamos a pasar (en mayúscula) a otro campo de texto que no se puede editar cuando presionemos un botón.

Aunque se vea muy simple, es para dar un ejemplo de como usar actionListener y bueno acá va el código comentado las partes que no se han visto antes:

import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextField;

@SuppressWarnings("serial")
public class JFrames extends JFrame implements ActionListener {

    //Ocupamos que nuestro botón y los jtextfield sean globales para poder acceder a ellos 
    //por medio de actionPerformed
    private JButton boton;
    private JTextField jtfPalabra;
    private JTextField jtfPalabraPasada;

    public JFrames() {
        add(verBoton());
        add(getPalabra());
        add(getIngresar());
        add(getPalabraPasada());
        inicializador();
    }
   
    private void inicializador() {
        setSize(400, 300);
        setLayout(null);
        setTitle("Mi ventana");
        setLocationRelativeTo(null);
        setVisible(true);
        setResizable(false);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
    }

    private JButton verBoton() {
        boton = new JButton();
        boton.setText(">>>");
        boton.setBounds(150, 200, 100, 50);
        boton.setFont(new Font("Arial", 1, 18));
        //le incluimos la posibilidad de ser escuchado cuando se
        //le precione
        boton.addActionListener(this);
        return boton;
    }
 
    private JLabel getIngresar() {
        JLabel jlIngresar = new JLabel("Ingrese una palabra: ");
        jlIngresar.setBounds(30, 50, 150, 30);
        return jlIngresar;
    }
 
    private JTextField getPalabra() {
        jtfPalabra = new JTextField();
        jtfPalabra.setBounds(180, 50, 100, 30);
        return jtfPalabra;
    }
 
    private JTextField getPalabraPasada() {
        jtfPalabraPasada = new JTextField();
        jtfPalabraPasada.setBounds(180, 120, 150, 30);
        //Hacemos que lo que esté escrito acá no se pueda modificar
        jtfPalabraPasada.setEnabled(false);
        return jtfPalabraPasada;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //Para hacerlo paso a paso vamos a crear unas variables tipo
        //string para almacenamiento temporal
        String palabra = "";
 
        //si precionamos nuestro botón ejecutará una acción
        if (e.getSource() == boton){
            //Obtenemos el valor del campo de texto
            palabra = jtfPalabra.getText();
            //convertimos a mayúsculas
            palabra = palabra.toUpperCase();
            //asignamos al otro jtextfield (el que no se puede editar)
            jtfPalabraPasada.setText(palabra);
            //limpiamos el campo en el que escribimos la palabra
            jtfPalabra.setText(""); 
        }
    } 
}

Y como siempre la documentación de java con respecto a los temas tratados:
Botones: http://docs.oracle.com/javase/8/docs/api/javax/swing/JButton.html
ActionListener: http://docs.oracle.com/javase/8/docs/api/java/awt/event/ActionListener.html

Conclusiones

Los botones y las acciones que se realizan al presionarlos son elementos que se utilizan en la gran mayoría de aplicaciones hoy en día.

El ActionListener es una interface que se implementa para poder asignarle una acción a un elemento del JFrame.

Java: Swing: JTextField

Francisco 8:54 gui , input , java , jframe , jtextfield , por: Francisco Vargas , programación java , swing , textfield No hay comentarios :

Introducción

Los JTextField son campos donde el usuario puede ingresar información que se le solicite, por ejemplo en un formulario para registrarse a algún servicio. En esta entrada aprenderemos a como crear este elemento.

Desarrollo

Primero importar la librería necesaria:

import javax.swing.JTextField;

Luego tenemos nuestro método para un JTextField:

//Crea un campo de texto
 private JTextField verTextField() {
  //inicializamos el campo
  JTextField ejemplo = new JTextField();
  //le damos coordenadas
  ejemplo.setBounds(10, 10, 100, 20);
  return ejemplo;
 }

Como pueden ver el método para crear uno de estos es muy sencillo, lógicamente tiene otras propiedades pero como lo más básico es este que coloqué.

Y bueno mi clase quedaría así:

import javax.swing.JFrame;
import javax.swing.JTextField;

@SuppressWarnings("serial")
public class JFrames extends JFrame {

 public JFrames() {
  add(verTextField());
  inicializador();
 }

 private void inicializador() {
  setSize(800, 600);
  setLayout(null);
  setTitle("Mi ventana");
  setLocationRelativeTo(null);
  setVisible(true);
  setResizable(false);
  setDefaultCloseOperation(EXIT_ON_CLOSE);
 }

 //Crea un campo de texto
 private JTextField verTextField() {
  //inicializamos el campo
  JTextField ejemplo = new JTextField();
  //le damos coordenadas
  ejemplo.setBounds(10, 10, 100, 20);
  return ejemplo;
 }
}

Documentación de JTextField: http://docs.oracle.com/javase/8/docs/api/javax/swing/JTextField.html

Conclusiones

Los JTextField, son elementos básicos y de gran utilidad en las aplicaciones que requieran formularios y demás. En este ejemplo fué algo muy básico, sin embargo, es suficiente para entender como crearlo, la funcionalidad varía entre una y otra aplicación.

martes, 29 de noviembre de 2011

Java: JOptionPane: Menú desplegable

Francisco 9:57 input , inputDialog , java , jcombox , joptionpane , por: Francisco Vargas , programación java , showInputDialog 7 comentarios :

Introducción

Muchas veces, se necesitan poner datos por defecto y que el usuario simplemente seleccione, por ejemplo: los días de la semana, meses, país, entre otros. En esta entrada aprenderemos a hacer un combo box o menú desplegable con JOptionPane.

Desarrollo

Ante todo se debe importar el JOptionPane, con la siguiente línea:

import javax.swing.JOptionPane;

Ya importado procedemos a crear un vector que va a contener los textos de nuestro menú.

Object [] colores ={"rojo","negro","amarillo","azul","majenta"};

La inicialización se trabaja como cualquier otra:

- El tipo de dato String u Object, respectivamente.

- El nombre de nuestro vector, que llamé Colores.

- La inicialización del texto de nuestro menú, estos van entre comillas, separados por comas y finalmente encerrados entre llaves.

Ahora ya que inicializamos nuestro vector, creamos nuestra ventana con el menú desplegable con estas líneas de código.

Object opcion = JOptionPane.showInputDialog(null,"Selecciona un color", "Elegir",JOptionPane.QUESTION_MESSAGE,null,colores, colores[0]);

Las partes que componen estas dos líneas de código son las siguientes:

- Creamos una variable de tipo Object debido a que lo que esto retorna es un objeto que va a valer el texto que se haya elegido.

- Sentencia JOptionPane.showInputDialog, la normal a la hora de pedir datos al usuario.

- null, este caso no ocupa nada.

- Mensaje que vamos a mostrar en este caso "Selecciona un color".

- Titulo de nuestra ventana, yo le puse Elegir.

- Tipo de mensaje, para saber los tipos de mensaje ver acá:

- null, para icono predeterminado o el nombre de nuestra imagen para uso personalizado, para colocar un imagen personalizada ver acá:
- nombre de nuestro vector inicializado.
- Opción que se quiere que este predeterminada en nuestra ventana, el cero se puede cambiar por cualquier número mientras este en el rango del vector, recordar que el primero es cero, luego viene el uno y así sucesivamente.

Cuando presionamos cancelar o equis este devuelve un null.

Finalmente nuestra ventana se vería así:

Y con el menú desplegado se vería así:

Conclusiones

Esta opción es muy sencilla de usar, cuando se requiere que el usuario seleccione algún valor predeterminado.

Puede ser muy útil para no generar toda una ventana solo por un menú desplegable o cambiar de ventana por la misma razón.

lunes, 28 de noviembre de 2011

Java: JOptionPane: Botones personalizados.

Francisco 20:04 confirm dialog , input , java , joptionpane , optionDialog , por: Francisco Vargas , programación java , ventanas java 6 comentarios :

Introducción

Muchas veces necesitamos que nuestros cuadros de diálogo tengan texto personalizados y no los predeterminados de Java, por ese motivo en esta entrada se explicará como hacerlo de una manera fácil y rápida.

Desarrollo

Para crear nuestros botones personalizados (en cuanto a texto se refiere), primero tenemos que importar el JOptionPane así:

import javax.swing.JOptionPane;

Luego que lo importamos procedemos a hacer un vector String (también se puede usar un Object para quien lo prefiere) que contendrá nuestros textos de los botones, lo creamos de la siguiente manera:

String [] botones = { " boton uno", " boton dos", "boton N" };

Object [] botones = { " boton uno", " boton dos", "boton N" };

Partes que conforman la inicializacion del vector:
- El tipo de dato String u Object, en el primero y segundo caso respectivamente..
- El nombre de nuestro vector, que yo llamé botones.
- La inicialización del texto de nuestros botones, estos van entre comillas, separados por comas y finalmente encerrados entre llaves.
- Resaltar que el Object acá funciona como un String.

Luego de declarar nuestros nombres de botones procedemos a crear la ventana de diálogo con la siguiente sentencia:

int variable = JOptionPane.showOptionDialog (null, " Quieres bailar esta noche?", "Cita", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE, null/*icono*/, botones, botones[0]);

Ahora se desglosará estas lineas de código:

- Creación de una variable tipo entero que recibirá nuestra opción seleccionada

- Sentencia JOptionPane.showOptionDialog

- null, en este caso no precisa poner nada

- El texto a mostrar ( Quieres bailar esta noches?)

- Titulo de nuestra ventana ( Cita )

- Tipo de botones de confirmación aunque no importa mucho cual pongan, acá se explican mejor los tipos.

- Tipo de mensaje, se explica mejor acá.

- EL icono si vamos a poner uno personalizado sino el null para decir que seleccione el del tipo de mensaje, para colocar uno personalizado click acá.

- El nombre de nuestro vector inicializado.
- La posición en los botones que queremos que nuestra ventana marque como predeterminado ( 0 , 1 , ... , - 1)

Nuestra ventana se vería así una vez terminada:

Como pueden observar la posición donde está el "boton uno", esta remarcada y es diferente a los demás bonotes eso sucede porque es el predeterminado, esto se elije cuando hace la escritura del código para estas ventanas ( ver el desglose del código punto 10 ).

Conclusiones

Java proporciona maneras muy fáciles para la creación de ventanas con JOptionPane, además de maneras simples para personalizarlas.

JOptionPane es una librería muy útil para mensajes rápidos y sin mucha complejidad.

domingo, 27 de noviembre de 2011

Java: JOptionPane: Colocar iconos personalizados

Francisco 17:18 confirm dialog , iconos , iconos personalizados , input , java , jcombox , joptionpane , joptionpane confirm , optionDialog , por: Francisco Vargas , programación java , showConfirmDialog , ventanas java 24 comentarios :

Introducción

Cuando se programa cada quién quiere darle su "toque" personal a su aplicación, en entradas anteriores hemos visto como utilizar ventanas de diálogo de la libería de java JOptionPane, hoy veremos como personalizar el icono de estas con alguna imagen que nosotros queramos utilizar.

Desarrollo

Para colocar iconos, ya sean animados o no, en nuestros ventanas de JOptionPane (algunas no lo aceptan), se importan las librerías Icon e ImageIcon, las líneas para esto se presentan a continuación:

import javax.swing.Icon;
import javax.swing.ImageIcon;

Una vez que los importamos procedemos a inicializar nuestro icono:

Icon icono = new ImageIcon(getClass().getResource("ruta local de la imagen"));

La sentencia anterior se descompone en los siguientes elementos:
- Nuestro Icon que lo importamos anteriormente
- el nombre de nuestro objeto
- new, para la creación de nuevo objeto en la instancia
- ImageIcon que lo habíamos importado anteriormente

- la ruta completa de la imagen, esta va entre comillas y con la extensión de la imagen: gift, png entre otras, esto es para que el programa sepa donde ir a buscar la imagen.

Luego para utilizar a nuestra imagen en diversos tipos de ventanas se utilizaría el siguiente código:

showMessageDialog:

JOptionPane.showMessageDialog(null," Aprendiendo a poner imagenes ", "Imagen Java", JOptionPane.PLAIN_MESSAGE, icono);

showOptionDialog:

JOptionPane.showOptionDialog(null, "¿Queres salir a Bailar esta Noche?","Sita", JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.WARNING_MESSAGE, icono, botones, botones[0]);

showInputDialog (JCombox):

Object opcion = JOptionPane.showInputDialog(null,"Selecciona un color", "Elegir",JOptionPane.QUESTION_MESSAGE, icono ,colores, colores[0]);

showConfirmDialog:

JOptionPane.showConfirmDialog(null, "Realmente desea salir de Hola Swing?", "Confirmar salida", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, icono);

En el caso del JCombox y en el caso del OptionDialog si no se va a poner un icono se coloca un null.

Conclusiones

Colocar iconos personalizados es sumamente sencillo y puede dar un aspecto más profesional a nuestra aplicación.

No es bueno colocar imágenes muy grandes debido a que la ventana en sí es pequeña, ni tampoco es bueno colocar imágenes que distraigan al usuario (como animaciones y demás).

Java: JOptionPane: Ventanas de confirmación (ConfirmDialog)

Francisco 16:18 confirm dialog , input , java , joptionpane , joptionpane confirm , por: Francisco Vargas , programación java , showConfirmDialog 5 comentarios :

Introducción

Muchas veces necesitamos mensajes de confirmación, estos mensajes son ventanas de diálogo que, por ejemplo, nos piden que aceptemos o cancelemos una acción o evento que se va a realizar.

En esta entrada veremos como gracias a la librería de JOptionPane, existe una manera fácil y rápida de hacer esta ventanas de confirmación.

Desarrollo

Lo primero es importar la librería de JOptionPane.

import javax.swing.JOptionPane;

En el siguiente código, se aprecia la manera de crear una ventana de confirmDialog de JOptionPane:

JOptionPane.showConfirmDialog(null, "Realmente desea salir de Hola Swing?", "Confirmar salida", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE);

Las partes que la sentencia anterior son:
- null, por lo general se pone.
- Realmente desea salir de Hola Swing?, este es el mensaje que se desea mostrar.
- Confirmar salida, es el titulo de la ventana.
- JOptionPane.YES_NO_OPTION, este es el tipo de botones que van a aparecer, para esta parte de la sentencia existen los siguientes tipos:

- YES_NO_OPTION

- DEFAULT_OPTION o CLOSED_OPTION

- YES_NO_CANCEL_OPTION

- OK_CANCEL_OPTION, muestra esta ventana:

- por ultimo viene el tipo de mensaje que va a ser o el tipo de icono que trae java para las ventanas, son los mismos que el showMessageDialog y el showInputDialog y se les explica mejor acá.

Si queremos poner un icono personalizado se coloca al final el nombre de nuestro icono, para conocer como hacerlo da click aquí.

Todas estas ventana de confirmación retornan un valor numérico correspondiente a lo opción que se seleccionó, la primera posición va a ser cero, la segunda uno y así sucesivamente, por ejemplo, si en la ventana de YES_NO_OPTION, seleccionamos que Sí, este lo que nos devuelve es un cero, si seleccionamos que No, nos estaría devolviendo un uno, si seleccionamos la equis devolverá un menos uno ( -1 ).

Conclusiones

Estas ventanas de confirmación pueden ser de gran utilidad en nuestras aplicaciones, por ejemplo si se desea eliminar un usuario de la base de datos se puede confirmar con una de estas ventanas.

Al igual que messageDialog e inputDialog, cuenta con una serie de iconos predeterminados que pueden ser utilizados para que que la ventana vaya más acorde a la acción que se realiza, por ejemplo un error, una pregunta, una advertencia, entre otros.

sábado, 26 de noviembre de 2011

Java: JOptionPane: MessageDialog e InputDialog

Francisco 21:38 input , java , joptionpane , message , por: Francisco Vargas , programación java , ventanas java No hay comentarios :

Introducción

Cuando ya queremos dejar la consola de java a un lado y empezar a generar una interfaz de usuario más agradable, lo primero que nos encontramos son con lo cuadros de diálogo de la librería JOptionPane de java.

En esta entrada entenderemos el funcionamiento de dos de estos componentes, el messageDialog y el inputDialog.

Desarrollo

Para utilizar estos componentes de se debe importar la librería correspondiente, lo cual se enseña en el siguiente código:

import javax.swing.JOptionPane;

Ahora sí, aprenderemos a usar lo componentes iniciando con el messageDialog, con el siguiente código se genera un mensaje a mostrar al usuario.

JOptionPane.showMessageDialog(null, "Hola mundo", "Mensaje", JOptionPane.INFORMATION_MESSAGE, icono);

Las partes que lo componen son:

- null, que por lo general siempre se pone.
- "Hola mundo", ese es el texto o que queremos mostrar al usuario.
- "Mensaje", es el encabezado de nuestra ventana por decirlo de otra manera el titulo
- El tipo de icono que queremos que ponga la ventana en caso que no le pongamos una imagen, si se desea utilizar una predeterminada, existen las siguientes
- INFORMATION_MESSAGE, coloca un símbolo de admiración encerrado en un circulo.

- QUESTION_MESSAGE, coloca un símbolo de pregunta

- WARNING_MESSAGE, coloca un símbolo de admiración en un triangulo

- ERROR_MESSAGE, coloca una equis roja

- PLAIN_MESSAGE, no coloca ningún símbolo.

- icono, este es opcional, si no se quiere que lleve ningún icono personalizado simplemente no se coloca. Si quieres poner un icono mira en el siguiente link Iconos personalizados.

La ventana se miraría así:

Y con esto ya aprendimos como utilizar el componente messageDialog.

Los inputDialog se utilizan para que el usuario introduzca algún valor, para luego utilizarlo en alguna función de nuestra aplicación, en este caso lo que se ingrese, sea letras, números, caracteres especiales, siempre van a ser tratados como una cadena.

Para utilizarlos se coloca el siguiente código:

String introducido = JOptionPane.showInputDialog(null,"Ingresa tu nombre","Informacion", JOptionPane.QUESTION_MESSAGE);

Y lleva los mismos componentes que los messageDialog, por tanto no se volverán a explicar, lo único diferente es que se le asigna a una variable el valor que retorne el inputDialog.
Esta ventana se vería así:

Conclusiones

Estas ventanas con una manera de irse introduciendo a la parte de interfaz de usuario con la que cuenta java, además que pueden ser muy útiles dentro de aplicaciones grandes.

Por otro lado, brindan una mayor calidad a los trabajos realizados y no consumen demasiados recursos ni son difíciles de programar.

Suscribirse a: Entradas ( Atom )

Noticias

domingo, 20 de enero de 2013

Java: Swing: JFormattedTextField y MaskFormatter

sábado, 19 de enero de 2013

Java: Swing: JPasswordField

viernes, 18 de enero de 2013

Java: Swing: JTextArea y JScrollPane

jueves, 6 de diciembre de 2012

Java: Swing: AWT: JButton y ActionListener

Java: Swing: JTextField

martes, 29 de noviembre de 2011

Java: JOptionPane: Menú desplegable

lunes, 28 de noviembre de 2011

Java: JOptionPane: Botones personalizados.

domingo, 27 de noviembre de 2011

Java: JOptionPane: Colocar iconos personalizados

Java: JOptionPane: Ventanas de confirmación (ConfirmDialog)

sábado, 26 de noviembre de 2011

Java: JOptionPane: MessageDialog e InputDialog

Populares

Seguidores

Envía tú opinión, comentario o sugerencia.

domingo, 20 de enero de 2013

sábado, 19 de enero de 2013

viernes, 18 de enero de 2013

jueves, 6 de diciembre de 2012

martes, 29 de noviembre de 2011

lunes, 28 de noviembre de 2011

domingo, 27 de noviembre de 2011

sábado, 26 de noviembre de 2011

Populares

Síguenos por RSS

Seguidores

Envía tú opinión, comentario o sugerencia.