WordPress

Mozilla Firefox: el zorro cada vez más rápido

2013-01-11 - Categorías: General
Cuanto más leo más me sorprende su historia y rumbo que llevan los desarrollos, tanto de la Fundación Mozilla, como en concreto, de su caballo de batalla, el Mozilla Firefox. Hoy he actualizado a la versión 18 del Firefox y me he puesto manos a la obra para éste post. Desde el Netscape, rivalizando con el Internet Explorer y con Chrome también, viene a ser un caso de estudio y una opción nada desechable.

En algunos desarrollos, tratando de seguir al 100% los estándares del Consorcio W3 que dirigen el cotarro, me he llegado a encontrar con problemas a la hora de visualizar o con el funcionamiento de la interfaz por problemas de compatibilidad entre navegadores. Según el que utilizaba cambiaba su funcionamiento. Donde se alineaba a la izquierda o derecha en una tabla con columnas agrupadas, ahora se alineaba al centro en otro navegador; aparte de los clásicos problemas con el vídeo y sonido al usar HTML4, resulta que los navegadores toman por defecto unos valores u otros. 
Total que acabo instalándome los principales navegadores para hacer las pruebas:
Safari
…en orden de uso. Cabe indicar que si usas Windows se complica encontrar la versión de Safari, pero al final buscando desde Google que todo lo encuentra me descargo la versión 5.1.7. Cuál será la razón por la que Apple no nos da el Safari con fácil acceso desde su web.
Leyendo un poco sobre Firefox resulta que viene a ser el único navegador de los principales, que no está desarrollado ni soportado por una empresa con ánimo de lucro. Ésto lo hace cada vez más interesante, sobre todo para mí que pienso que las soluciones gratuitas, con código fuente libre, son una de las opciones más interesantes, no sólo por su coste cero, sino también porque vienen siendo soluciones cada vez más probadas y con gran cantidad de usuarios. Será porque funcionan realmente bien.
Haciendo un repaso a lo que ha sido 2012 para Mozilla:
Se han añadido todo tipo de compatibilidades. Y después de haberse quedado un poco retrasado en cuestión de velocidad de funcionamiento, comparándolo con los demás navegadores… ahora viene cogiendo carrerilla y con la versión 18 destaca su velocidad, mejorada una vez más. Compatibilidad con tabletas. Funciones de programación avanzada con Javascript, como el BananaBread. La inclusión del IonMonkey para compilar Just-In-Time las aplicaciones Javascript y correr a toda velocidad…
En fin otra joya de la informática, que al ser desarrollado sin ánimo de lucro, no tenía otra opción que recomendarlo. Así que si no te has instalado el Firefox, ya estás tardando… xD
Si tiene tiempo, no se deje por probar el BananaBread.

Mapas conceptuales y construcción del conocimiento con Freeplane

2013-01-06 - Categorías: General
Ya han venido los Reyes Majos, y os han dejado virus para los que habeis sido malos. Y para los que habeis sido buenos os han dejado un buen programa que curiosear, el Freeplane. A fecha de hoy la versión que tengo es al 1.2.20 del Freeplane, lo he probado con el JRE 7 en un Windows 7.
Aún con mi edad sigo estudiando, sobre todo en la informática si no te actualizas frecuentemente te quedas obsoleto, desfasado, finito… He estado preparando unos exámenes en éstos días y he estado complicándome la vida un poco en buscar un programa que me sirva para organizar mis ideas. No soy vago a la hora de coger papel y lápiz para hacerme esquemas o resolver los problemas sobre el papel antes de pasarlos a limpio. Pero con todo lo que avanza las TI (Tecnologías de la Información), vienen siendo útil todos éstos programas que nos hacen la vida un poco más fácil.
Como buen fan del software GNU, del gratuito, o de los programas con licencias o versiones gratuitas. Les presento el Freeplane para el que no lo conozca. Nació del archiconocido FreeMind, que a fecha de hoy anda un poco desactualizado. Viene a ser la continuación del FreeMind, cuyos códigos fuentes iniciales son los propios del FreeMind, pero han ido añadiendo más y más funciones como exportar en formato PDF, en HTML, en imágenes tanto vectoriales (SVG) como normales (JPG, PNG…), etcétera. Nos permite cambiar los estilos de cada nodo, las formas de las llaves, las flechas, añadir iconos a los nodos, podemos poner textos grandes en un nodo, o incluso enlazar a páginas web o archivos externos desde nuestros esquemas.
Como dice en su Acerca de… es un programa libre para creación de mapas conceptuales y construcción del conocimiento. Su licencia es GNU, con lo que se puede usar para trabajar o de forma personal sin coste alguno. Rivaliza con el XMind que viene siendo también un referente en éste campo, también es multiplataforma, disponible para Windows, Linux y Mac, está hecho en Java y funciona de maravilla todo lo que he probado.
Tiene innumerables opciones. El ejemplo que nos enseña el programa nos puede mostrar en líneas generales para qué lo podemos usar:
Yo lo tengo en castellano, haciendo click en el menú Ayuda->Documentación te saldrá un esquema como el de la imagen de abajo donde se puede aprender a usar todo lo que se necesite llegado el momento. Hasta tiene una opción en Ayuda->Pedir una Característica nueva que me sorprende que exista. En fin, toda una joya de la informática.

Para instalártelo, leer más sobre él o lo que sea:

http://freeplane.sourceforge.net/

Un saludo!


Java Swing 6: Los componentes básicos

2013-01-01 - Categorías: Java / Java Swing
¡¡Feliz Año Nuevo!!
Hace ya un tiempo que no escribo, así que voy a tratar de que éste año sea mejor que el anterior y comienzo por avanzar en mis investigaciones con Java, así que os dejo éste post por si a alguien le sirve…
Sigo escudriñando los componentes de Swing, a ver cómo son los más simples, que no faltan en cualquier programa. Si lo que buscas es aprender rápido lo necesario para usarlos, éste es tu post xD He utilizado la versión 7 del JDK y Eclipse Juno.

Si vas a seguir éste tutorial desde cero, lo suyo sería que hicieras un nuevo proyecto, crearas un nuevo JFrame con el generador de código de Eclipse y fueras al Swing Designer. Es decir, entras al modo de diseño para editarlo intentando hacer algo como la imagen de arriba, usando las herramientas que ves aquí abajo:
Queda cada vez menos componentes de los presentados en el post ‘Java Swing 1’. Así que vamos al grano.

JLabel

Es una etiqueta. Con el diseñador ponemos el texto en el valor text, se puede cambiar en el código con la función nombreEtiqueta.setText(«Cadena»); aunque en el código fuente del ejemplo se ha puesto el texto en el constructor al usar JLabel lblEtiqueta = new JLabel(«Etiqueta»);

JTextField

Es una caja de texto. Se usa de igual manera que una etiqueta a la hora de programar o diseñar la interfaz, pero su diferencia con la etiqueta es que el usuario puede cambiar el contenido de la caja escribiendo en ella, con la etiqueta no puede hacerlo. Tendremos también la función nombre.setText(«Cadena»); anterior. Con variable = txtCajaDeTexto.getText(); podemos tener el contenido de la caja de texto en la variable. Éste componente sólo admite una línea.

JComboBox

Significa cuadro combinado, como se puede ver en el ejemplo, es una lista de elementos desplegable donde el usuario puede elegir entre las opciones que le demos. La elección la podemos tener con a función variable = comboBox.getSelectedIndex();

JButton

Es un simple botón, con el que al hacer click programamos lo que necesitemos. En el ejemplo se muestra un diálogo simple con:
btnBotn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
JOptionPane.showMessageDialog(frame, "Ésto es un botón simple.");
}
});
Tambien se puede cambiar el texto con el método .setText(cadena);

JCheckBox

Las casillas de verificación, que en ejemplo hay varias. Las podemos usar de una en una, o en grupo, poniéndolas dentro de un grupo, de manera que cuando se selecciona una las demás se des-seleccionan automáticamente.
Para saber si un JCheckBox está ‘checkeado’ debemos usar la función nombreCheckBox.isSelected(); que devolverá true o false.

JRadioButton

