Download Práctica 1. Manejo de JFrames y Evetnos Competencia Específica a

Práctica 1. Manejo de JFrames y Evetnos
Competencia Específica a Desarrollar: Desarrolla aplicaciones gráficas utilizando la API Swing de Java
utilizando manejo de eventos del teclado.
Saberes previos: conocer el funcionamiento básico de las clases JFrame, manejo de eventos en Java con
ActionListener así como el uso de componentes como JTextField, JButton y JLabel. Manejo de Herencia y
polimorfismo.
Saberes nuevos: JColorChooser.
Objetivo: Desarrollar una aplicación de ventanas en Java que permita calcular el área de las siguientes figuras:
Triángulo, Cuadrado, Círculo y Rectángulo. Se deberá manejar herencia de Figuras utilizando una clase base
Figura, la cual no podrá instanciarse, las clases derivadas no podrán derivar en otras. La aplicación cuenta con
una ventana principal en la que se escogerá el tipo de figura y mandará a cada ventana respectiva para
realizar el cálculo pertinente.
Nuevos saberes: A continuación se explica el código del día de hoy. El programa principal es el siguiente:
1. import java.awt.Color;
2. import javax.swing.JColorChooser;
3. public class App {
4. public static void main(String[] args) {
5. Color c=Color.BLACK;
6. c = JColorChooser.showDialog(null, "Escoge un color de fondo", c);
7. Principal p = new Principal("Ventana", 800, 600);
8. p.setBackground(c);
9. p.setVisible(true);
10. }
11. }
En la línea 6 se utiliza el Objeto estático JColorChooser del paquete javax.swing el cual es un cuadro de
diálogo para seleccionar colores. Este cuadro regresa el color seleccionado por el usuario el cual se colocará
de fondo en nuestra aplicación en la línea 8. El programa principal construye un objeto de tipo Principal que
a continuación se detalla:
1. import java.awt.BorderLayout;
2. import java.awt.Canvas;
3. import java.awt.Color;
4. import java.awt.Container;
5. import java.awt.Font;
6. import java.awt.GradientPaint;
7. import java.awt.Graphics;
8. import java.awt.Graphics2D;
9. import java.awt.event.ActionEvent;
10. import java.awt.event.ActionListener;
11. import java.awt.event.ItemEvent;
12. import java.awt.event.ItemListener;
13. import java.awt.event.MouseEvent;
14. import java.awt.event.MouseListener;
15. import java.awt.event.MouseMotionListener;
16. import java.awt.event.WindowEvent;
17. import java.awt.event.WindowListener;
18. import java.awt.geom.Ellipse2D;
19. import javax.swing.JButton;
20. import javax.swing.JCheckBox;
21. import javax.swing.JFrame;
22. import javax.swing.JLabel;
23. import javax.swing.JOptionPane;
24. import javax.swing.JPanel;
25. import javax.swing.JTextField;
26. import javax.swing.Timer;
27. public class Principal extends JFrame{
28. private int tamX;
29. private int tamY;
30. private String titulo;
31. private Lienzo l;
32. private Timer t;
33. private Font f;
34. private JTextField texto;
35. private JLabel etiqueta;
36. private JPanel p1, p2;
37. private JCheckBox caja;
38. private JButton boton;
39. public Principal(){
40. tamX=640;
41. tamY=480;
42. titulo="Venatana Principal";
43. init();
44. }
45. public Principal(String t, int x, int y){
46. super(t);
47. this.addWindowListener(new EventoVentana());
48. init();
49. setSize(x, y);
50. }
51. private void init(){
52. setDefaultLookAndFeelDecorated(true);
53. Container c = getContentPane();
54. c.setLayout(new BorderLayout());
55. p1 = new JPanel();
56. p1.setLayout(new BorderLayout());
57. p2 = new JPanel();
58. p2.setLayout(new BorderLayout());
59. l = new Lienzo();
60. l.addMouseMotionListener(new MovimientoRaton());
61. f = new Font("Helvetica", Font.BOLD, 32);
62. texto = new JTextField("Escribe tu nombre");
63. texto.setFont(f);
64. etiqueta = new JLabel("Ejemplo de manejo de eventos");
65. etiqueta.addMouseListener(new EventoRaton());
66. //etiqueta.addActionListener(new ActionListener(){
67. // public void actionPerformed(ActionEvent e) {
68. // System.out.println("Presionado");
69. //}
70. //});
71. p1.add(etiqueta, BorderLayout.NORTH);
72. p1.add(l, BorderLayout.CENTER);
73. p1.add(texto, BorderLayout.SOUTH);
74. //Se crea un timer cada 5 segundos
75. t = new Timer(5000, new ActionListener(){
76. public void actionPerformed(ActionEvent e){
a. System.out.println("Se repite cada 5 segundos");
77. }
78. });
79. //Se arranca el timer
80. t.start();
81. //t.stop();
82. caja = new JCheckBox("Te gusta Java");
83. caja.setSelected(true);
84. caja.addItemListener(new Verificacion());
85. boton = new JButton("Otra Ventana");
86. boton.addActionListener(new ActionListener(){
87. public void actionPerformed(ActionEvent e) {
a. Ventanita v = new Ventanita();
b. v.setVisible(true);
88. }
89. });
90. p2.add(caja, BorderLayout.NORTH);
91. p2.add(boton, BorderLayout.CENTER);
92. c.add(p1, BorderLayout.CENTER);
93. c.add(p2, BorderLayout.SOUTH);
94. pack();
95. }
96. class EventoRaton implements MouseListener{
97. public void mouseClicked(MouseEvent e) {
98. System.out.println("Se hizo click sobre la etiqueta con el boton="+e.getButton());
99. }
100.
public void mousePressed(MouseEvent e) {
101.
System.out.println("Se presiono el botón "+e.getClickCount()+"veces");
102.
}
103.
public void mouseReleased(MouseEvent e) {
104.
System.out.println("Se solto el boton en x="+e.getX());
105.
}
106.
public void mouseEntered(MouseEvent e) {
107.
System.out.println("Entro el raton"+e.getY());
108.
}
109.
public void mouseExited(MouseEvent e) {
110.
System.out.print("Se salio del raton a las:"+e.getWhen());
111.
}
112.
}
113.
class EventoVentana implements WindowListener{
114.
public void windowOpened(WindowEvent e) {
115.
//Evento de ventana abierta
116.
}
117.
public void windowClosing(WindowEvent e) {
118.
String opciones[]={"Si", "Tal vez", "A lo mejor", "Quien sabe", "No"};
119. int
op
=
JOptionPane.showOptionDialog(null,
"Deseas
salir",
JOptionPane.YES_NO_OPTION, JOptionPane.PLAIN_MESSAGE, null, opciones, "No");
120.
System.out.println("Opcion seleccionada="+op );
121.
System.exit(-1);
122.
}
123.
public void windowClosed(WindowEvent e) {
124.
}
125.
public void windowIconified(WindowEvent e) {
126.
}
127.
public void windowDeiconified(WindowEvent e) {
128.
}
129.
public void windowActivated(WindowEvent e) {
"Saliendo",
130.
}
131.
public void windowDeactivated(WindowEvent e) {
132.
}
133.
}
134.
class MovimientoRaton implements MouseMotionListener{
135.
public void mouseDragged(MouseEvent e) {
136.
System.out.println("Se hizo Drag en el botón"+e.getLocationOnScreen());
137.
}
138.
public void mouseMoved(MouseEvent e) {
139.
System.out.println("Se movio el raton "+e.getPoint());
140.
}
141.
}
142.
class Verificacion implements ItemListener{
143.
public void itemStateChanged(ItemEvent e) {
144.
if(caja.isSelected())
a. System.out.println("Vientos!!!");
145.
else
a. System.out.println("De seguro eres fan de VB");
146.
}
147.
}
148.
}
149.
class Lienzo extends Canvas{
150.
@Override
151.
public void paint(Graphics g){
152.
Graphics2D g2d = (Graphics2D) g;
153.
int x[]={1, 100, 150, 200, 300};
154.
int y[]={1, 50, 200, 250, 300};
155.
g2d.fill3DRect(100, 350, 300, 100, true);
156.
g2d.drawPolygon(x, y, x.length);
157.
g2d.setPaint(new GradientPaint(5,30,Color.BLUE, 65,100, Color.YELLOW, true));
158.
g2d.fill(new Ellipse2D.Double(80,30, 65, 100));
159.
}
160.
}
La Ventana Principal tiene dos constructores uno predeterminado (línea 39) y otro parametrizado (línea
45). Ambos llaman al método init (línea 51) para la construcción del entrono gráfico.
El constructor parametrizado en la línea 47 agrega una manejador de eventos de ventana WindowListener
llamada EventoVentana (línea 113). De los eventos de ventana el más utilizado es windowClosing (línea
117) el cual ocurre cuando se cierra una ventana, en este caso en la línea 119 se muestra el uso del objeto
JOptionPane con el método showOptionDialog, este método recibe muchos parámetros conocidos,
cambiando un manejo de opción de botones a través de un arreglo de cadenas y la selección de un elemento
por default.
El método init en la línea 52 con setDefaultLookAndFeelDecorated(true), forza a que se conserve el
ambiente de ventanas predeterminado por el sistema. El manejo de componentes se hace a través de
Layouts anidados, todos de tipo BorderLayout. Para hacer el anidamieno de componentes se necesita de un
componente especial llamado JPanel. Un Panel permite colocar elementos para un mejor manejo. En este
programa se construyen dos paneles cuyo layout también es BorderLayout(líneas 53 a 58).
Aunque se puede dibujar directamente sobre cualquier componente gráfico con el método paint() se sugiere
que se utilice un objeto especializado para ello, este objeto es un Canvas. Se creó una clase llamada Lienzo
derivada de Canvas (línea 149) y se sobrescribió su método paint(). En la línea 152 se utilizó una mejora del
objeto Graphics tradicional: el objeto Graphics2D. Un objeto de tipo Grpahics2D tiene la misma
funcionalidad que Graphics solo que cuenta con métodos extendidos. En la línea 155 se construyo un
rectángulo lleno del color activo con efecto de 3D. En la línea 156 se dibujó un polígono con el método
drawPolygon, el cual recibe un conjunto de puntos x y y así como su tamaño. Mientras que en la línea 157 se
creó un gradiente entre azul y rojo (métodos solo disponibles en Grpahics2D) para después dibujar una
Elipse en dos dimensiones en la línea 158.
Una vez agregado el lienzo, se le agregó el manejo de eventos de tipo MouseMotionListener (línea 60) a
través de la clase Interna MovimientoRaton (línea 134). Este manejador de eventos cuenta con dos métodos:
mouseDragged y mouseMoved que se ejecutarán cuando sobre el lienzo se arrastre el ratón o éste se mueva.
En las líneas 66-70 las cuales están comentadas se trata de agregar un ActionListener a un JLabel. Dicho
evento no lo tiene definido este componente por lo que fue necesario agregar otro manejo de eventos. En
este caso nos interesa un clic de ratón lo cual se logra a través de agregar un manejador de eventos
MouseListener, por lo que se creo una clase manejadora del evento denominada EventoRatón(línea 96) que
controla los siguientes eventos: mouseClicked, mousePressed, mouseReleased, mouseEntered y
mouseExited. Se sobre cargo el método mouseClicked para simular un evento de acción.
En las líneas 71 a 73 se agregaron algunos componentes al panel1 para posteriormente agregarlos en un
contenedor. En la línea 75 se crea un timer, el cual es un elemento temporizador de reljo que ejecutará su
acción (definida en un ActionListener). El primer argumento es el número de milisegundos de espera, en
este caso 5000 equivalentes a 5 segundos. El timer se echa andar con el método start() y se pararía con el
método stop(). (Líneas 80 y 81).
En la línea 82 se crea una caja de verificación con JCheckBox, se coloca para que esté palomeada (línea 83) y
se agrega un manejador de eventos de tipo ItemListener llamado Verificación (línea 142). La cual
implementa el método itemStateChange el cual ocurre cuando cambia un valor.
Finalmente en las líneas 85 y 89 se crea un botón y se le asigna la propiedad de construir un objeto ventanita
que a continuación se describe:
1. import java.awt.Container;
2. import java.awt.FlowLayout;
3. import java.awt.event.ItemEvent;
4. import java.awt.event.ItemListener;
5. import javax.swing.ButtonGroup;
6. import javax.swing.JRadioButton;
7. import javax.swing.JFrame;
8. public class Ventanita extends JFrame implements ItemListener{
9. private JRadioButton op1, op2, op3;
10. private ButtonGroup grupo;
11. public Ventanita(){
12. super("Menú de Opciones");
13. setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14. Container c = getContentPane();
15. c.setLayout(new FlowLayout());
16. op1 = new JRadioButton("Opcion1", true);
17. op2 = new JRadioButton("Opcion2", false);
18. op3 = new JRadioButton("Opcion3", true);
19. c.add(op1);
20. c.add(op2);
21. c.add(op3);
22. grupo = new ButtonGroup();
23. grupo.add(op1);
24. grupo.add(op2);
25. grupo.add(op3);
26. op2.addItemListener(this);
27. }
28. public void itemStateChanged(ItemEvent e) {
29. System.out.println("Cambiando esta opcion");
30. System.out.print("opcion seleccionada="+grupo.getSelection().getActionCommand());
31. }
32. }
En este programa se construyen tres botones de radio con la clase JRadioButton (líneas 16 a 18) y se crea un
grupo de botones con ButtonGroup (línea 22) al cual lógicamente se le agregan los botones de forma lógica.
Nótese que si los radiobotones no estuvieran en un grupo, cada uno sería independiente con respecto a su
valor. Finalmente se agregó un manejador de evento de tipo ItemListener incluido dentro de la clase.