Uso básico de elementos Swing con NetBeans – 12 – Uso básico de JTextPane y JPanel, visualizar texto con estilo y objetos.

En esta guía podremos ver la utilización de “JTextPane” o Panel de Texto. Este es un componente al cual se le puede aplicar estilos de texto además de agregar otros componentes como botones o imágenes como ya veremos.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJTextPane). Como se ve en la imagen, agregamos un JPanel al cual le especificamos un borde con texto, esto se consigue modificando la propiedad “border” e indicando que sea “Borde con título”; dentro del JPanel agregamos nuestro JTextPane. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Para este proyecto creamos tres métodos específicos, la primera que arrancará al crear el formulario y pondrá en marcha los demás métodos, el segundo maneja los estilos que utilizaremos y el último se utilizar para cargar imágenes desde archivos.
Código Java
    //Método que se ejecuta al crear el formulario
private void inicio(){
//Array de String para muestras de estilo.
String[] textos = {"Codigo Java - (Texto Normal)." + "\n",
"Utilizando Swing - (Texto Cursiva)." + "\n",
"Programando con Java - (Texto Negrita)" + "\n",
"Utilizando JTextPane - (Texto pequeño)" + "\n",
"Utilizando Style. (Texto grande)" + "\n",
"JTextPane con soporte para insertar objetos." + "\n",
" " + "\n",
"Soporte insertar iconos." + "\n",
" " + "\n",
"JTextPane permite utilizar StyledEditorKit y StyledDocument, " +
"también interactua con diferentes objetos."
};
//Array de String para el nombre de cada estilo "Style"
String[] iniText = {
"normal","cursiva","negrita","peque","grande","boton","normal","icono","normal","normal"
};
//Cramos una variable tipo StyledDocument que manejara los estilos.
StyledDocument sd = jtp.getStyledDocument();
//Método que se crea más abajo, le pasamos como argumento nuestro StyledDocument.
styleDoc(sd);
//Control de errores
try {
//Método insertString(int offset, String str, AttributeSet a)
//Primer argumento - Posición de inserción. Segundo - String que se va insertar.
//Atributo asociado al String ingresado. En este caso los estilos.
for (int i = 0; i < iniText.length; i++) {
sd.insertString(sd.getLength(), textos[i], sd.getStyle(iniText[i]));
}
} catch (Exception e) {
System.err.println("error " + e);
}
}
//Inicialización de los diferentes estilos a utilizar.
//Hay diferentes propiedades, pero fáciles de entender.
private void styleDoc(StyledDocument sd){
Style def = StyleContext.getDefaultStyleContext().
getStyle(StyleContext.DEFAULT_STYLE);

Style nm = sd.addStyle("normal", def);
StyleConstants.setFontFamily(def, "SansSerif");

Style s = sd.addStyle("cursiva", nm);
StyleConstants.setItalic(s, true);

s = sd.addStyle("negrita", nm);
StyleConstants.setBold(s, true);

s = sd.addStyle("peque", nm);
StyleConstants.setFontSize(s, 10);

s = sd.addStyle("grande", nm);
StyleConstants.setFontSize(s, 16);

s = sd.addStyle("icono", nm);
//Tomar en cuentra la imagen que utilizaremos y su ubicación
StyleConstants.setAlignment(s, StyleConstants.ALIGN_CENTER);
ImageIcon compu = createImageIcon("/com/swing/basic/img/Computer.png",
"Icono PNG - Coputadora");
if (compu != null) {
StyleConstants.setIcon(s, compu);
}
//Icono para nuestro botón
s = sd.addStyle("boton", nm);
StyleConstants.setAlignment(s, StyleConstants.ALIGN_CENTER);
ImageIcon searchIcon = createImageIcon("/com/swing/basic/img/Search.png",
"Icono de búsqueda");
JButton button = new JButton("Buscar");
if (searchIcon != null) {
button.setIcon(searchIcon);
} else {
button.setText("Search");
}
button.setCursor(Cursor.getDefaultCursor());
button.setMargin(new Insets(0,0,0,0));
StyleConstants.setComponent(s, button);
}