Los botones de radio, JRadioButton para los amigos, se usan de igual manera que los JCheckBox. La diferencia es que tradicionalmente se usan para elegir una entre varias opciones, mientras que los JCheckBox normalmente se usan para elegir en varias opciones si se desean o no, sin que unas excluyan a las otras. Pero en realidad se pueden usar igual dependiendo de si los agrupamos o no. En el ejemplo se han agrupado los botones de radio con el código:
ButtonGroup radioGroup = new ButtonGroup();
radioGroup.add(rdbtn1);
radioGroup.add(rdbtn2);
Ésto de aquí arriba lo que hace es que si elegimos el rdbtn1 entonces el rdbtn2 se des-selecciona y viceversa. Así de simple ocurre si también agrupamos los JCheckBox, es decir, en los elementos de un grupo sólo estará seleccionado uno.

JToggleButton

Llamado botón de activación, se usa de nuevo igual que un JCheckBox o un JRadioButton, creo que sobran las explicaciones aquí porque tenemos las mismas funciones y comportamientos, sólo cambia su apariencia por la forma de un botón que se mantiene pulsado cuando está activado.

JTextArea

Es un área de texto de varias líneas, se usa igual que el JTextField pero con la diferencia de que admite varias líneas. Podemos establecer el número de líneas con nombre.setRows(n); y tenemos también las funciones nombre.getText() y nombre.setText(). En el ejemplo se establece el texto de la forma:
txtrAreaDeTexto.setText("Arearnderntexto.");
Podemos ver que con rn se produce un salto de línea. Ésto nos puede servir en muchos otros sitios para hacer un salto de línea, así que de memoria a aprendérselo.

JPasswordField

Es un área de contraseña, es decir, un área de texto pero con la diferencia de que los caracteres no se muestran para que el usuario del ordenador de al lado no pueda leer las contraseñas que pones en tu pantalla. La diferencia con un JTextField es que para conseguir la cadena de caracteres que ha puesto el usuario hay que usar la función nombre.getPassword();

JSpinner

Ésto es una caja donde con un par de botones cambiamos los valores. Traducido se llama ‘hilandero’, otra palabra nueva para mi vocabulario, nunca la habia oido ni leido. Por defecto se configura para que recorra los enteros, si le das a la flecha arriba suma uno al valor que haya 1, 2, 3, 4, 5… Si le das abajo resta de la forma 3, 2, 1, 0, -1, -2, -3…
Con spinner.getValue(); obtenemos el valor elegido. Va a devolver un objeto del tipo correspondiente, puede ser una fecha o una lista de elementos.
Para configurarlo hay que acceder en el modo Design a la propiedad model. Internamente utiliza la función setModel() para establecer una lista de elementos que utiliza el componente. Éstos vectores son habituales en varios componentes Swing y nos van a facilitar la vida. Por resumirlos, los ListModel son vectores, y dependiendo del tipo de componente los elementos del vector van a ser de un tipo o de otro. En el JList se ha establecido uno para verlo claro.

JList

Es una lista seleccionable. Estableciendo la propiedad model pondremos los elementos fácilmente con el Swing Designer. Si vamos al código veremos que se genera un ListModel especial para el tipo JList, el AbstractListModel, y entonces podremos acceder a los elementos seleccionados con las funciones siguientes:
entero = list.getSelectedIndex();
vectorDeEnteros = list.getSelectedIndices();
elemento = list.getSelectedValue();
vectorDeElementos = list.getSelectedValues();
La lista permite selección múltiple, por eso que tenemos las funciones que devuelven vectores.

JProgressBar

Es una barra de progreso. Con nombre.setValue(nuevoValor) y nombre.getValue() podemos cambiar o saber el valor que tiene en cada momento. Su manejo es sencillo y pienso que con esas dos funciones en bastante para empezar con ello.

JScrollBar

Es una barra de desplazamiento. Se usa igual que la barra de progreso a la hora de programar, pero añade que el usuario puede moverla, de manera que puede cambiar el valor de su posición. Con ésto que añade es interesante capturar el evento para hacer algo cuando el usuario cambia su posición, para ello con el boton derecho en el componente la damos al evento de cambio de ajuste:
En el código del ejemplo se puede ver que cuando se mueve la barra de desplazamiento se van a ajustar tanto la barra la progreso como el deslizador que viene a continuación.

JSlider

En castellano se llama deslizador. Funciona igual que la barra de desplazamiento, pero nos permite un mayor ajuste, pudiendo mostrar una regla con los números. Para que se vea la regla debemos poner los valores que se ven en la imagen siguiente:
Si no configuramos éstos valores en el editor de diseño no se verán los números. De igual manera que los anteriores, con getValue() tendremos el valor actual.
En la barra de desplazamiento se ha capturado el evento que se dispara al cambiar el ajuste. Para el deslizador el evento que se dispara cuando se mueve el deslizador se llama cambio de estado, como se ve en el código fuente:
slider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent arg0) {
progressBar.setValue(slider.getValue());
scrollBar.setValue(slider.getValue());
}
});

JSeparator

Simplemente es una línea de separación, una raya, que ya puse en el post anterior sobre los menús. Se puede poner también en el JFrame, concretamente en el panel, para dibujar una separación.

Terminando

Todo lo anterior se puede ver al detalle escudriñando un poco el código fuente generado con el Swing Designer y un poco programado manualmente:
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;

import javax.swing.AbstractListModel;
import javax.swing.ButtonGroup;
import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JProgressBar;
import javax.swing.JRadioButton;
import javax.swing.JScrollBar;
import javax.swing.JSeparator;
import javax.swing.JSlider;
import javax.swing.JSpinner;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JToggleButton;
import javax.swing.SwingConstants;
import javax.swing.border.EmptyBorder;
import javax.swing.border.LineBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

// ÉSTO ES LA CLASE PRINCIPAL QUE EXTIENDE DE JFRAME...
public class Principal extends JFrame {

private JPanel contentPane;
private JTextField txtCajaDeTexto;
static Principal frame;
private JPasswordField passwordField;

// la función que primero se ejecuta que crea
// el frame en memoria...
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
frame = new Principal();
// ... y lo visualiza
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

// aquí está el constructor de la clase que todo
// lo programa...
public Principal() {
// se contruye la ventana
setTitle("JavaSwing 6 Componentes bu00E1sicos by Jnj");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 458, 363);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);

// la etiqueta
JLabel lblEtiqueta = new JLabel("Etiqueta");
lblEtiqueta.setBounds(10, 11, 67, 14);
contentPane.add(lblEtiqueta);

// la caja de texto
txtCajaDeTexto = new JTextField();
txtCajaDeTexto.setText("Caja de texto");
txtCajaDeTexto.setBounds(10, 36, 152, 20);
contentPane.add(txtCajaDeTexto);
txtCajaDeTexto.setColumns(10);

// el cuadro combinado
JComboBox comboBox = new JComboBox();
// los elementos
comboBox.setModel(new DefaultComboBoxModel(new String[] {"Elemento 1", "Elemento 2", "Elemento 3"}));
// comienza seleccionado el elemento 1
comboBox.setSelectedIndex(1);
comboBox.setBounds(10, 67, 191, 20);
contentPane.add(comboBox);

// el botón
JButton btnBotn = new JButton("Botu00F3n");
// cuando se pulsa hace ésto
btnBotn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
JOptionPane.showMessageDialog(frame, "Ésto es un botón simple.");
}
});
btnBotn.setBounds(53, 95, 89, 23);
contentPane.add(btnBotn);

// la casilla de verificación
JCheckBox chckbx = new JCheckBox("Casilla de verificaciu00F3n");
chckbx.setSelected(true);
chckbx.setBounds(10, 125, 191, 23);
contentPane.add(chckbx);

// los botones de radio
JRadioButton rdbtn1 = new JRadioButton("RadioButton 1");
rdbtn1.setBounds(10, 151, 109, 23);
contentPane.add(rdbtn1);

JRadioButton rdbtn2 = new JRadioButton("RadioButton 2");
rdbtn2.setBounds(10, 177, 109, 23);
contentPane.add(rdbtn2);

// el grupo para los botones
ButtonGroup radioGroup = new ButtonGroup();
radioGroup.add(rdbtn1);
radioGroup.add(rdbtn2);

// otras casillas de verificación que se van a agrupar
// para ver el comportamiento
JCheckBox chckbx1 = new JCheckBox("CheckBox 1 agrupado");
chckbx1.setBounds(10, 203, 166, 23);
contentPane.add(chckbx1);

JCheckBox chckbx2 = new JCheckBox("CheckBox 2 agrupado");
chckbx2.setBounds(10, 229, 152, 23);
contentPane.add(chckbx2);

// el grupo para las casillas de verificación
ButtonGroup chkGroup = new ButtonGroup();
chkGroup.add(chckbx1);
chkGroup.add(chckbx2);

// el botón de activación
JToggleButton tglbtn = new JToggleButton("Botu00F3n de activaciu00F3n");
// que está seleccionado inicialmente
tglbtn.setSelected(true);
tglbtn.setBounds(10, 259, 166, 23);
contentPane.add(tglbtn);

// el área de texto
JTextArea txtrAreaDeTexto = new JTextArea();
// con una linea en el borde
txtrAreaDeTexto.setBorder(new LineBorder(new Color(0, 0, 0)));
// tres lineas de texto permitidas
txtrAreaDeTexto.setRows(3);
// el texto
txtrAreaDeTexto.setText("Arearnderntexto.");
txtrAreaDeTexto.setBounds(224, 11, 205, 58);
contentPane.add(txtrAreaDeTexto);

// el texto de contrasela
passwordField = new JPasswordField();
passwordField.setBounds(224, 80, 152, 20);
// contraseña inicial
passwordField.setText("supercontraseña");
contentPane.add(passwordField);

// el llamado 'hilandero'
JSpinner spinner = new JSpinner();
spinner.setBounds(224, 111, 101, 20);
contentPane.add(spinner);

// la lista
JList list = new JList();
// la declaración de los elementos
list.setModel(new AbstractListModel() {
String[] values = new String[] {"Elemento 1", "Elemento 2", "Elemento 3"};
// función que deveuelve el número de elementos
public int getSize() {
return values.length;
}
// función para acceder a cada elemento
// por ejemplo usando
//
// list.getModel().getElementAt(1)
//
// nos devolverá el elemento "Elemento 2"
public Object getElementAt(int index) {
return values[index];
}
});
list.setSelectedIndex(1);
list.setBounds(224, 142, 67, 52);
contentPane.add(list);

// el separador
JSeparator separator = new JSeparator();
separator.setOrientation(SwingConstants.VERTICAL);
separator.setBounds(211, 11, 2, 297);
contentPane.add(separator);

// inicializacion de la barra de progreso,
// la barra de desplazamiento y el deslizador.
// los he puesto aquí juntos porque los uso
// después y era necesario.
final JProgressBar progressBar = new JProgressBar();
final JScrollBar scrollBar = new JScrollBar();
final JSlider slider = new JSlider();

// configuraciones de la barra de progreso
progressBar.setValue(50);
progressBar.setBounds(224, 203, 205, 14);
contentPane.add(progressBar);

// la barra de desplazamiento
scrollBar.addAdjustmentListener(new AdjustmentListener() {
public void adjustmentValueChanged(AdjustmentEvent arg0) {
// mueve a la vez la barra de progreso y el deslizador
progressBar.setValue(scrollBar.getValue());
slider.setValue(scrollBar.getValue());
}
});
// valor inicial
scrollBar.setValue(50);
scrollBar.setOrientation(JScrollBar.HORIZONTAL);
scrollBar.setBounds(224, 233, 205, 23);
contentPane.add(scrollBar);

// el deslizador, capturando evento
slider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent arg0) {
// mueve la barra de progreso y la de desplazamiento
// cada vez que se mueve el deslizador.
progressBar.setValue(slider.getValue());
scrollBar.setValue(slider.getValue());
}
});
// valores para que salga la regla numerada
slider.setMinorTickSpacing(1);
slider.setMajorTickSpacing(10);
slider.setToolTipText("");
slider.setPaintTicks(true);
slider.setPaintLabels(true);
slider.setBounds(224, 267, 200, 52);
contentPane.add(slider);

} // termina el constructor de la ventana
} // termina la clase
Un fichero .zip para descargar con todo el código fuente y un ejecutable .jar para verlo en acción lo tienen aquí: descargar ejemplo.
Para ejecutarlo es necesario por lo menos tener el JRE, recomiendo la última versión a ser posible, la 7.
Como viene siendo habitual, para más información, me remito a la documentación oficial:
Espero que haya servido.
Un saludo. 

Java Swing 5: Preparando el menú para estas Navidades…

2012-12-20 - Categorías: Java / Java Swing
¡Hola de nuevo!

Estoy pegándole un repaso a todo lo referente a los menús con Swing usando Eclipse. No deja de sorprenderme lo fácil y rápido que lo tenemos una vez que te has familiarizado con Eclipse, y en concreto con el Swing Designer. En pocos minutos tenemos nuestro esqueleto de la aplicación listo para codificar sus funciones o encajarlo con códigos ya hechos, cada uno para lo que lo necesite…


Para todo ésto he usado la zona del Swing Designer que vemos a continuación:

Jugando con los componentes donde pone ‘Menu’ podemos hacer todo lo referente. Un JMenuBar es una barra de menús, es la típica barra de menús que sale normalmente en la zona de arriba de un programa con Archivo, Opciones, Ayuda, etcétera… Tenemos que poner uno en el JFrame para entonces, dentro de éste JMenuBar, podamos poner los JMenu o JMenuItem que queramos. Dentro de un JMenu podemos poner otros JMenu o elementos finales de tipo JMenuItem, JCheckBoxMenuItem, JRadioButtonMenuItem o en especial el JSeparator que simplemente es una línea separadora como la siguiente después de ‘Poner título’:
Luego tenemos otro tipo de menú que es el JPopupMenu. Se usa igual que el JMenuBar pero se pone en un panel en donde podremos hacer click derecho y saldrá el menú desplegable con los elementos que hayamos hecho.

Para hacer la estructura del ejemplo he puesto los siguientes componentes todos dentro del JMenuBar:

Archivo (JMenu)
– Poner título (JMenuItem)
– Barra separadora (JSeparator)
– Un JCheckBoxMenuItem (JCheckBoxMenuItem)
– Un JRadioButtonMenuItem (JRadioButtonMenuItem)
– Otro JRadioButtonMenuItem (JRadioButtonMenuItem)
– Salir (JMenuItem)
Colores (JMenuItem)
– Blanco (JMenuItem)
– Negro (JMenuItem)
– Cambiar el color de fondo con otros colores (JMenu)
— Verde (JMenuItem)
— Rojo (JMenuItem)
— Azul (JMenuItem)
Minimizar (JMenuItem)

En el JPopupMenu que pone ¡Hola! ¡Feliz Navidad! simplemente hay dos JMenuItem. En medio de la ventana he puesto un JSeparator para mostrar que se puede poner no sólo como un elemento de menú. Y luego tenemos un JLabel con la frase explicatoria.

Sólo hay que ponerse a juguetear con el Swing Designer y seguro que bien rápido que se le coge el truco.

Queda añadir cómo hacer que haga algo al hacer click, ésto se llama ponerle un manejador de evento, en éste caso al evento click del ratón. De nuevo usando el Swing Designer, que para eso está, para hacernos la vida más fácil xD le damos en cualquier componente Swing con el botón derecho y nos sale un menú desplegable como el siguiente:

En la opción ‘Add event handler’ tenemos todos los eventos disponibles que podemos asociar con casi cualquier componente. El que nos interesa ahora es el mousePressed que significa apretar el ratón, que en la imagen de arriba ya sale programado, por eso pone -> line 110, porque está en la línea 110 del código fuente. Ésto lo hacemos para cada cosa que queramos que haga algo al hacer click y al darle a mousePressed nos dirigirá al código para que lo programemos, creando el esqueleto del programa asociado a dicho evento del ratón.

Los elementos JCheckBoxMenuItem y JRadioButtonMenuItem también tienen el evento del click de ratón, y podemos usar una propiedad llamada ‘selected’ para saber si estan seleccionados o no y hacer lo correspondiente en cada caso.

Aquí tienes el código del ejemplo:

// el paquete del programa
package principal;

// las librerias de java para hacer todo...
import java.awt.Color;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.Frame;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JCheckBoxMenuItem;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.JSeparator;
import javax.swing.border.EmptyBorder;

// la clase principal
public class Principal extends JFrame {

 // el panel que todo lo contiene
 private JPanel contentPane;