//Método que nos permitira cargar una imagen como icono pasándole una url
protected static ImageIcon createImageIcon(String path,String des) {
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 la imagen siguiente vemos las importaciones que necesitamos, nuestro paquete si la utilizamos y el método que llámanos desde el constructor.
Lista de Importaciones.
Código Java
import java.awt.Cursor;
import java.awt.Insets;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.text.Style;//Importaciones necesarias
import javax.swing.text.StyleConstants;
import javax.swing.text.StyleContext;
import javax.swing.text.StyledDocument;
En este caso no utilizaremos eventos, por tanto ya podremos ejecutar el formulario creado. (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 – 11 – Uso básico de JEditorPane y JPanel, visualizar documento HTML.

En esta oportunidad veremos el uso que se le puede dar a un “JEditorPane”, precisamente la utilizaremos para abrir un documento HTML. Es un elemento útil para la apertura de documentos en texto plano o del tipo HTML. El ejemplo es sencillo, agregaremos nuestro “JEditorPane” dentro de un panel junto con dos botones, al apretar cada botón se podrá visualizar un ejemplo de documento HTML. Los documentos HTML deberán estar dentro del mismo paquete que nuestro formulario.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJEditorPane). Como se ve en la imagen, agregamos un JPanel al cual le especificamos un borde con texto, esto se consigue modificando la propiedad “border” e indicando que sea “Borde con título”; dentro del JPanel agregamos nuestro JEditorPane. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
En este caso creamos dos métodos similares, cada una se relacionará con un documento HTML distinto. Se agregan comentario para conocer el funcionamiento de cada línea de código.
Código Java
    private void inicio(){
//jep es el nombre de variable de nuesto JEditorPane.
//indicamos que no sea editable.
jep.setEditable(false);
//Utilizamos el método siguiente para referenciar nuestro HTML
//Para ejemplo se puede usar cualquier documento HTML, tomar en cuenta el nombre.
java.net.URL urlHtm = UsoJEditorPane.class.getResource("Welcome.html");
//Se ejecuta si no se retorna vacio.
if (urlHtm != null){
//Control de posibles errores de lectura.
try {
//Método para cargar el documento HTML al JEditorPane
jep.setPage(urlHtm);
} catch (IOException e) {
System.err.println("No se puede leer la URL: " + urlHtm + e);
}
}
//Se ejecuta en caso que retorne vacio.
else{
JOptionPane.showMessageDialog(null, "No se pudo cargar la url...");
}

}
//Método similar a la anterior, solo varia el nombre del documento HTML
private void inicioDos(){
jep.setEditable(false);
java.net.URL urlHtm = UsoJEditorPane.class.getResource("bookmarks.html");
if (urlHtm != null){
try {
jep.setPage(urlHtm);
} catch (IOException e) {
System.err.println("No se puede leer la URL: " + urlHtm + e);
}
}
else{
JOptionPane.showMessageDialog(null, "No se pudo cargar la url...");
}

}
En la imagen siguiente vemos las importaciones que necesitamos, nuestro paquete si la utilizamos y el método que llámanos desde el constructor.
El paso siguiente es establece eventos para los botones, esto les dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de elementos es el ActionPerformed. Si ya vieron alguna guía anterior a esta podrán saber cómo se agrega un evento, la ubicación habitual tanto para la lista de eventos, como también los métodos que hayamos creado al igual de la forma en que se implementan estos eventos y llamadas a métodos.
Código Java
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
inicio();
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
inicioDos();
}
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 – 10 – Uso básico de JTextArea y JPanel. Ej. 01.

En esta guía veremos la utilización del “JTextArea” o área de texto como queramos llamarla, su función es simple, mostrar o permitir la edición de texto largo. En este ejemplo agregamos un texto desde código; le especificamos tipo de letra, formato y tamaño. También indicamos que el Área de Texto ajuste el texto ingresado de forma automática a su tamaño. El JPanel sirve como contenedor de objetos que tienen su propia distribución lo cual permite una gran independencia; en guías anteriores vimos varios ejemplos de su uso.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJTextArea). Como se ve en la imagen, agregamos un JPanel al cual le especificamos un borde con texto, esto se consigue modificando la propiedad “border” e indicando que sea “Borde con título”; dentro del JPanel agregamos nuestro JTextArea . En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
En este proyecto creamos un único método, el cual se llama desde el constructor para que se ejecute al crearse el formulario, no utilizamos eventos.
Código Java
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, 15));
//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.");
}
En la imagen siguiente vemos las importaciones que necesitamos, nuestro paquete si la utilizamos y el método que llámanos desde el constructor.
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 – 09 – Uso básico de JOptionPane con eventos. Ej. 04.

Otro elemento del JOptionPane es el showInputDialog, la cual permitirá al usuario ingresar datos o seleccionarla de una lista de opciones, dependiendo del caso. Hay dos tipos principales, la primera que nos permite crear un “Array” de objetos, la cual contendrá las opciones que el usuario podrá seleccionar, estos elementos estarán dentro de un combo. La otra solamente muestra un campo de texto en el que el usuario podrá ingresar texto.
Diseñamos un formulario utilizando un JFrame (Nombre del formulario UsoJOptionPane4). En el ejemplo utilizaremos una lista seleccionable de forma individual utilizando JRadioButton, un botón personalizado para ejecutar nuestra selección y un campo de texto JTextField que reflejará nuestra selección. Dependiendo de nuestra selección se ejecutará un modelo de showInputDialog, cada modelo tiene su utilidad en diferentes situaciones. En la imagen siguiente vemos el diseño de nuestro formulario, cada elemento tiene un nombre de variable como se especifica en la imagen, tomar en cuenta este punto ya que es necesario para referenciar los objetos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. (clic sobre la imagen para ampliar)
Creamos los métodos necesarios 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
    private void inicio(){
//Agrupamos nuestros JRadioButton creados.
ButtonGroup group = new ButtonGroup();
group.add(jRB1);
group.add(jRB2);
//Incicamos que jRB1 este seleccionado de arranque.
jRB1.setSelected(true);
}

private void ver(){
//Comprobamos cuál de las opciones esta seleccionada.
if(jRB1.isSelected()){
//Creamos un Array de objetos para nuestras opciones.
Object[] opt = {"Mercurio", "Venus", "Tierra","Marte","Jupiter"};
//El showInputDialog nos retornará un String.
//Utilizamos nuestra variable de clase creada "String n".
//Esta variable se crea fuera del constructor y cualquier método.
s = (String)JOptionPane.showInputDialog(
null,
"¿De qué planeta eres?",
"Pregunta",
JOptionPane.PLAIN_MESSAGE,
null,
opt,
"Tierra");

//Comprobamos que se seleccionen datos...
if ((s != null) && (s.length() > 0)) {
//Obtenemos el valor de nuestro showInputDialog
rp.setText("Soy del planeta " + s);
}
}
if(jRB2.isSelected()){
s = (String)JOptionPane.showInputDialog(
null,
"¿De qué planeta eres?",
"Pregunta",
JOptionPane.PLAIN_MESSAGE
);

//Comprobamos que se escriban datos...
if ((s != null) && (s.length() > 0)) {
rp.setText("Soy del planeta " + s);
}
}

}
Antes de continuar veremos que método se llama desde el constructor, variables de clase creadas y las importaciones necesarias.
El paso siguiente es establece un evento para nuestro botón, esto le dará la funcionalidad que necesitamos. El evento que normalmente se utiliza para este tipo de elementos es el ActionPerformed. Si ya vieron alguna guía anterior a esta, podrán saber la ubicación habitual tanto para la lista de eventos, como también los métodos que hayamos creado al igual de la forma en que se implementan estos eventos y llamadas a métodos.
Código Java
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
ver();
}
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)