 // la entrada al programa, lo que primero
 // se ejecuta
 public static void main(String[] args) {
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     // crea el frame en memoria
     // y lo visualiza
     Principal frame = new Principal();
     frame.setVisible(true);
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 // ésto es el constructor de la clase
 // aquí está todo
 public Principal() {

  // al cerrar la ventana sale del programa
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  // dimensiones y posición al arrancar del JFrame
  setBounds(100, 100, 450, 300);

  // la barra de menú
  JMenuBar menuBar = new JMenuBar();
  setJMenuBar(menuBar);

  // el menú Archivo empieza aquí ---------------------------------------
  JMenu mnArchivo = new JMenu("Archivo");
  menuBar.add(mnArchivo);

  JMenuItem mntmPonerTtulo = new JMenuItem("Poner tu00EDtulo");
  mntmPonerTtulo.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    setTitle("Java Swing 5: Menús by jnj");
   }
  });
  mnArchivo.add(mntmPonerTtulo);

  JMenuItem mntmSalir_1 = new JMenuItem("Salir");
  mntmSalir_1.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    dispose();
   }
  });

  JSeparator separator_1 = new JSeparator();
  mnArchivo.add(separator_1);

  JCheckBoxMenuItem chckbxmntmUnJcheckboxmenuitem = new JCheckBoxMenuItem(
    "Un JCheckBoxMenuItem");
  mnArchivo.add(chckbxmntmUnJcheckboxmenuitem);

  JRadioButtonMenuItem rdbtnmntmUnJradiobuttonmenuitem = new JRadioButtonMenuItem(
    "Un JRadioButtonMenuItem");
  mnArchivo.add(rdbtnmntmUnJradiobuttonmenuitem);

  JRadioButtonMenuItem rdbtnmntmOtroJradiobuttonmenuitem = new JRadioButtonMenuItem(
    "Otro JRadioButtonMenuItem");
  mnArchivo.add(rdbtnmntmOtroJradiobuttonmenuitem);
  mnArchivo.add(mntmSalir_1);

  // el menú Colores empieza aquí ---------------------------------------
  JMenu mnColores = new JMenu("Colores");
  menuBar.add(mnColores);

  JMenuItem mntmBlanco = new JMenuItem("Blanco");
  mntmBlanco.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.WHITE);
   }
  });
  mnColores.add(mntmBlanco);

  JMenuItem mntmNegro = new JMenuItem("Negro");
  mntmNegro.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.BLACK);
   }
  });
  mnColores.add(mntmNegro);

  JMenu mnCambiarElColor = new JMenu(
    "Cambiar el color de fondo con otros colores");
  mnColores.add(mnCambiarElColor);

  JMenuItem mntmVerde = new JMenuItem("Verde");
  mntmVerde.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.GREEN);
   }
  });
  mnCambiarElColor.add(mntmVerde);

  JMenuItem mntmRojo = new JMenuItem("Rojo");
  mntmRojo.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.RED);
   }
  });
  mnCambiarElColor.add(mntmRojo);

  JMenuItem mntmAzul = new JMenuItem("Azul");
  mntmAzul.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    contentPane.setBackground(Color.BLUE);
   }
  });
  mnCambiarElColor.add(mntmAzul);

  // el elemento del menú para minimizar está aquí ---------------------------------------
  JMenuItem mntmNewMenuItem = new JMenuItem("Minimizar");
  menuBar.add(mntmNewMenuItem);
  mntmNewMenuItem.addMouseListener(new MouseAdapter() {
   @Override
   public void mousePressed(MouseEvent e) {
    setState(Frame.ICONIFIED);
   }
  });
  
  // aquí termina la barra de menú ...
  
  
  // el panel que todo lo contiene se crea
  contentPane = new JPanel();
  // se le pone un borde
  contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  // se establece en el JFrame
  setContentPane(contentPane);

  // se hace JPopupMenu y lo pongo en el panel contenedor
  JPopupMenu popupMenu = new JPopupMenu();
  popupMenu.setBounds(0, 0, 319, 58);
  addPopup(contentPane, popupMenu);

  // el primer elemento del desplegable
  JMenuItem mntmhola = new JMenuItem("u00A1Hola!");
  popupMenu.add(mntmhola);

  // el segundo elemento del desplegable
  JMenuItem mntmfelizNavidad = new JMenuItem("u00A1Feliz Navidad!");
  popupMenu.add(mntmfelizNavidad);
  
  // el resto del JPanel con la raya separadora y la etiqueta explicatoria  
  contentPane.setLayout(null);

  JSeparator separator = new JSeparator();
  separator.setBounds(31, 88, 372, 24);
  contentPane.add(separator);

  JLabel lblHazClickCon = new JLabel(
    "Haz click con el botu00F3n derecho en la ventana para que salga el menu00FA.");
  lblHazClickCon.setBounds(10, 118, 414, 76);
  contentPane.add(lblHazClickCon);
 }

 // ésto es lo relativo al menú desplegable
 // lo que hace es mostrar éste menú donde sea que hagamos click 
 private static void addPopup(Component component, final JPopupMenu popup) {
  component.addMouseListener(new MouseAdapter() {
   public void mousePressed(MouseEvent e) {
    if (e.isPopupTrigger()) {
     showMenu(e);
    }
   }

   public void mouseReleased(MouseEvent e) {
    if (e.isPopupTrigger()) {
     showMenu(e);
    }
   }

   private void showMenu(MouseEvent e) {
    popup.show(e.getComponent(), e.getX(), e.getY());
   }
  });
 }
}

Y también como viene siendo costumbre el fichero con todo

Un saludo!


Java Swing 4: Pestañas

2012-12-14 - Categorías: Java / Java Swing

Para hacer un programa con pestañas repartiendo así los componentes se hace fácil con Swing y Eclipse. En pocos minutos, usando el generador de código esqueleto y con el Swing Designer te genera código.

Antes de poner el código, a saber, con el Swing Designer lo que tendremos será la ventana vacía, para poder posicionar los elementos tenemos que añadir en medio un Absolute layout. Luego dibujamos donde va a ir con el JTabbedPane. Después tenemos que añadir dos paneles encima del JTabbedPane, es decir, dos JPanel normales y corrientes. Las pestañas las creará el JTabbedPane cuando añadimos los paneles. Entonces ya tenemos las pestañas creadas, pero tenemos que decirle, en cada pestaña cómo vamos a posicionar los elementos y ponemos otros Absolute layout, uno en cada pestaña. Ahroa ya tenemos las pestañas y además podremos poner los elementos en la zona de la pestaña en que queramos, que en éste caso es una etiqueta JLabel en cada pestaña.

Aquí está el código:

import java.awt.EventQueue;
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.JPanel;
import javax.swing.JTabbedPane;
import javax.swing.border.EmptyBorder;

// Ésta es la clase principal
// es un JFrame...
public class Principal extends JFrame {

 // el panel principal donde se pone todo
 private JPanel contentPane;
 
 // ejecuta primero todo ésto
 public static void main(String[] args) {
  // arranca en un hilo de ejecución... 
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     // creando el frame y lo muestra
     Principal frame = new Principal();
     frame.setVisible(true);
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 // Constructor de la clase: se configura aquí toda 
 // la ventana y los controles...
 public Principal() {
  
  // título de la ventana
  setTitle("Pestau00F1as con Swing by jnj");
  // operación al cerra la ventana 
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  // coordenadas de las esquinas del frame en el escritorio
  setBounds(100, 100, 419, 234);
  
  // el panel que contiene todo se crea y se pone en el frame
  contentPane = new JPanel();
  contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  setContentPane(contentPane);
  // distribución nula para poder posicionar los elementos
  // en las coordenadas que queramos
  contentPane.setLayout(null);
  
  // se crea el panel de pestañas
  JTabbedPane panelDePestanas = new JTabbedPane(JTabbedPane.TOP);
  // se posiciona en el panel
  panelDePestanas.setBounds(10, 11, 383, 174);
  contentPane.add(panelDePestanas);
  
  // éste es el primer panel
  // que se añade como pestaña al 'tabbedPane'
  JPanel panel1 = new JPanel();
  panelDePestanas.addTab("Panel 1", null, panel1, null);
  // al panel le pongo distribución nula para
  // posicionar los elementos en las coordenadas que
  // quiera
  panel1.setLayout(null);
  
  // una etiqueta en el panel de la pestaña 1
  JLabel lbl1 = new JLabel("Primera pestau00F1a..");
  lbl1.setBounds(10, 11, 348, 14);
  panel1.add(lbl1);
  
  // otro panel de igual forma
  JPanel panel2 = new JPanel();
  panelDePestanas.addTab("Panel 2", null, panel2, null);
  panel2.setLayout(null);
  
  // otra etiqueta ésta vez en el segundo panel
  JLabel lbl2 = new JLabel("Segunda pestau00F1a..");
  lbl2.setBounds(10, 11, 290, 14);
  panel2.add(lbl2);
 }
}

Un saludo!


Google Drive vía web en 3 sencillos pasos

2012-12-09 - Categorías: General

Me hago eco de una noticia que últimamente está corriendo por Internet, con una guía, a mi entender bastante complicada para poner una web o archivos en descarga directa en Google Drive. La fuente de la noticia que leo es:

http://www.pcactual.com/articulo/actualidad/noticias/12064/google_drive_permite_publicar_contenido_web.html

… buscando un poco más, encontré la guía de Developers de Google:

https://developers.google.com/drive/publish-site

He hecho un par de pruebas, aparte de que está en inglés, se habla del webViewLink y de programar para crear un directorio público :S todo ésto se me va complicando… Una web de ejemplo que nos han dejado los de Google es:

https://googledrive.com/host/0B716ywBKT84AcHZfMWgtNk5aeXM/

Resumiendo

Voy a ir al grano, reduciendo todo el proceso anterior, lo que necesitas es conseguir la cadena que identifica tu directorio que vas a usar para poner tus archivos. En el ejemplo anterior de la gente de Google, es 0B716ywBKT84AcHZfMWgtNk5aeXM, éste es su identificador para el ejemplo que se han currado. Nosotros entonces podemos reducir el proceso, y para ello sólo hay que seguir 3 pasos:

  1. Crear una carpeta dentro de tu Google Drive.
  2. La compartes como público en la web. Con lo que te van a dar un enlace como el siguiente https://docs.google.com/folder/d/cadenaQueIndicaTuDirectorio/edit (lo puedes ver en la ventana que sale para configurar como compartes el directorio).
  3. Ya sólo tienes que poner tu cadenaQueIndicaTuDirectorio en la dirección URL para que se pueda acceder desde un navegador.

Podrás acceder y enviar tu dirección a quien quieras, y los archivos podrán verse de la forma:
https://googledrive.com/host/cadenaQueIndicaTuDirectorio/index.html
https://googledrive.com/host/cadenaQueIndicaTuDirectorio/miArchivo.zip
https://googledrive.com/host/cadenaQueIndicaTuDirectorio/loQueSeaQueQuieraPublicar.extension
etcétera…

Si pones en éste directorio un archivo index.html y el resto de una página web, ya tienes acceso directo como en cualquier hosting. Puedes usar las tecnologías de programación cliente, como HTML, CSS, Javascript… Lo único malo es la dirección URL tan compleja, pero también se puede redirigir un domonio ocultando éste URL. De todas maneras dependes de lo que haga Google con tu cuenta de Drive. Pero ya es bastante lo que nos estan dando, que es gratis, o por lo menos yo me beneficio de su cuenta gratuita…

Un saludo!


Java Swing 2: Crear ventanas con Eclipse

2012-12-08 - Categorías: Java / Java Swing

Para éste microtutorial he usado el Swing Designer de Eclipse y la versión 1.7 update 9 de Java, el JDK y el JRE.

En Eclipse tenemos tenemos varias opciones para generar código esqueleto para nuestro programa. En la ventana del explorador de proyectos, en el lugar elegido le damos con el botón derecho a New -> Other… y nos saldrá una ventana como la siguiente con las opciones disponibles con respecto a Swing:

En el árbol de Swing Designer tenemos las opciones para crear programas con ventanas Swing, valga la redundancia. Todos los códigos generados con el Swing Designer también se pueden crear a mano y se pueden llevar a otros entornos de desarrollo y te van a funcionar. Ésto lo digo porque no ocurre siempre, según en qué entorno de desarrollo estés, a veces pasa que si te sales de él ya no te sirven los códigos porque se les han puesto «extras» que te atan a ellos. Ésto no te va a pasar con los Swing en Eclipse, o por lo menos yo no me encontrado con éste problema.

Vamos al grano…

Application Window

Si elegimos una Application Window nos va a crear la clase siguiente:

package pruebasSwing;

import java.awt.EventQueue;
import javax.swing.JFrame;

public class ApplicationWindowPrueba {

    private JFrame frame;

    // primero se ejecuta ésto…
    public static void main(String[] args) {
        // en un hilo de ejecución aparte hace todo
        // porque todo lo hace en un new Runnable
        // a continuación…
        EventQueue.invokeLater(new Runnable() {
            // run es el método que se ejecuta
            // al arrancar el hilo
            public void run() {
                try {
                    // crea una variable de la clase y se inicializa
                    // con el constructor de la misma                  
                    ApplicationWindowPrueba window = new ApplicationWindowPrueba();
                    // muestra la ventana
                    window.frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    // éste es el constructor de la clase
    public ApplicationWindowPrueba() {
        initialize();
    }

    // la función que inicializa
    private void initialize() {
        // crea el frame
        frame = new JFrame();
        // coordenadas de la ventana
        frame.setBounds(100, 100, 450, 300);
        // establece la operación a ejecutar cuando
        // se cierra el JFrame
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

}

Se trata de una clase que no hereda de ninguna otra, y lo que simplemente hace es crear un JFrame en un hilo de ejecución separado.

JApplet

Un Applet es una programa de Java que se ejecuta en un navegador de Internet. Éste programa se le envía al cliente mientras que navega y se ejecuta en su máquina. Nos crea lo básico para hacer uno, pero a fecha de hoy están totalmente en desuso y los navegadores los desactivan por defecto.. Así que mejor ni probarlo…

package pruebasSwing;

import javax.swing.JApplet;

// clase que extiende de JApplet,
// que a su vez extiende de la clase
// Applet y ésta en sí es un Panel…
public class JAppletPrueba extends JApplet {

    // el constructor
    public JAppletPrueba() {

    }
}

JDialog

Con ésta opción generaremos el código para hacer un típico cuadro de diálogo con el usuario para que se le informe de algo o elija entre las opciones que queramos. Éste tipo de ventanas se usan asociadas a otra ventana padre, aunque al tener un main se puede generar un .jar ejecutable que sólo tenga un cuadro de diálogo de éstos.

El código que genera:

package pruebasSwing;

import java.awt.BorderLayout;
import java.awt.FlowLayout;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

// la clase que extiende de JDialog,
// que a su vez extiende de Dialog,
// y ésta de Window…
public class JDialogPrueba extends JDialog {

    private final JPanel contentPanel = new JPanel();

    public static void main(String[] args) {
        try {
            // crea un nuevo objeto de la clase
            JDialogPrueba dialog = new JDialogPrueba();
            // operacion al cerrar
            dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            // lo muestra
            dialog.setVisible(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // constructor de la clase
    public JDialogPrueba() {
        // propiedades de la ventana
        setBounds(100, 100, 450, 300);
        getContentPane().setLayout(new BorderLayout());
        contentPanel.setLayout(new FlowLayout());
        contentPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
        getContentPane().add(contentPanel, BorderLayout.CENTER);
       
        // los botones para confirmar o cancelar
        {
            JPanel buttonPane = new JPanel();
            buttonPane.setLayout(new FlowLayout(FlowLayout.RIGHT));
            getContentPane().add(buttonPane, BorderLayout.SOUTH);
            {
                JButton okButton = new JButton(«OK»);
                okButton.setActionCommand(«OK»);
                buttonPane.add(okButton);
                getRootPane().setDefaultButton(okButton);
            }
            {
                JButton cancelButton = new JButton(«Cancel»);
                cancelButton.setActionCommand(«Cancel»);
                buttonPane.add(cancelButton);
            }
        }
    }

}

JFrame

Con el asistente del JFrame, hace casi lo mismo que con el de Application Window, pero hay dos ligeras diferencias. La primera es que con Application Window tenemos una variable interna a la clase que es el JFrame, y con el éste lo que tenemos es que la clase misma extiende a JFrame, con lo que realmente tenemos un JFrame en sí que se puede reutilizar en otros lugares del programa. La segunda diferencia es que añade un JPanel al JFrame, cosa que con el asistente de Application Window no lo hace.

El código es el siguiente:

package pruebasSwing;

import java.awt.BorderLayout;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;

// la clase extiende de JFrame, realmente ES un JFrame
public class JFramePrueba extends JFrame {

    private JPanel contentPane;

    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    JFramePrueba frame = new JFramePrueba();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    public JFramePrueba() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 450, 300);
        // añade el panel…
        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        contentPane.setLayout(new BorderLayout(0, 0));
        setContentPane(contentPane);
    }

}

JInternalFrame

Ésta clase se usa para hacer ventanas que se ejecutan dentro de un JDesktopPane. Es decir, dentro de la misma ventana padre, tendremos una zona que será un panel de escritorio, el anterior JDesktopPane. Y en éste panel es donde veremos el JInternalFrame. Así que necesitaremos un JFrame padre para poder ejecutarlo dentro.

Ésta clase tiene un main pero no se puede ejecutar en un .jar aparte.

El código:

package pruebasSwing;

import java.awt.EventQueue;
import javax.swing.JInternalFrame;

public class JInternalFramePrueba extends JInternalFrame {

    // arranca en un hilo el formulario hijo
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    JInternalFrame frame = new JInternalFrame();
                    frame.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }

    // aquí estará construida la ventana
    public JInternalFramePrueba() {
        setBounds(100, 100, 450, 300);

    }

}

JPanel

Ésto es una clase básica que podemos usar en otros formularios o ventanas. Es decir, podemos poner paneles dentro de JFrames. Así que puede ser útil tener un panel programado aparte. El código que genera es:

package pruebasSwing;

import javax.swing.JPanel;

public class JPanelPrueba extends JPanel {

    // constructor de la clase
    public JPanelPrueba() {

    }

}

Swing Automatic Databinding

Aquí tenemos un asistente que nos va a crear lo necesario para crear una ventana con Databindings. Necesitaremos un Bean, y configurar las diversas opciones. Ésto es bastante extenso así que ya tengo tema para otro post.. 🙂

Terminando

Las principales clases que primero se van a usar van a ser la ApplicationWindow o la JFrame. De éstas la JFrame es bueno usarla de un principio porque luego la puede incluir dentro de otros proyectos sin muchos cambios.

Dentro de Eclipse podemos visualizar todos los anteriores con F11, menos el JInternalFrame y el JPanel que se podrá visualizar dentro de otro. Una vez generado el código correspondiente, podremos entrar a editar el diseño visualmente, con lo que nos ahorraremos un considerable esfuerzo.

Con ésto me voy a la cama y mañana más…

Un saludo!


Java Swing 1: A vista de pájaro

2012-12-05 - Categorías: Java / Java Swing
En éste post, espero dar un vistazo general al paquete de clases de Java de Swing, en concreto a la versión estándar 1.7 update 9. En la fecha en que escribo ésto, los Swing ya no están en desarrollo, con lo que no se van a añadir nuevas funcionalidades, ni componentes. En la web de Oracle, podemos ver la jerarquía completa del paquete javax.swing en la documentación original, aquí teneis el árbol de la jerarquía de clases:

Casi todas las clases que hay para crear nuestra interfaz de usuario van a empezar por J, como JFrame, JDialog, JButton, JLabel, etcétera… Ya tengo instalada la versión del JDK y del JRE más nueva ahora mismo para asegurarme de que tengo al día el paquete de clases. Así pues, la ayuda contextual de Eclipse me muestra un listado de todos éstos componentes:
Tenemos 46 clases en éste listado, de las cuales la clase con la que se contruyen todas las demás clases visuales es JComponent. El resto de clases de Swing que no comienzan por J, ayudan o nos sirven de herramientas para éstas. Quitando la JComponent, nos quedan 45 clases que «dibujan» nuestra interfaz gráfica.

Estado actual

Swing se contruyó a partir de AWT, es decir se basa en AWT, que es más dependiente del Sistema Operativo. De ésta forma los programas hechos con Swing son más independientes del Sistema Operativo, así que mejor si usamos Swing porque está más elaborado. Otro tema es JavaFX, que es el siguiente «level» en la programación gráfica que la gente de Java están desarrollando. JavaFX promete ser más independiente del Sistema Operativo si aún cabe, prometiendo en un futuro que tu programa desarrollado en JavaFX llegue a ser compatible con cualquier dispositivo que tenga gráficos, como móviles, televisiones, coches, incluso en una página web dicen en los vídeos de Oracle siempre que tengamos la máquina virtual de Java instalada. Pero todo ésto se va del tema del post que tenemos entre manos…

Contenedores externos

Volviendo a los Swing, de todas éstas clases tenemos las clases que nos van a ayudar a estructurar nuestro programa en ventanas, diálogos, paneles.. en donde vamos a poner el resto de componentes. Éstas clases son las siguientes:
  1. JFrame -> es la madre del cordero, la clase que normalmente se usa para que contenga el resto de componentes, es la principal.
  2. JApplet -> para construir un applet.
  3. JDesktopPane -> crea una zona donde podemos poner ventanas internas (JInternalFrame).
  4. JDialog -> es una ventana de diálogo.
  5. JInternalFrame -> ventana hija que debe estar dentro de un escritorio (JDesktopPane).
  6. JLayer -> crea un borde alrededor de otro componente.
  7. JLayeredPane -> es un panel con borde.
  8. JPanel -> un panel simple sin adornos ni nada.
  9. JRootPane -> panel principal que puede contener otros objetos.
  10. JScrollPane -> es un panel que sirve para contener objetos que se salen del campo, entonces con barras de scroll podemos movernos por ellos.
  11. JSplitPane -> sirve para dividir una zona en dos, en cada subdivisión podemos poner otros elementos.
  12. JTabbedPane -> parecido al JSplitPane pero divide las zonas en pestañas.
  13. JViewPort -> es un objeto que sirve para visualizar los otros objetos que se mueven en una ventana, como por ejemplo con barras de scroll.
  14. JWindow -> es como un JFrame pero sin bordes ni botones para cerrar, maximizar y minimizar.
Pueden crearso objetos anteriores y meterse unos dentro de otros, algunos se pueden omitir y otros son necesarios. Por ejemplo si queremos ventanas internas debemos de ponerlas dentro de un panel de escritorio (JDesktopPane), sino no funcionará.

El resto de componentes

Vistos los anterioes 14 elementos, nos quedan 45 menos 14 que son 31 componentes. Éstos que quedan son más conocidos y en cuanto leemos sobre ellos seguro que sabemos de qué hablamos.
Los clásicos:
  1. JButton -> para hacer botones.
  2. JCheckBox -> cajas chequeables.
  3. JComboBox -> pues el combo de siempre, creo que se llama «caja de selección desplegable».
  4. JLabel -> para poner etiquetas.
  5. JList -> implementa una lista seleccionable.
  6. JOptionPane -> panel donde podemos poner opciones a elegir.
  7. JPasswordField -> campo de contraseña.
  8. JProgressBar -> barras de progreso.
  9. JRadioButton -> estos son los elementos que dan varias opciones a elegir, en la que sólo una es posible.
  10. JEditorPane -> para poner textos complejos, admite HTML y  texto en el formato Rich Text Format (RTF).
  11. JFormattedTextField -> para poner textos con formato.
  12. JTextArea -> areas de texto donde podemos poner textos grandes, multilínea.
  13. JTextField -> areas de textos pequeños, de una sola linea de texto.
  14. JTextPane -> admite textos formateados, iconos y componentes.
Unas utilidades:
  1. JColorChooser -> nos sirve para mostrar una ventana donde podemos elegir un color.
  2. JFileChooser -> éste objeto es una ventana para elegir un archivo.
Menús:
  1. JMenu -> ésto es un menú que podemos poner dentro de una barra de menú o dentro de otro menú.
  2. JMenuBar -> barra de menús, dentro de ésta se ponen el resto de los elementos de los menús.
  3. JMenuItem -> es un elemento de menú.
  4. JCheckBoxMenuItem -> cajas de texto seleccionable en un menú.
  5. JPopupMenu -> implementa un menú desplegable.
  6. JRadioButtonMenuItem -> para poner opciones a elegir en un menú.
  7. JSeparator -> es una raya entre elemento y elemento de menú.
Otros:
  1. JToolBar -> es una barra de herramientas para personalizar.
  2. JToolTip -> muestra un texto al pasar por encima de un componente.
  3. JScrollBar -> barras de scroll.
  4. JSlider -> es una barra que puedes mover arriba y abajo con la que elijes un valor.
  5. JSpinner -> es una caja de texto con dos botones arriba y abajo para cambiar el valor de la caja.
  6. JToggleButton -> botón con dos estados, presionado y no presionado.
  7. JTable -> se usa para mostrar tablas de datos, como su nombre indica.
  8. JTree -> es un árbol, que puede servir para mostrar por ejemplo un árbol de directorios.
Con ésto ya nos podemos hacer una idea de las posibilidades que tenemos para hacer una interfaz de usuario con Swing.
Espero que sirva de ayuda.
Un saludo.

El SlideShow más simple con jQuery

2012-11-14 - Categorías: General

Un slideshow viene a significar visor de imágenes o diapositivas que van pasando una tras otra.

Estuve buscando para descargar slideshows para web. Encontré de todo tipo, muy elaborados y con muchos extras, unos de pago y otros gratis, pero no era lo que yo quería. Buscaba algo lo más sencillo posible para adaptarlo luego donde lo necesite y al final acabé programándolo a partir de jQuery.

Aquí va el código para el que lo necesite:

<html>
<head>
<!– Con ésto incluyes el jquery en tu web usando en CDN de Google –>
<script src=»https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js»></script>
</head>
<body>

<img id=»imagenslide» src=»imagenes/imagenInicial.jpg» alt=»Imagen de una mascota..» />

<script>
  cambiaSlideShow();

function cambiaSlideShow() {
// variables para configurar
var dirImagenes = ‘imagenes/’; // directorio donde estan
 // las imágenes, se deben nombrar de la forma
 // 1.jpg
 // 2.jpg
 // etcétera…
var numImagenes = 3; // número de imágenes que hay

// elige un número aleatorio para mostrar las imágenes
// aleatoriamente
var randomNum = Math.ceil(Math.random() * numImagenes);

// con ésto la imagen desaparece y cuando ha desaparecido
// cambia de imagen
$(‘#imagenslide’).fadeOut(3000,
function () {$(‘#imagenslide’).attr(‘src’, dirImagenes + randomNum + ‘.jpg’);}
);

// con ésto otro la imagen aparece con un efecto fade de nuevo
$(‘#imagenslide’).fadeIn(3000);
setTimeout(function () {cambiaSlideShow(); }, 7000);
}

</script>
</body>
</html>

Y un archivo para descargar el ejemplo haciendo click aquí.
Ten en cuenta que debes poner las imágenes en el directorio dirImagenes que tengas en dicha variable.

Un saludo.


Ponle un Favicon a tu web

2012-11-13 - Categorías: General
Ya le he puesto al blog un Favicon, y les dejo un nuevo post.
Cuando navegas por Internet, las páginas muestran un icono en tu navegador. Cuando agregas dicha web a Favoritos, Marcadores, o como se llame en el navegador que uses.. También verás dicho icono asociado a dicha página web. Ésto es lo que se llama ‘el Favicon’.

Favicon, viene de Favourites Icon, icono de favoritos en castellano. Nació para darle mejor estética al listado de páginas de nuestra lista de páginas web favoritas. Y si quieres que tu web tenga una imagen de éstas lo único que debes hacer es usar un código tal que así:

<html>
<head>
<title>Aquí va el título</title>
<link href=»http://direcciondetuweb/favicon.ico» rel=»icon» type=»image/x-icon»>
</head>
<body>
<p>Contenido de la página.</p>
</body>
</html>

La imagen debe ser de 16×16 pixeles tradicionalmente, también puede ser de 32×32, incluso se pueden usar en algunos navegadores imágenes en JPG, PNG y GIF. Pero éstas otras opciones no son totalmente estándar y puede que no funcionen en todos los navegadores.
En éste blog, gracias a Blogger, tengo disponible el gadget llamado tal cual Favicon, que automáticamente me genera el código de aquí arriba. Yo te lo he detallado por si acaso lo usas en otro sitio.
Así que, después de éste post ¿no merece que agregues ésta web a favoritos? agregame a favoritos y así me visitas de vez en cuando 😉
Un saludo.

Hola Mundo con Swing y Eclipse

2012-11-10 - Categorías: Java / Java Swing
Aquí dejo cómo crear una primera aplicación gráfica en Java usando Swing y Eclipse. El ejercicio clásico ¡Hola Mundo! usando una tecnología que nos brinda Java crear aplicaciones con entorno gráfico, Java Swing. Y para verlo, el entorno de desarrollo elegido ha sido Eclipse.

Curioseando qué tal van los desarrollos, con respecto a las interfaces gráficas de usuario (llamadas GUI para los amigos), veo que tengo otra nueva actualización del Window Builder. El Window Builder es un conjunto de plugins de Eclipse que nos van a permitir hacer GUIs en Java sin gastar casi tiempo.

A fecha de hoy tengo la versión Juno de Eclipse, y me acabo de instalar el plugin Swing Designer que está disponible dentro del propio Eclipse, en la famosa opción Help -> Install New Software. Instalada la versión 1.5.1 del Swing Designer, me he puesto manos a la obra.

En el Explorador de Proyectos, donde estés creando tu aplicación Java, le das con el botón derecho del ratón a New -> Other… Y verás una ventana como la siguiente donde puedes elegir todo el tipo de ficheros, clases, o lo que sea que quieras hacer:
Se parece a Visual Studio, NetBeans o IDEs similares ¿verdad? Personalmente no creo que Eclipse tenga nada que envidiar a ningún otro entorno de desarrollo de pago, o no de pago. ¿Qué más queremos teniendo Eclipse? Parezco un vendedor de Eclipse (jejejje es broma). Bromas aparte, depende de dónde te encuentres te irá mejor un entorno de desarrollo u otro…
Seguimos con lo que tenemos entre manos. He creado mi nueva Application Window que he llamado HolaMundoSwing y se me abre una ventana dentro de Eclipse tal que así:
Me ha generado 44 líneas de código, con las que ya tengo mi ventana con el programa básico. Tenemos disponible absolutamente todo el código necesario para crear aplicaciones con GUIs, es decir, que no se nos esconde nada del código fuente. Podríamos usar éste mismo código fuente en línea de comandos, y compilar nuestro programa Java con el javac.exe sin usar Eclipse. Lo que quiero explicar, es que Eclipse te genera y te da todo el código fuente, sin crear archivos secundarios en tu proyecto donde gestione la parte gráfica. No te atas a Eclipse. Es decir, en éste caso todo lo necesario está dentro del mismo fichero, te puedes llevar ésta recién creada aplicación de ventanas a otro sitio con sólo llevarte el fichero HolaMundoSwing.java y seguir programando.
Vamos ahora a lo que más nos va a interesar, el diseñador de formularios que nos va a ahorrar mucho tiempo en el diseño de la interfaz de usuario. Abajo tenemos una pestaña que pone ‘Design’, diseño en castellano. Le damos y nos sale una ventana como la siguiente. Aquí es donde podemos editar visualmente todo tipo de componentes visuales del estilo de botones, cajas de texto, grupos de selección, podemos poner imágenes, menús, y un largo etcétera…
Cómo se usa cada componente merece un post, así que éste lo voy a dejar así.

Lo lógico es que quieras juguetear poniendo componentes en tu nueva ventana. Para poder posicionarlos donde quieras hay que poner antes de nada en el formulario un ‘Absolute layer’ que tenemos en la sección ‘Layouts’. Después ya podrás poner los componentes donde quieras. En pocos segundos he puesto un botón, una etiqueta y una caja de selección, como podemos ver en la imagen de aquí arriba. Si volvemos a la pestaña de abajo donde pone ‘Source’, en nuestro Eclipse, veremos que automáticamente se ha generado todo el código correspondiente para dibujar los componentes en nuestro GUI. Queda después añadir el código para hacer funcionar cada cosa.

Puedes hacer doble click en el botón para ver la facilidad con que puedes empezar a programar. Se te pondrá delante el código fuente y la función donde puedes programar el click del botón. Verás un código tal que así:

JButton btnNewButton = new JButton(«Botu00F3n»);
btnNewButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// AL HACER CLICK EJECUTA ÉSTO
}
});
btnNewButton.setBounds(10, 11, 89, 23);
frmholaMundoSwing.getContentPane().add(btnNewButton);

Aquí queda ésta pequeña introducción a los Swings de Java. Si quieres hacer un fichero ejecutable de Java, un .JAR y distribuir el programa que acabas de hacer; en la ventana del explorador de proyectos, le das con el botón derecho del ratón al fichero HolaMundoSwing.java. Se despliega el menú y le haces click en Exportar. Luego eliges Java JAR file. Eliges destino. Y ya tienes un ejecutable .jar que puedes usar en cualquier ordenador con el JRE instalado.
Un saludo.

Cómo montar un servidor propio con Joomla y Uniform Server

2012-11-05 - Categorías: General
Hola! Ya tengo algo de tiempo, estoy poniéndome al día y navegando veo que hay una nueva versión de Joomla, la 3.0.1. También veo que tengo disponible una nueva versión del Uniform Server, tengo la 8.5.7 y ya existe la 8.6.7, así que me he puesto las pilas para actualizarme y de paso os hago éste post.
Joomla ya es compatible con móviles, es la primera plataforma web compatible 100% con móviles, eso escriben en JoomlaSpanish.org. Así que con ésto, es un buen momento de probar la nueva versión.
Si estas aquí supongo que ya sabrás que Joomla es un CMS, un sistema para manejo de contenidos, y que el Uniform Server es un servidor de páginas web con base de datos MySQL y otros extras más… Si no lo sabías ya lo sabes, Joomla es una aplicación web, que instalada en un servidor web, te proporciona todas las utilidades necesarias para gestionar una página web medianamente compleja.
No voy a entrar en detalle sobre las diferencias entre usar un CMS ya hecho, usar un framework de desarrollo de webs, o programar todo directamente desde cero. Tal vez en otro post.
Asi que empezemos a montar un servidor propio…
Un poco de teoría
Antes de entrar directamente a instalar programas, sin saber lo que estamos haciendo debemos saber algunas cosas. Si eres un veterano, o muy valiente, pásate éste apartado xD
Todo en Internet, mientras navegamos, ocurre de la misma manera. Tenemos nuestro navegador, en el que ponemos las direcciones de Internet, le damos al Enter o al botón de turno, y mágicamente nos sale la página web. A ver, hay que entender que es lo que ocurre. Tenemos lo que se llama un cliente (navegador), y un servidor (el programa que nos envía a nuestro ordenador la página web y la podemos ver en nuestro navegador). Éste servidor web es lo que vamos a instalar. Y en concreto, el Uniform Server, que me atrevo a decir es muy buena opción.
Lo que vamos a hacer es simular lo que ocurre en Internet mientras navegamos, pero en nuestro ordenador en red local.

Ingredientes
  1. Uniform Server.
  2. Joomla en versión castellano.
El Joomla, en castellano, lo tienen en http://www.joomlaspanish.org/
Uniform Server es un proyecto en SourceForge.net, disponible en:
Y su página oficial es:
Sobre los ingredientes
He probado el XAMPP, que también es una buena opción, pero he elegido el Uniform Server para el trabajo de servidor web Apache con PHP y MySQL porque no hay que instalarlo, símplemente se descomprime. Y además es portable, es decir, que lo puedes llevar en un USB con toda tu web configurada y ejecutarla en cualquier ordenador con Windows sin tener que instalar todos los programas asociados a un servidor web (que pueden llegar a ser muchos).
Por otro lado, Joomla no es sólo un CMS, sino que también es un framework de desarrollo de aplicaciones web. La comunidad de Joomla, surgió del antiguo Mambo. He leido que hubo conflicto entre algunos de los actuales desarrolladores de Mambo y algunos de Joomla, que antes programaban juntos en Mambo, entonces se dividieron creando Joomla a partir de una versión de Mambo. No voy a entrar en la rumorología, el hecho es que Joomla surgió de Mambo, otro CMS anterior. Y ahora según las últimas estadísticas Joomla es el CMS más utilizado.
Joomla está construido en PHP, y actualmente trabaja sobre MySQL y se está añadiendo que pueda trabajar con otras bases de datos a fecha de hoy. Ésto es muy resumido porque Joomla es muy extenso e incluye gran cantidad de componentes. Es decir, tenemos un monton de archivos que descargaremos de la página, y éstos archivos van a ejecutarse de manera que todos los datos de Joomla se van a guardar en una base de datos. Es importante saber ésto porque tanto los archivos del directorio, como lo que haya en la base de datos forman tu web, no puedes separarlos.
El servidor web
Muy bien, llegado éste momento. Ya debemos tener descargados los archivos para el Joomla y el UniServer. Vamos a descomprimir primero el UniServer la versión completa del server, se llama Coral, debe ser uno llamado Coral_version.exe. Al arrancarlo te pide la carpeta donde lo quieres instalar, yo le he puesto C: y entonces me queda una estructura tal que así:
Arrancas el archivo Start_as_service.exe para usarlo como servicio instalándolo dentro del propio Windows. De ésta manera cada vez que arranques de nuevo Windows estará funcionando. Si lo prefieres usar como un programa sin instalarlo, puedes arrancar Start_as_program.exe y no necesitarás instalarlo como servicio. Yo lo tengo instalado como servicio, como podeis ver en la imagen.
Si no queremos complicarnos, sólo queda descomprimir el archivo de Joomla en el directorio C:UniServerwww y ya tendremos el servidor propio de Joomla en nuestro ordenador. Y accediendo a http://localhost/ veremos el Joomla que nos pide los datos para configurar la web.
Ésto es lo estrictamente necesario, de ésta manera te limitas a sólo tener una página web, y pierdes la página principal del UniServer. Yo prefiero configurarlo de otra manera, usando «hosts virtuales» y poniendo cada web en la carpeta que yo quiera. Me gusta tenerlo todo muy organizado, cada cosa en su carpeta, y poder acceder a cada página web de nuestro ordenador de la forma siguiente, por ejemplo:
http://localhost/  <- ésta es la página principal de nuestro servidor
http://unapaginajoomla/ <- ésta es la página web que vamos a configurar
http://temporal/ <- otra página web
etcétera…
Imaginemos que hemos puesto en D:MisPaginasWebunapaginajoomla los archivos de Joomla descomprimido, y en D:MisPaginasWebtemporal otra página web.
Vamos entonces a configurar los llamados «hosts virtuales», de manera que tengamos varios hosts en nuestra misma máquina. Entonces abrimos el panel de control del Uniform Server. Vamos a Server Configuration -> Apache -> Apache Vhosts. Entonces elegimos directorio D:MisPaginasWebunapaginajoomla, le ponemos el nombre debajo (en éste caso «unapaginajoomla») y confirmamos, y si no hemos tenido error le damos a Create Vhost. Reiniciamos el Apache con el panel de control del UniServer y ahora ya podremos acceder al Joomla que acabamos de descomprimir mediante el navegador poniendo http://unapaginajoomla/
Lo mismo podemos hacer con el directorio D:MisPaginasWebtemporal poniéndole como nombre de host virtual ‘temporal’ por ejemplo. Y así tantos hosts como queramos.
Yo prefiero tenerlo así para tener todas las páginas web localizadas en un directorio. Y a la vez puedes configurar tu entorno de desarrollo web para que acceda a esos directorios. Esto te puede ayudar a programar más organizadamente, pero ya entramos en otro tema que no viene al caso en éste post.
Podemos configurar el servidor de forma que nos sirva para un entorno de producción, o para desarrollo. Si estás programando en PHP o construyendo una web nueva con Joomla, te interesará activar ésto:
Dentro del panel de control del UniServer, entras a:
Server Configuration -> PHP -> Switch to Developement Configuration file
Así verás cualquier error o advertencia mientras que trabajas con el Joomla.
El CMS
Recapitulando, si todo ha ido bien ya tenemos Joomla en una carpeta, que yo he puesto en D:MisPaginasWebunapaginajoomla y que tiene un host virtual asociado. Ahora resulta que accedemos a la siguiente dirección:
Y ahora sí, vamos a configurar Joomla para poder crear contenido. La primera vez nos veremos el sistema de instalación tal que así:
Aquí arriba vemos que se ha simplificado enormemente los pasos de instalación en sólo tres. La ayuda proporcionada por el sistema está muy bien como para yo tener que explicar nada más.
A continuación veo que se ha añadido soporte para PostgreSQL, una gran base de datos. La comunidad de usuarios de Joomla llevaba tiempo queriendo tener soporte para otras bases de datos y ya por fin llegó.
Ponemos los datos de conexión a nuestra base de datos y al darle a siguiente tendremos el tercer y último paso con información sobre la instalación. Podemos aquí instalar datos de ejemplo para poder ver algo mientras que lo probamos.
Para terminar le damos a instalar y ya está, tendremos nuestra nueva y flamante página web, toda gestionada por Joomla, y en un servidor propio instalado en nuestro ordenador.
Terminando
Me sorprende todos los cambios de los últimos meses en Joomla, la interfaz es mucho más limpia. En fin, me parece una gozada el buen trabajo que esta haciendo la gente de Joomla. A ver si en otro post puedo entrar a destripar el Joomla, que tiene muy buena pinta ¿verdad? jejeje
Con ésto ya les dejo.
Un saludo

© 2024 JnjSite.com - MIT license

Sitio hecho con WordPress, diseño y programación del tema por Jnj.