elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Arreglado, de nuevo, el registro del warzone (wargame) de EHN


  Mostrar Mensajes
Páginas: [1] 2 3 4 5 6 7
1  Programación / Java / Como paso datos entre varios jsp en: 22 Mayo 2015, 10:29 am
hola, buenos dias, tengo que realizar una aplicacion para gestionar un almacen de provicncias y poblaciones:
<a href="http://imgur.com/v9ySUBS"><img src="http://i.imgur.com/v9ySUBS.png" title="source: imgur.com" /></a>
<a href="http://imgur.com/BekJHxd"><img src="http://i.imgur.com/BekJHxd.png" title="source: imgur.com" /></a>
<a href="http://imgur.com/jUepkrF"><img src="http://i.imgur.com/jUepkrF.png" title="source: imgur.com" /></a>
<a href="http://imgur.com/Sykcl38"><img src="http://i.imgur.com/Sykcl38.png" title="source: imgur.com" /></a>

de momento estoy con la pagina que muestra las provincias y poblaciones en una tabla, llevo esto:

Código
  1. <%@ page language="java" import="java.util.*"%>
  2. <%@ page language="java" import="almacen.*"%>
  3. <%@ page language="java" import="java.io.*"%>
  4. <%@ page language="java" import="paa.provincias.*"%>
  5.  
  6.  
  7.  
  8. <html xmlns="http://www.w3.org/1999/xhtml" lang="es" xml:lang="es">
  9. <head>
  10.    <title>listaPoblaciones</title>
  11.    <link rel="stylesheet" type="text/css" href="estilos.css" />
  12.    <meta http-equiv="Content-Type" content="text/html;charset=ISO-8859-1" />
  13.  
  14. </head>
  15. <body>
  16. <%@ page language="java"
  17. contentType="text/html; harset=ISO-8859-1"
  18. pageEncoding="ISO-8859-1"%>
  19. <div id="lista">
  20. <%
  21. AlmacenPoblaciones almacen = null;
  22. boolean balmacen;
  23. almacen = new AlmacenPoblaciones();
  24.    String path = getServletConfig().getServletContext().getRealPath("");
  25. balmacen = almacen.recuperar(path + "\\WEB-INF\\almacen.dat");
  26. int numProvincias = almacen.getProvincias().size();
  27. String direccion = "http://localhost:8080/practica3/listaPoblaciones.jsp?";
  28. if(!balmacen){
  29. System.out.println("No se ha cargado el almacen");
  30. }
  31. %>
  32.  
  33. <h1>Lista de provincias almacenadas</h1>
  34. <h2>Se han recuperado <%=numProvincias%> provincias</h2>
  35. <h3>Pulse sobre el nombre de la provincia para ver las poblaciones</h3>
  36. <%
  37. Set<String> listaProvincias = almacen.getProvincias();
  38. String provincia;
  39. System.out.println("listaProvincias");%>
  40. <ul>
  41. <%for(String a : listaProvincias){%>
  42. <li> Provincias: <a href=<%=direccion%>> <%=a%></a></li>
  43. <%}%>
  44. </ul>
  45. <%
  46. Enumeration<String> nombres = request.getParameterNames();
  47.    if(nombres.hasMoreElements()){
  48. provincia = nombres.nextElement();
  49.        SortedSet<IPoblacion> listaPoblaciones = almacen.getPoblaciones(provincia);
  50. Iterator<IPoblacion> itr = listaPoblaciones.iterator();
  51. Poblacion poblacion;
  52. if(itr.hasNext()){%>
  53. <table align=\center\>
  54. <tr><th>Provincia</th><th>Población</th><th>Habitantes</th><th>Código</th><th>Operación</th></tr>
  55. <%for(IPoblacion s : almacen.getPoblaciones(provincia)){
  56. poblacion = (Poblacion) s;%>
  57. <tr><td><%=poblacion.getProvincia()%></td><td><%=poblacion.getNombre()%></td><td><%=poblacion.getHabitantes()%></td><td><%=poblacion.getCodigoAEMET()%></td><td><a href=borrar.jsp>Borrar</a></td></tr>
  58. <%}%>
  59.  
  60. </table>
  61. <%}else{%>
  62. <h2>No hay poblaciones en: <%=provincia%></h2>
  63. <%}%>
  64. <%}%>
  65.  
  66. </div>
  67. </body>
  68. </html>
  69.  

el problema que tengo es que no se como borrar una poblacion, en el objeto almacen esta el metodo correspondiente al que hay que pasarle la poblacion y la provincia en la que la hay que borrar pero al ser un .jsp no se como debo de hacerlo, es posible saber si se ha pinchado en un href?, habia pensado en crear otro jsp al que le pase los datos pero no se como hacerlo y si seria correcto, alguna ayuda, gracias.
2  Programación / Java / Poner iconos en JTable en: 17 Abril 2015, 15:22 pm
hola, quiero hacer una tabla para mostrar predicciones meteorologicas, la cual forma parte de una aplicacion:


pero a la hora de actualizar las predicciones queda asi:


lo curioso es que en el codigo del modelo:

Código
  1. package principal;
  2.  
  3. import java.util.Iterator;
  4.  
  5. import javax.swing.table.AbstractTableModel;
  6.  
  7. import paa.provincias.IPrediccion;
  8.  
  9. public class TableModel extends AbstractTableModel{
  10.  
  11. /**
  12. *
  13. */
  14. private static final long serialVersionUID = 1L;
  15. String columnas[] = {"Fecha", "Temp. Mínima", "Temp. Máxima", "Icono","Estado del cielo"};
  16. Object[][] data;
  17. public java.util.List<IPrediccion> predicciones;
  18.  
  19. public TableModel() {
  20. data = new Object[8][5];
  21. int k = 0;
  22. for(int j = 0; j<5; j++){
  23. data[0][j] = columnas[k];
  24. k++;
  25. for(int i=1; i<8; i++){
  26. data[i][j] = new String("*");
  27. }
  28. }
  29. }
  30.  
  31. public int getColumnCount() {
  32. return columnas.length;
  33. }
  34.  
  35. @Override
  36. public int getRowCount() {
  37. return data.length;
  38. }
  39.  
  40. @Override
  41. public Object getValueAt(int row, int col) {
  42.  
  43. return data[row][col];
  44. }
  45.  
  46. public String getColumnName(int col){
  47. return columnas[col];
  48. }
  49.  
  50. public Class getColumnClass(int c){
  51. return getValueAt(0,c).getClass();
  52. }
  53.  
  54. //public boolean isCellEditable(int row,int col){}
  55. public void setValueAt(Object value, int row, int col){
  56. data[row][col] = value;
  57. fireTableCellUpdated(row,col);
  58. }
  59.  
  60. public void rellenar(java.util.List<IPrediccion> prediccion){
  61. Iterator<IPrediccion> it;
  62. it = prediccion.iterator();
  63.  
  64. int i = 1; // si pongo 1 salen imagenes, si pongo 0 salen string wtf?
  65. int j;
  66. while (it.hasNext()){
  67. //Recorremos la lista y colocamos en las celdas de cada fila los datos de las predicciones
  68. IPrediccion pre = it.next();
  69. j=0;
  70. setValueAt(pre.getFecha(), i, j);
  71. j++;
  72. setValueAt(pre.getTemperaturaMinima(), i, j);
  73. j++;
  74. setValueAt(pre.getTemperaturaMaxima(), i, j);
  75. j++;
  76. setValueAt(pre.getIconoEstadoCielo(), i, j);
  77. j++;
  78. setValueAt(pre.getEstadoCielo(), i, j);
  79. j++;
  80. i++;
  81. }
  82. }
  83.  
  84.  
  85. }
  86.  

y me da esto cuando pongo i a 1:


lo cual es como deberia de estar pero desplazado una fila hacia debajo, alguien sabe donde esta el error?
3  Programación / Java / Re: Aplicacion en swing para mostrar el tiempo de provincias y poblaciones en: 16 Abril 2015, 10:12 am
Tengo problemas para actualizar el jtree no se como hacerlo, utilizo reload pero no se actualiza, las provincias y poblaciones se guardan pero el jtree ni se inmuta, y otra cosa en la tabla, como actualizo los datos?, por que el metodo para actualizarlos que es setValueAt esta inplementado dentro del tablemodel, no dentro de la tabla,

principal:

Código
  1. package principal;
  2. import java.awt.*;
  3. import java.awt.event.*;
  4. import javax.swing.BorderFactory;
  5. import javax.swing.Icon;
  6. import javax.swing.ImageIcon;
  7. import javax.swing.JButton;
  8. import javax.swing.JFrame;
  9. import javax.swing.JLabel;
  10. import javax.swing.JMenu;
  11. import javax.swing.JMenuBar;
  12. import javax.swing.JMenuItem;
  13. import javax.swing.JOptionPane;
  14. import javax.swing.JPanel;
  15. import javax.swing.JSplitPane;
  16. import javax.swing.JTable;
  17. import javax.swing.JToolBar;
  18. import javax.swing.JTree;
  19. import javax.swing.SwingConstants;
  20. import javax.swing.event.TreeSelectionEvent;
  21. import javax.swing.event.TreeSelectionListener;
  22. import javax.swing.tree.DefaultMutableTreeNode;
  23. import javax.swing.tree.DefaultTreeModel;
  24. import javax.swing.tree.TreeNode;
  25. import javax.swing.tree.TreeSelectionModel;
  26.  
  27. import Poblacion.VentanaBorrarPoblacion;
  28. import Poblacion.VentanaCrearPoblacion;
  29. import paa.provincias.GestorAEMET;
  30. import paa.provincias.GestorAEMETException;
  31. import paa.provincias.IPoblacion;
  32. import paa.provincias.IPrediccion;
  33.  
  34.  
  35. /**
  36.  * Fichero: InterfazAWT_AEMET.java Clase que implementa la Interfaz Gráfica
  37.  * AEMET con awt.
  38.  *
  39.  * @author PAA
  40.  * @version 1.0
  41.  */
  42. public class InterfazAWT_AEMET extends JFrame {
  43. /**
  44. *
  45. */
  46. private static final long serialVersionUID = 502635761186556414L;
  47.  
  48. private static final String FICHERO = "almacen.dat";
  49. private AlmacenPoblaciones almacen;
  50.  
  51. // private IAlmacenPoblaciones almacenPoblaciones;
  52.  
  53. private java.util.List<IPrediccion> listaPredicciones;
  54. private InterfazAWT_AEMET gui;
  55. private GestorAEMET gestor = new GestorAEMET();
  56. private JTree tree;
  57. private JTree treeDatos;
  58. private DefaultTreeModel modeloArbol;
  59. private DefaultTreeModel modelo;
  60. private DefaultMutableTreeNode selectedNode;
  61. private String nombrePoblacion;
  62. private JTable tabla;
  63. private TableModel d;
  64. /**
  65. * Constructor.
  66. *
  67. * @throws GestorAEMETException
  68. */
  69. public InterfazAWT_AEMET(String titulo, int ancho, int alto) {
  70. super(titulo);
  71. setSize(ancho, alto);
  72. setLocationRelativeTo(null);
  73. setLayout(new BorderLayout()); // Layout de la aplicación, podría ser otro
  74. almacen = RecuperarAlmacenPoblaciones();
  75. initComponents();
  76. JFrame.setDefaultLookAndFeelDecorated(true);
  77. }
  78.  
  79. public AlmacenPoblaciones RecuperarAlmacenPoblaciones() {
  80. // Recuperamos el almacén
  81. AlmacenPoblaciones almacenPoblaciones1 = new AlmacenPoblaciones();
  82.  
  83. if (almacenPoblaciones1.recuperar(FICHERO)){
  84. Icon icono= new ImageIcon(getClass().getResource("/iconos/check.png"));
  85. JOptionPane.showMessageDialog(null, "Recuperado el almacen del fichero " + FICHERO, "Recuperado",JOptionPane.INFORMATION_MESSAGE,icono);
  86. }else{
  87. JOptionPane.showMessageDialog(null, "No se ha podido recuperar el almacen del fichero" + FICHERO, "Error",JOptionPane.ERROR_MESSAGE);
  88.  
  89. }return almacenPoblaciones1;
  90.  
  91. }
  92.  
  93. public void initComponents() {
  94. // Boton salir por defecto
  95. this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  96. setJMenuBar(addJMenuBar());
  97. this.add(addJToolBar(), BorderLayout.NORTH);
  98. this.add(addlineaEstado(), BorderLayout.SOUTH);
  99.  //Creamos el splitpanel y lo colocamos en medio del jtree y la tabla, despues lo añadimos al Jframe
  100.    JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,addPanelIzquierda(),addpredicciones());
  101.    splitPane.setOneTouchExpandable(true);
  102.    splitPane.setDividerLocation(100);
  103.    splitPane.setDividerSize(10);
  104.    this.add(splitPane,BorderLayout.CENTER);
  105. }
  106.  
  107. private JMenuBar addJMenuBar() {
  108. // Sitúo los menús desplegables
  109. JMenuBar barraDeMenu = new JMenuBar();
  110. // Creo el menú Archivo
  111. JMenu menuArchivo = new JMenu("Archivo");
  112. JMenuItem crearGuardar = new JMenuItem("Guardar");
  113. JMenuItem crearCargar = new JMenuItem("Cargar");
  114. JMenuItem salir = new JMenuItem("Salir");
  115. crearCargar.addActionListener(new Controller());
  116. crearGuardar.addActionListener(new Controller());
  117. salir.addActionListener(new Controller());
  118. menuArchivo.add(crearCargar);
  119. menuArchivo.add(crearGuardar);
  120. menuArchivo.add(salir);
  121.  
  122. // Creo el menú Provincias
  123. JMenu menuProvincias = new JMenu("Provincias");
  124. JMenuItem crearProvincias = new JMenuItem("Crear provincia");
  125. JMenuItem borrarProvincias = new JMenuItem("Borrar provincia");
  126. crearProvincias.addActionListener(new Controller());
  127. borrarProvincias.addActionListener(new Controller());
  128. menuProvincias.add(crearProvincias);
  129. menuProvincias.add(borrarProvincias);
  130.  
  131. // Creo el menu Poblaciones
  132. JMenu menuPoblaciones = new JMenu("Poblaciones");
  133. JMenuItem crearPoblacion = new JMenuItem("Crear poblacion");
  134. JMenuItem borrarPoblacion = new JMenuItem("Borrar poblacion");
  135. JMenuItem ordenarNombre = new JMenuItem("Ordenar por nombre");
  136. JMenuItem ordenarHabitantes = new JMenuItem("Ordenar por habitantes");
  137. JMenuItem modPoblacion = new JMenuItem("Modificar poblacion");
  138. JMenuItem movPoblacion = new JMenuItem("Mover poblacion");
  139. crearPoblacion.addActionListener(new Controller());
  140. borrarPoblacion.addActionListener(new Controller());
  141. ordenarNombre.addActionListener(new Controller());
  142. ordenarHabitantes.addActionListener(new Controller());
  143. modPoblacion.addActionListener(new Controller());
  144. movPoblacion.addActionListener(new Controller());
  145. menuPoblaciones.add(crearPoblacion);
  146. menuPoblaciones.add(borrarPoblacion);
  147. menuPoblaciones.add(ordenarNombre);
  148. menuPoblaciones.add(ordenarHabitantes);
  149. menuPoblaciones.add(modPoblacion);
  150. menuPoblaciones.add(movPoblacion);
  151.  
  152. // Creo el menú de ayuda
  153. JMenu ayuda = new JMenu("Ayuda");
  154. JMenuItem acercaDe = new JMenuItem("Acerca de");
  155. acercaDe.addActionListener(new AcercaDe());
  156. ayuda.add(acercaDe);
  157.  
  158. // Crea el
  159. barraDeMenu.add(menuArchivo);
  160. barraDeMenu.add(menuProvincias);
  161. barraDeMenu.add(menuPoblaciones);
  162. barraDeMenu.add(ayuda);
  163. return barraDeMenu;
  164. }
  165.  
  166. private JToolBar addJToolBar() {
  167. // Sitúo la línea de botones
  168. JToolBar lineaDeBotones = new JToolBar();
  169. lineaDeBotones.setBackground(new Color(200,100,100));
  170.  
  171. // Boton crear provincia
  172. Icon Iprovincia= new ImageIcon(getClass().getResource("/iconos/provincia.png"));
  173. JButton proCrear = new JButton("Crear provincia",Iprovincia);
  174. proCrear.addActionListener(new Controller());
  175.  
  176. // Boton crear poblacion
  177. Icon Ipoblacion= new ImageIcon(getClass().getResource("/iconos/poblacion.png"));
  178. JButton poCrear = new JButton("Crear poblacion",Ipoblacion);
  179. poCrear.addActionListener(new Controller());
  180.  
  181. // Boton actualizar prediccion
  182. Icon actualizar= new ImageIcon(getClass().getResource("/iconos/actualizar.png"));
  183.  
  184. JButton aPrediccion = new JButton("Actualizar Predicción",actualizar);
  185. aPrediccion.setToolTipText("Click para actualizar las predicciones");
  186. aPrediccion.addActionListener(new Controller());
  187.  
  188. // Añadir los botones a la barra
  189. lineaDeBotones.add(proCrear);
  190. lineaDeBotones.add(poCrear);
  191. lineaDeBotones.add(aPrediccion);
  192. return lineaDeBotones;
  193. }
  194.  
  195. private JTree addPanelIzquierda() {
  196.        // Construccion de los datos del arbol y del arbol
  197.        CrearArbol();
  198.        //Creamos el listener del JTree
  199.        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  200.        tree.addTreeSelectionListener(new TreeSelectionListener(){
  201. @Override
  202. public void valueChanged(TreeSelectionEvent se) {
  203. treeDatos = (JTree) se.getSource();
  204. selectedNode = (DefaultMutableTreeNode) treeDatos.getLastSelectedPathComponent();
  205.    nombrePoblacion = selectedNode.toString();
  206.    if (selectedNode.isLeaf()) {
  207.      System.out.println(nombrePoblacion);
  208.      System.out.println(selectedNode.getParent().toString());
  209.    }
  210. }
  211.        });
  212.        tree.setBorder(BorderFactory.createLineBorder(Color.blue));
  213.  
  214. return tree;
  215. }
  216.  
  217. public void CrearArbol(){
  218. DefaultMutableTreeNode provinciasPrincipal = new DefaultMutableTreeNode("Provincias");
  219. modelo = new DefaultTreeModel(provinciasPrincipal);
  220.    tree = new JTree(modelo);
  221. for(String s : almacen.getProvincias()){
  222.         int j = 0;
  223.         DefaultMutableTreeNode provincia = new DefaultMutableTreeNode(s);
  224.         modelo.insertNodeInto(provincia, provinciasPrincipal, j);
  225.         j++;
  226.         for(IPoblacion i : almacen.getPoblaciones(s)){
  227.         int x = 0;
  228.         DefaultMutableTreeNode poblacion = new DefaultMutableTreeNode(i.getNombre());
  229.         modelo.insertNodeInto(poblacion, provincia, x);
  230.         x++;
  231.         }
  232.        }
  233.  
  234. }
  235.  
  236. private JPanel addpredicciones() {
  237. // Creamos la tabla de las predicciones
  238. JPanel predicciones = new JPanel(new BorderLayout());
  239. d = new TableModel();
  240. tabla = new JTable(d);
  241. JLabel lPrediccion = new JLabel("Predicciones de :");
  242. //predicciones.add(lPrediccion, BorderLayout.NORTH);
  243. predicciones.add(lPrediccion,BorderLayout.NORTH);
  244. predicciones.add(tabla,BorderLayout.CENTER);
  245. predicciones.setBackground(Color.white);
  246. predicciones.setBorder(BorderFactory.createLineBorder(Color.blue));
  247. return predicciones;
  248. }
  249.  
  250. private JPanel addlineaEstado() {
  251. // Sitúo la línea de estado
  252. JPanel lineaDeEstado = new JPanel();
  253. lineaDeEstado.setLayout(new FlowLayout(FlowLayout.LEFT));
  254. lineaDeEstado.setBackground(new Color(0,80,80));
  255. JLabel ventanaDeeventos = new JLabel("Gestor AEMET v2.0 (PAA)",SwingConstants.CENTER);
  256. ventanaDeeventos.setForeground(new Color(200,200,60));
  257. ventanaDeeventos.setHorizontalAlignment(SwingConstants.CENTER);
  258. ventanaDeeventos.setVerticalAlignment(SwingConstants.CENTER);
  259. lineaDeEstado.add(ventanaDeeventos);
  260. return lineaDeEstado;
  261. }
  262.  
  263. private void guardarAntesDeSalir() {
  264.  
  265. // Guardar almacen
  266. almacen.guardar(FICHERO);
  267. System.out.println("Gracias por utilizar nuestro programa");
  268. }
  269.  
  270. class Controller implements ActionListener {
  271. @Override
  272. public void actionPerformed(ActionEvent e) {
  273. String nombre = e.getActionCommand();
  274. EvaluarAccion(nombre);
  275. }
  276.  
  277. public void EvaluarAccion(String accion) {
  278.  
  279. switch (accion) {
  280. case "Guardar":
  281. almacen.guardar(FICHERO);
  282. JOptionPane.showMessageDialog(null, "El almacen ha sido guardado", "Guardado", DISPOSE_ON_CLOSE);
  283. break;
  284. case "Cargar":
  285. almacen = RecuperarAlmacenPoblaciones();
  286. break;
  287. case "Salir":
  288. System.exit(0);
  289. break;
  290. case "Crear provincia":
  291. String crearProvincia = JOptionPane.showInputDialog(null,"Provincia:","Nueva provincia",JOptionPane.QUESTION_MESSAGE);
  292. if((crearProvincia != null)&&(!crearProvincia.equals(""))){
  293. almacen.addProvincia(crearProvincia);
  294. CrearArbol();
  295. modelo.reload();
  296. }else{
  297. JOptionPane.showMessageDialog(null, "Error al crear provincia", "Error", DISPOSE_ON_CLOSE);
  298. }
  299. break;
  300. case "Borrar provincia":
  301. String borrarProvincia = JOptionPane.showInputDialog(null,"Provincia:","Eliminar provincia",JOptionPane.QUESTION_MESSAGE);
  302. if((borrarProvincia != null)&&(!borrarProvincia.equals(""))){
  303. almacen.delProvincia(borrarProvincia);
  304. CrearArbol();
  305. }else{
  306. JOptionPane.showMessageDialog(null, "Error al borrar provincia", "Error", DISPOSE_ON_CLOSE);
  307. }
  308. break;
  309. case "Crear poblacion":
  310. new VentanaCrearPoblacion(gui,almacen).setVisible(true);
  311. CrearArbol();
  312. break;
  313. case "Borrar poblacion":
  314. new VentanaBorrarPoblacion(gui,almacen).setVisible(true);
  315. CrearArbol();
  316. break;
  317. case "Ordenar por nombre":
  318. break;
  319. case "Ordenar por habitantes":
  320. break;
  321. case "Modificar poblacion":
  322. break;
  323. case "Mover poblacion":
  324. break;
  325. case "Actualizar Predicción":
  326. try {
  327. Poblacion poblacion = (Poblacion) almacen.getPoblacion(selectedNode.getParent().toString(), nombrePoblacion);
  328. System.out.println(poblacion.getCodigoAEMET());
  329. if(poblacion.getPrediccion()==null){
  330. listaPredicciones = gestor.getPredicciones( poblacion );
  331. poblacion.lista = listaPredicciones;
  332. }else{
  333.  
  334. }
  335. } catch( NullPointerException | GestorAEMETException gae ) {
  336. JOptionPane.showMessageDialog(null, gae, "Error", DISPOSE_ON_CLOSE);
  337.  
  338. }
  339.  
  340.  
  341. break;
  342. case "Acerca de" :
  343. new VentanaAcercaDe(gui);
  344. break;
  345. }
  346. }
  347. }
  348. /**
  349. * Clase que implementa la acción del menú "acerca de".
  350. */
  351. class AcercaDe implements ActionListener { // Clase interna
  352. @Override
  353. public void actionPerformed(ActionEvent e) {
  354. VentanaAcercaDe ventanaAcercaDe = new VentanaAcercaDe(
  355. InterfazAWT_AEMET.this);
  356. ventanaAcercaDe.setVisible(true);
  357. }
  358. }// Acerca de
  359.  
  360. /**
  361. * Método main.
  362. * @throws GestorAEMETException
  363. */
  364. public static void main(String[] args) throws GestorAEMETException {
  365.  
  366. InterfazAWT_AEMET mimarco = new InterfazAWT_AEMET("Gestor AEMET", 1000,
  367. 500);
  368. mimarco.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
  369. mimarco.setVisible(true);
  370. } // Main
  371. }
  372.  


tablemodel:

Código
  1. package principal;
  2.  
  3. import java.util.Iterator;
  4.  
  5. import javax.swing.table.AbstractTableModel;
  6.  
  7. import paa.provincias.IPrediccion;
  8.  
  9. public class TableModel extends AbstractTableModel{
  10.  
  11. /**
  12. *
  13. */
  14. private static final long serialVersionUID = 1L;
  15. String columnas[] = {"Fecha", "Temp. Mínima", "Temp. Máxima", "Icono","Estado del cielo"};
  16. Object[][] data;
  17. public java.util.List<IPrediccion> predicciones;
  18.  
  19. public TableModel() {
  20. data = new Object[7][5];
  21. for(int i = 0; i < 7; i++ ){
  22. for(int j = 0; j < 5;j++){
  23. data[i][j] = new String("*");
  24. }
  25. }
  26. }
  27.  
  28. @Override
  29. public int getColumnCount() {
  30. return columnas.length;
  31. }
  32.  
  33. @Override
  34. public int getRowCount() {
  35. return data.length;
  36. }
  37.  
  38. @Override
  39. public Object getValueAt(int row, int col) {
  40.  
  41. return data[row][col];
  42. }
  43.  
  44. @Override
  45. public String getColumnName(int col){
  46. return columnas[col];
  47. }
  48.  
  49. @Override
  50. public Class getColumnClass(int c){
  51. return getValueAt(0,c).getClass();
  52. }
  53.  
  54. //public boolean isCellEditable(int row,int col){}
  55. @Override
  56. public void setValueAt(Object value, int row, int col){
  57. data[row][col] = value;
  58. fireTableCellUpdated(row,col);
  59. }
  60.  
  61. private void printDebugData() {
  62. int numRows = getRowCount();
  63.    int numCols = getColumnCount();
  64.  
  65.    for (int i = 0; i < numRows; i++) {
  66.      System.out.print("    row " + i + ":");
  67.      for (int j = 0; j < numCols; j++) {
  68.        System.out.print("  " + data[i][j]);
  69.      }
  70.      System.out.println();
  71.    }
  72.    System.out.println("--------------------------");
  73. }
  74.  
  75. public void rellenar(java.util.List<IPrediccion> prediccion){
  76. Iterator<IPrediccion> it;
  77. it = prediccion.iterator();
  78.  
  79. int i = 0;
  80. int j;
  81. while (it.hasNext()){
  82. //Recorremos la lista y colocamos en las celdas de cada fila los datos de las predicciones
  83. IPrediccion pre = it.next();
  84. j=0;
  85. setValueAt(pre.getFecha(), i, j);
  86. j++;
  87. setValueAt(pre.getTemperaturaMinima(), i, j);
  88. j++;
  89. setValueAt(pre.getTemperaturaMaxima(), i, j);
  90. j++;
  91. setValueAt(pre.getIconoEstadoCielo(), i, j);
  92. j++;
  93. setValueAt(pre.getEstadoCielo(), i, j);
  94. j++;
  95. i++;
  96. }
  97. }
  98.  
  99.  
  100. }
  101.  
4  Programación / Java / Re: Aplicacion en swing para mostrar el tiempo de provincias y poblaciones en: 13 Abril 2015, 19:11 pm
he conseguido solucionar el problema del jsplit y ya funciona, ahora viene lo que me queda, la tabla, la cual me esta dando muchos quebraderos de cabeza, tengo esto:


y tengo que llegar a esto:



y ahora explico como debe de hacerse:

El boton actualizar prediccion ha de utilizar un paquete .jar que nos dan pedefinido y en el cual hay 2 metodos necesarios, el primero, getPredicciones que me devuelve una lista de las predicciones con una semana de margen, las cuales tengo que colocar en cada casilla de la tabla al darle al boton actualizar y ademas colocar el icono del tiempo en funcion de la prediccion que tambien viene dado por el metodo getIcono.


pero hay un pero y es que si ya se ha dado al boton actualizar y se vuelve a pulsar debe de mostrar la tabla que ya habia la primera vez y no volver a actualizar ya que al no haber datos que actualizar seria un malgasto de internet, solo debe de actuar el boton actualizar cuando haya pasado el tiempo suficiente para que haya nuevas predicciones, es decir 1 dia.

hasta aqui lo que debe de hacer, tengo todo pero la tabla no consigo hacerla, para empezar no soy capaz de dibujar los nombres de las columnas, he copiado el codigo de las columnas predefinido para probar pero no se como voy a meter en la tabla los datos de las predicciones y el icono, pongo el codigo que tengo hasta ahora:

clase principal:
Código
  1. package principal;
  2. import java.awt.*;
  3. import java.awt.event.*;
  4. import java.util.ArrayList;
  5.  
  6. import javax.swing.BorderFactory;
  7. import javax.swing.Icon;
  8. import javax.swing.ImageIcon;
  9. import javax.swing.JButton;
  10. import javax.swing.JFrame;
  11. import javax.swing.JLabel;
  12. import javax.swing.JMenu;
  13. import javax.swing.JMenuBar;
  14. import javax.swing.JMenuItem;
  15. import javax.swing.JOptionPane;
  16. import javax.swing.JPanel;
  17. import javax.swing.JScrollPane;
  18. import javax.swing.JSplitPane;
  19. import javax.swing.JTable;
  20. import javax.swing.JToolBar;
  21. import javax.swing.JTree;
  22. import javax.swing.SwingConstants;
  23. import javax.swing.WindowConstants;
  24. import javax.swing.border.Border;
  25. import javax.swing.border.CompoundBorder;
  26. import javax.swing.border.EtchedBorder;
  27. import javax.swing.event.TreeSelectionEvent;
  28. import javax.swing.event.TreeSelectionListener;
  29. import javax.swing.table.AbstractTableModel;
  30. import javax.swing.table.DefaultTableModel;
  31. import javax.swing.tree.DefaultMutableTreeNode;
  32. import javax.swing.tree.DefaultTreeModel;
  33. import javax.swing.tree.TreeSelectionModel;
  34.  
  35. import Poblacion.VentanaBorrarPoblacion;
  36. import Poblacion.VentanaCrearPoblacion;
  37. import paa.provincias.GestorAEMET;
  38. import paa.provincias.GestorAEMETException;
  39. import paa.provincias.IPoblacion;
  40. import paa.provincias.IPoblacionAEMET;
  41. import paa.provincias.IPrediccion;
  42.  
  43.  
  44. /**
  45.  * Fichero: InterfazAWT_AEMET.java Clase que implementa la Interfaz Gráfica
  46.  * AEMET con awt.
  47.  *
  48.  * @author PAA
  49.  * @version 1.0
  50.  */
  51. public class InterfazAWT_AEMET extends JFrame {
  52. /**
  53. *
  54. */
  55. private static final long serialVersionUID = 502635761186556414L;
  56.  
  57. private static final String FICHERO = "almacen.dat";
  58. private AlmacenPoblaciones almacen;
  59.  
  60. // private IAlmacenPoblaciones almacenPoblaciones;
  61. private List listaPoblaciones = new List();
  62. private List listaPredicciones = new List();
  63. private List listaProvincias = new List();
  64. private InterfazAWT_AEMET gui;
  65. private GestorAEMET gestor = new GestorAEMET();
  66. private JTree tree;
  67. private JPanel panel;
  68. private JTable tabla;
  69. /**
  70. * Constructor.
  71. *
  72. * @throws GestorAEMETException
  73. */
  74. public InterfazAWT_AEMET(String titulo, int ancho, int alto) {
  75. super(titulo);
  76. setSize(ancho, alto);
  77. setLocationRelativeTo(null);
  78. setLayout(new BorderLayout()); // Layout de la aplicación, podría ser otro
  79. almacen = RecuperarAlmacenPoblaciones();
  80. initComponents();
  81. JFrame.setDefaultLookAndFeelDecorated(true);
  82. }
  83.  
  84. public AlmacenPoblaciones RecuperarAlmacenPoblaciones() {
  85. // Recuperamos el almacén
  86. AlmacenPoblaciones almacenPoblaciones1 = new AlmacenPoblaciones();
  87.  
  88. if (almacenPoblaciones1.recuperar(FICHERO)){
  89. Icon icono= new ImageIcon(getClass().getResource("/iconos/check.png"));
  90. JOptionPane.showMessageDialog(null, "Recuperado el almacen del fichero " + FICHERO, "Recuperado",JOptionPane.INFORMATION_MESSAGE,icono);
  91. }else{
  92. JOptionPane.showMessageDialog(null, "No se ha podido recuperar el almacen del fichero" + FICHERO, "Error",JOptionPane.ERROR_MESSAGE);
  93.  
  94. }return almacenPoblaciones1;
  95.  
  96. }
  97.  
  98. public void initComponents() {
  99. // Boton salir por defecto
  100. this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  101. setJMenuBar(addJMenuBar());
  102. this.add(addJToolBar(), BorderLayout.NORTH);
  103. this.add(addlineaEstado(), BorderLayout.SOUTH);
  104.  //Creamos el splitpanel y lo colocamos en medio del jtree y la tabla, despues lo añadimos al Jframe
  105.    JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,addPanelIzquierda(),addpredicciones());
  106.    splitPane.setOneTouchExpandable(true);
  107.    splitPane.setDividerLocation(100);
  108.    splitPane.setDividerSize(10);
  109.    this.add(splitPane,BorderLayout.CENTER);
  110. }
  111.  
  112. private JMenuBar addJMenuBar() {
  113. // Sitúo los menús desplegables
  114. JMenuBar barraDeMenu = new JMenuBar();
  115. // Creo el menú Archivo
  116. JMenu menuArchivo = new JMenu("Archivo");
  117. JMenuItem crearGuardar = new JMenuItem("Guardar");
  118. JMenuItem crearCargar = new JMenuItem("Cargar");
  119. JMenuItem salir = new JMenuItem("Salir");
  120. crearCargar.addActionListener(new Controller());
  121. crearGuardar.addActionListener(new Controller());
  122. salir.addActionListener(new Controller());
  123. menuArchivo.add(crearCargar);
  124. menuArchivo.add(crearGuardar);
  125. menuArchivo.add(salir);
  126.  
  127. // Creo el menú Provincias
  128. JMenu menuProvincias = new JMenu("Provincias");
  129. JMenuItem crearProvincias = new JMenuItem("Crear provincia");
  130. JMenuItem borrarProvincias = new JMenuItem("Borrar provincia");
  131. crearProvincias.addActionListener(new Controller());
  132. borrarProvincias.addActionListener(new Controller());
  133. menuProvincias.add(crearProvincias);
  134. menuProvincias.add(borrarProvincias);
  135.  
  136. // Creo el menu Poblaciones
  137. JMenu menuPoblaciones = new JMenu("Poblaciones");
  138. JMenuItem crearPoblacion = new JMenuItem("Crear poblacion");
  139. JMenuItem borrarPoblacion = new JMenuItem("Borrar poblacion");
  140. JMenuItem ordenarNombre = new JMenuItem("Ordenar por nombre");
  141. JMenuItem ordenarHabitantes = new JMenuItem("Ordenar por habitantes");
  142. JMenuItem modPoblacion = new JMenuItem("Modificar poblacion");
  143. JMenuItem movPoblacion = new JMenuItem("Mover poblacion");
  144. crearPoblacion.addActionListener(new Controller());
  145. borrarPoblacion.addActionListener(new Controller());
  146. ordenarNombre.addActionListener(new Controller());
  147. ordenarHabitantes.addActionListener(new Controller());
  148. modPoblacion.addActionListener(new Controller());
  149. movPoblacion.addActionListener(new Controller());
  150. menuPoblaciones.add(crearPoblacion);
  151. menuPoblaciones.add(borrarPoblacion);
  152. menuPoblaciones.add(ordenarNombre);
  153. menuPoblaciones.add(ordenarHabitantes);
  154. menuPoblaciones.add(modPoblacion);
  155. menuPoblaciones.add(movPoblacion);
  156.  
  157. // Creo el menú de ayuda
  158. JMenu ayuda = new JMenu("Ayuda");
  159. JMenuItem acercaDe = new JMenuItem("Acerca de");
  160. acercaDe.addActionListener(new AcercaDe());
  161. ayuda.add(acercaDe);
  162.  
  163. // Crea el
  164. barraDeMenu.add(menuArchivo);
  165. barraDeMenu.add(menuProvincias);
  166. barraDeMenu.add(menuPoblaciones);
  167. barraDeMenu.add(ayuda);
  168. return barraDeMenu;
  169. }
  170.  
  171. private JToolBar addJToolBar() {
  172. // Sitúo la línea de botones
  173. JToolBar lineaDeBotones = new JToolBar();
  174. lineaDeBotones.setBackground(new Color(200,100,100));
  175.  
  176. // Boton crear provincia
  177. Icon Iprovincia= new ImageIcon(getClass().getResource("/iconos/provincia.png"));
  178. JButton proCrear = new JButton("Crear provincia",Iprovincia);
  179. proCrear.addActionListener(new Controller());
  180.  
  181. // Boton crear poblacion
  182. Icon Ipoblacion= new ImageIcon(getClass().getResource("/iconos/poblacion.png"));
  183. JButton poCrear = new JButton("Crear poblacion",Ipoblacion);
  184. poCrear.addActionListener(new Controller());
  185.  
  186. // Boton actualizar prediccion
  187. Icon actualizar= new ImageIcon(getClass().getResource("/iconos/actualizar.png"));
  188.  
  189. JButton aPrediccion = new JButton("Actualizar Predicción",actualizar);
  190. aPrediccion.setToolTipText("Click para actualizar las predicciones");
  191. aPrediccion.addActionListener(new Controller());
  192.  
  193. // Añadir los botones a la barra
  194. lineaDeBotones.add(proCrear);
  195. lineaDeBotones.add(poCrear);
  196. lineaDeBotones.add(aPrediccion);
  197. return lineaDeBotones;
  198. }
  199.  
  200. private JPanel addPanelIzquierda() {
  201. // Construccion del arbol
  202.        DefaultMutableTreeNode provinciasPrincipal = new DefaultMutableTreeNode("Provincias");
  203.        DefaultTreeModel modelo = new DefaultTreeModel(provinciasPrincipal);
  204.        tree = new JTree(modelo);
  205.        panel = new JPanel();
  206.        // Construccion de los datos del arbol
  207.  
  208.        for(String s : almacen.getProvincias()){
  209.         int j = 0;
  210.         DefaultMutableTreeNode provincia = new DefaultMutableTreeNode(s);
  211.         modelo.insertNodeInto(provincia, provinciasPrincipal, j);
  212.         j++;
  213.         for(IPoblacion i : almacen.getPoblaciones(s)){
  214.         int x = 0;
  215.         DefaultMutableTreeNode poblacion = new DefaultMutableTreeNode(i.getNombre());
  216.         modelo.insertNodeInto(poblacion, provincia, x);
  217.         x++;
  218.         }
  219.        }
  220.        tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
  221.        tree.addTreeSelectionListener(new TreeSelectionListener(){
  222. @Override
  223. public void valueChanged(TreeSelectionEvent se) {
  224. JTree tree = (JTree) se.getSource();
  225.    DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
  226.    String selectedNodeName = selectedNode.toString();
  227.    if (selectedNode.isLeaf()) {
  228.      System.out.println(selectedNodeName);
  229.    }
  230. }
  231.        });
  232.        panel.setBorder(BorderFactory.createLineBorder(Color.blue));
  233.        panel.add(tree);
  234.  
  235.        panel.setBackground(Color.WHITE);
  236. return panel;
  237. }
  238.  
  239. private JPanel addpredicciones() {
  240. // Creamos la tabla de las predicciones
  241. JPanel predicciones = new JPanel(new BorderLayout());
  242. String columnas[] = {"Fecha", "Temp. Mínima", "Temp. Máxima", "Icono","Estado del cielo"};
  243. Object[][] data = {
  244.    {"Kathy", "Smith",
  245.        "Snowboarding", new Integer(5), new Boolean(false)},
  246.       {"John", "Doe",
  247.        "Rowing", new Integer(3), new Boolean(true)},
  248.       {"Sue", "Black",
  249.        "Knitting", new Integer(2), new Boolean(false)},
  250.       {"Jane", "White",
  251.        "Speed reading", new Integer(20), new Boolean(true)},
  252.       {"Joe", "Brown",
  253.        "Pool", new Integer(10), new Boolean(false)}
  254.   };
  255.  
  256.  
  257. TableModel d = new TableModel(data,columnas);
  258. tabla = new JTable(d);
  259. JLabel lPrediccion = new JLabel("Predicciones de :");
  260. //predicciones.add(lPrediccion, BorderLayout.NORTH);
  261. predicciones.add(lPrediccion,BorderLayout.NORTH);
  262. predicciones.add(tabla,BorderLayout.CENTER);
  263. predicciones.setBackground(Color.white);
  264. predicciones.setBorder(BorderFactory.createLineBorder(Color.blue));
  265. return predicciones;
  266. }
  267.  
  268. private JPanel addlineaEstado() {
  269. // Sitúo la línea de estado
  270. JPanel lineaDeEstado = new JPanel();
  271. lineaDeEstado.setLayout(new FlowLayout(FlowLayout.LEFT));
  272. lineaDeEstado.setBackground(new Color(0,80,80));
  273. JLabel ventanaDeeventos = new JLabel("Gestor AEMET v2.0 (PAA)",SwingConstants.CENTER);
  274. ventanaDeeventos.setForeground(new Color(200,200,60));
  275. ventanaDeeventos.setHorizontalAlignment(SwingConstants.CENTER);
  276. ventanaDeeventos.setVerticalAlignment(SwingConstants.CENTER);
  277. lineaDeEstado.add(ventanaDeeventos);
  278. return lineaDeEstado;
  279. }
  280.  
  281. private void guardarAntesDeSalir() {
  282.  
  283. // Guardar almacen
  284. almacen.guardar(FICHERO);
  285. System.out.println("Gracias por utilizar nuestro programa");
  286. }
  287.  
  288. class Controller implements ActionListener {
  289. public void actionPerformed(ActionEvent e) {
  290. String nombre = e.getActionCommand();
  291. EvaluarAccion(nombre);
  292. }
  293.  
  294. public void EvaluarAccion(String accion) {
  295.  
  296. switch (accion) {
  297. case "Guardar":
  298. almacen.guardar(FICHERO);
  299. JOptionPane.showMessageDialog(null, "El almacen ha sido guardado", "Guardado", DISPOSE_ON_CLOSE);
  300. break;
  301. case "Cargar":
  302. almacen = RecuperarAlmacenPoblaciones();
  303. break;
  304. case "Salir":
  305. System.exit(0);
  306. break;
  307. case "Crear provincia":
  308. String crearProvincia = JOptionPane.showInputDialog(null,"Provincia:","Nueva provincia",JOptionPane.QUESTION_MESSAGE);
  309. if((crearProvincia != null)&&(!crearProvincia.equals(""))){
  310. almacen.addProvincia(crearProvincia);
  311. }else{
  312. JOptionPane.showMessageDialog(null, "Error al crear provincia", "Error", DISPOSE_ON_CLOSE);
  313. }
  314. break;
  315. case "Borrar provincia":
  316. String borrarProvincia = JOptionPane.showInputDialog(null,"Provincia:","Eliminar provincia",JOptionPane.QUESTION_MESSAGE);
  317. if((borrarProvincia != null)&&(!borrarProvincia.equals(""))){
  318. almacen.delProvincia(borrarProvincia);
  319. }else{
  320. JOptionPane.showMessageDialog(null, "Error al borrar provincia", "Error", DISPOSE_ON_CLOSE);
  321. }
  322. break;
  323. case "Crear poblacion":
  324. new VentanaCrearPoblacion(gui,almacen).setVisible(true);
  325. break;
  326. case "Borrar poblacion":
  327. new VentanaBorrarPoblacion(gui,almacen).setVisible(true);
  328. break;
  329. case "Ordenar por nombre":
  330. break;
  331. case "Ordenar por habitantes":
  332. break;
  333. case "Modificar poblacion":
  334. break;
  335. case "Mover poblacion":
  336. break;
  337. case "Actualizar Predicción":
  338. IPoblacion poblacion = almacen.getPoblacion(listaProvincias.getSelectedItem(), listaPoblaciones.getSelectedItem());
  339. try {
  340. listaPredicciones.removeAll();
  341. for(IPrediccion p : gestor.getPredicciones((IPoblacionAEMET) poblacion)){
  342. listaPredicciones.add(p.getFecha() + " : " + p.getEstadoCielo() + " : " +
  343. p.getTemperaturaMaxima() + " : " + p.getTemperaturaMinima());
  344. }
  345. } catch (GestorAEMETException e) {
  346. new Aviso(gui,e.getMessage());
  347. }
  348. break;
  349. case "Acerca de" :
  350. new VentanaAcercaDe(gui);
  351. break;
  352. }
  353. }
  354. }
  355.  
  356.  
  357.  
  358.  
  359.  
  360. String columnas[] = {"Fecha", "Temp. Mínima", "Temp. Máxima", "Icono","Estado del cielo"};
  361. Object[][] data;
  362. public boolean cellEditable = false;
  363. public java.util.List<IPrediccion> dataArray = null;
  364.  
  365. public TableModel(Object[][] data2, String[] columnas2) {
  366. data = data2;
  367. columnas = columnas2;
  368. }
  369.  
  370. public int getColumnCount() {
  371. return columnas.length;
  372. }
  373.  
  374. @Override
  375. public int getRowCount() {
  376. return data.length;
  377. }
  378.  
  379. @Override
  380. public Object getValueAt(int arg0, int arg1) {
  381.  
  382. return data[arg0][arg1];
  383. }
  384.  
  385. public void setValueAt(Object value, int row, int col){
  386. data[row][col] = value;
  387. fireTableCellUpdated(row,col);
  388. }
  389.  
  390. }
  391. /**
  392. * Clase que implementa la acción del menú "acerca de".
  393. */
  394. class AcercaDe implements ActionListener { // Clase interna
  395. public void actionPerformed(ActionEvent e) {
  396. VentanaAcercaDe ventanaAcercaDe = new VentanaAcercaDe(
  397. InterfazAWT_AEMET.this);
  398. ventanaAcercaDe.setVisible(true);
  399. }
  400. }// Acerca de
  401.  
  402. /**
  403. * Método main.
  404. * @throws GestorAEMETException
  405. */
  406. public static void main(String[] args) throws GestorAEMETException {
  407.  
  408. InterfazAWT_AEMET mimarco = new InterfazAWT_AEMET("Gestor AEMET", 1000,
  409. 500);
  410. mimarco.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
  411. mimarco.setVisible(true);
  412. } // Main
  413. }
  414.  

clase prediccion:

Código
  1. package principal;
  2. import javax.swing.ImageIcon;
  3.  
  4. import paa.provincias.IPrediccion;
  5.  
  6. public class Prediccion implements IPrediccion {
  7.  
  8. private String estadoCielo;
  9. private String fecha;
  10. private String poblacion;
  11. private String provincia;
  12. private String temperaturaMaxima;
  13. private String temperaturaMinima;
  14. private ImageIcon icono;
  15.  
  16. public Prediccion() {
  17.  
  18. }
  19.  
  20. public String getEstadoCielo() {
  21. return estadoCielo;
  22. }
  23.  
  24. public String getFecha() {
  25. return fecha;
  26. }
  27.  
  28. public String getPoblacion() {
  29. return poblacion;
  30. }
  31.  
  32. public String getProvincia() {
  33. return provincia;
  34. }
  35.  
  36. public String getTemperaturaMaxima() {
  37. return temperaturaMaxima;
  38. }
  39.  
  40. public String getTemperaturaMinima() {
  41. return temperaturaMinima;
  42. }
  43.  
  44. public String toString(){
  45. return fecha + " : " + estadoCielo + " : " + temperaturaMaxima + " : " + temperaturaMinima;
  46.  
  47. }
  48.  
  49. public ImageIcon getIconoEstadoCielo() {
  50. return icono;
  51. }
  52.  
  53. }
  54.  

clase poblacion

Código
  1. package principal;
  2. import java.io.Serializable;
  3. import java.util.List;
  4.  
  5. import paa.provincias.IPoblacion;
  6. import paa.provincias.IPoblacionAEMET;
  7. import paa.provincias.IPrediccion;
  8.  
  9. /**
  10.  * Clase que modela una poblacion con nombre,numero de habitantes y provicnia
  11.  * asociada
  12.  *
  13.  * @author kikian
  14.  *
  15.  */
  16. public class Poblacion implements IPoblacion, Comparable<Poblacion>,
  17. Serializable, IPoblacionAEMET {
  18.  
  19. /**
  20. *
  21. */
  22. private static final long serialVersionUID = 1L;
  23. private String nombre;
  24. private int habitantes;
  25. private String provincia;
  26. private String codigoAEMET;
  27. public List<IPrediccion> lista = null;
  28.  
  29. /**
  30. * Crea una poblacion con los valores que se le pasan como parametros
  31. *
  32. * @param nombre
  33. *            - nombre de la poblacion
  34. * @param habitantes
  35. *            - Numero de habitantes
  36. * @param provincia
  37. *            - provincia a la que pertenece la poblacion
  38. */
  39. public Poblacion(String nombre, int habitantes, String provincia,
  40. String codigoAEMET) {
  41. this.nombre = nombre;
  42. this.habitantes = habitantes;
  43. this.provincia = provincia;
  44. this.codigoAEMET = codigoAEMET;
  45. }
  46.  
  47. /**
  48. * Crea una poblacion a partir del codigo AEMET
  49. *
  50. * @param codigoAEMET
  51. */
  52. public Poblacion(String codigoAEMET) {
  53. this.codigoAEMET = codigoAEMET;
  54. }
  55.  
  56. /**
  57. * Devuelve el número de habitantes de la población
  58. */
  59. public int getHabitantes() {
  60. return habitantes;
  61. }
  62.  
  63. /**
  64. * Devuelve el nombre de la población
  65. */
  66. public String getNombre() {
  67. return nombre;
  68. }
  69.  
  70. /**
  71. * Devuelve la provincia a la que pertenece la población
  72. */
  73. public String getProvincia() {
  74. return provincia;
  75. }
  76.  
  77. /**
  78. * Actualiza el número de habitantes de la población
  79. *
  80. * @param habitantes
  81. *            - habitantes que tiene la poblacion
  82. */
  83. public void setHabitantes(int habitantes) {
  84. this.habitantes = habitantes;
  85. }
  86.  
  87. /**
  88. * Actualiza el nombre de la población
  89. *
  90. * @param nombre
  91. *            -nombre que tendra la poblacion
  92. */
  93. public void setNombre(String nombre) {
  94. this.nombre = nombre;
  95. }
  96.  
  97. /**
  98. * Actualiza la provincia a la que pertenece la población
  99. *
  100. * @param provincia
  101. *            - Provincia a la que cambiaremos la poblacion
  102. */
  103. public void setProvincia(String provincia) {
  104. this.provincia = provincia;
  105. }
  106.  
  107. /**
  108. * Devuelve un string con la informacion de la poblacion
  109. */
  110. public String toString() {
  111. return this.nombre + "," + this.habitantes + "," + this.provincia;
  112. }
  113.  
  114. /**
  115. * Metodo para comparar las poblaciones y ordenarlas por defecto por el
  116. * nombre de la poblacion
  117. *
  118. * @param arg0
  119. *            - poblacion que vamos a comparar
  120. */
  121. public int compareTo(Poblacion arg0) {
  122. int res = 0;
  123. if (arg0 == null) {
  124. throw new NullPointerException();
  125. } else {
  126. res = this.nombre.compareTo(arg0.nombre);
  127. return res;
  128. }
  129. }
  130.  
  131. @Override
  132. public String getCodigoAEMET() {
  133. return codigoAEMET;
  134. }
  135.  
  136. public void setPrediccion(List<IPrediccion> lista){
  137. this.lista = lista;
  138. }
  139.  
  140. public List<IPrediccion> getPrediccion(){
  141. return lista;
  142. }
  143. }
  144.  

clase almacenpoblaciones

Código
  1. package principal;
  2. import java.io.FileInputStream;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  5. import java.io.ObjectInputStream;
  6. import java.io.ObjectOutputStream;
  7. import java.io.Serializable;
  8. import java.util.Comparator;
  9. import java.util.HashMap;
  10. import java.util.Iterator;
  11.  
  12. import java.util.Map;
  13. import java.util.Set;
  14. import java.util.SortedSet;
  15. import java.util.TreeSet;
  16.  
  17. import paa.provincias.IAlmacenPoblaciones;
  18. import paa.provincias.IPoblacion;
  19. import paa.provincias.IPoblacionAEMET;
  20.  
  21. /**
  22.  * Clase que modela un almacen de poblaciones
  23.  *
  24.  * @author kikian
  25.  *
  26.  */
  27. public class AlmacenPoblaciones implements IAlmacenPoblaciones, Serializable,
  28. IPoblacionAEMET {
  29.  
  30. /**
  31. *
  32. */
  33. private static final long serialVersionUID = 1L;
  34. private Map<String, SortedSet<IPoblacion>> Aprovincias;
  35.  
  36. /**
  37. * Ordenación principal en orden alfabético por el campo nombre de la
  38. * población.
  39. */
  40. final static int ORDENARPORNOMBRE = 2;
  41.  
  42. /**
  43. * Ordenación principal por el número de habitantes en sentido ascendente,
  44. * en segundo lugar, en caso de igualdad, por el orden alfabético del campo
  45. * nombre.
  46. */
  47. final static int ORDENARPORHABITANTES = 3;
  48.  
  49. /**
  50. * Constructor de la clase AlmacenPoblaciones
  51. */
  52. public AlmacenPoblaciones() {
  53. Aprovincias = new HashMap<String, SortedSet<IPoblacion>>();
  54. }
  55.  
  56.  
  57. /**
  58. * Añade una población a la provincia correspondiente si la población no
  59. * existe ya en ella, o sea, no hay ya otra población con el mismo nombre.
  60. * Las poblaciones se almacenarán ordenadas según el criterio de ordenación
  61. * definido.
  62. *
  63. * @param provincia
  64. *            - Provincia en la que se añadira la poblacion
  65. * @param poblacion
  66. *            - Poblacion a añadir
  67. */
  68. public boolean addPoblacion(String provincia, IPoblacion poblacion) {
  69. boolean res = false;
  70. if (provincia == null || poblacion == null
  71. || !Aprovincias.containsKey(provincia)) {
  72. res = false;
  73. System.out.println("La Provincia no existe, creela antes de añadir poblacion");
  74. } else {
  75. SortedSet<IPoblacion> sPoblacion = Aprovincias.get(provincia);
  76. sPoblacion.add(poblacion);
  77. Aprovincias.put(provincia, sPoblacion);
  78. res = true;
  79. }
  80. return res;
  81. }
  82.  
  83. /**
  84. * Añade una nuevo provincia al almacén de poblaciones si no está ya
  85. * presente en el almacén. Si ya había una del mismo nombre no se realiza
  86. * ningún cambio en el almacén y la llamada devuelve false.
  87. *
  88. * @param provincia
  89. *            - La provincia que queremos añadir
  90. */
  91. public boolean addProvincia(String provincia) {
  92. boolean res = false;
  93. if (Aprovincias.containsKey(provincia)) {
  94. System.out.println("Ya existe la provincia");
  95. } else {
  96. Aprovincias.put(provincia, new TreeSet<IPoblacion>());
  97. res = true;
  98. }
  99. return res;
  100. }
  101.  
  102. /**
  103. * Indica si ya existe en la provincia una población con ese nombre.
  104. *
  105. * @param provincia
  106. *            - Nombre de la provincia en la que vamos a buscar
  107. * @param poblacion
  108. *            - Nombre de la poblacion que queremos buscar
  109. */
  110. public boolean containsPoblacion(String provincia, String poblacion) {
  111. boolean res = false;
  112. if (provincia == null || !Aprovincias.containsKey(provincia)) {
  113. System.out
  114. .println("La provincia no existe, creela antes de eliminar poblacion");
  115. } else {
  116. SortedSet<IPoblacion> sPoblacion = Aprovincias.get(provincia);
  117. for (IPoblacion p : sPoblacion) {
  118. if (p.getNombre() == poblacion) {
  119. res = true;
  120. }
  121. }
  122. }
  123. return res;
  124. }
  125.  
  126. /**
  127. * Indica si ya existe en la provincia una población.
  128. *
  129. * @param provincia
  130. *            - La provincia en la que buscaremos
  131. * @param poblacion
  132. *            - La poblacion que queremos buscar
  133. */
  134. public boolean containsPoblacion(String provincia, IPoblacion poblacion) {
  135. boolean res = false;
  136. if (provincia == null || !Aprovincias.containsKey(provincia)) {
  137. System.out
  138. .println("La provincia no existe, creela antes de eliminar poblacion");
  139. } else {
  140. SortedSet<IPoblacion> sPoblacion = Aprovincias.get(provincia);
  141. if (sPoblacion.contains(poblacion)) {
  142. res = true;
  143. }
  144. }
  145. return res;
  146. }
  147.  
  148. /**
  149. * Indica si ya existe en el almacén la provincia correspondiente.
  150. *
  151. * @param provincia
  152. *            - La provincia que queremos comprobar
  153. */
  154. public boolean containsProvincia(String provincia) {
  155. boolean res = false;
  156. if (Aprovincias.containsKey(provincia)) {
  157. res = true;
  158. System.out.println("La provincia esta en el almacen");
  159. } else {
  160. System.out.println("La provincia no esta en el almacen");
  161. }
  162. return res;
  163. }
  164.  
  165. /**
  166. * Borra la población situada en la posición correspondiente dentro de la
  167. * provincia. La posición es un entero entre 1 y el número de poblaciones
  168. * que contiene la provincia. La posición de una población es variable,
  169. * puesto que cambia si se borran poblaciones de la provincia o se reordena.
  170. *
  171. * @param provincia
  172. *            - Provincia en la que buscaremos la poblacion
  173. * @param posicion
  174. *            - posicion de la poblacion que sera borrada
  175. */
  176. public boolean delPoblacion(String provincia, int posicion) {
  177. if (!Aprovincias.containsKey(provincia)) {
  178. System.out.println("No existe la provincia");
  179. return false;
  180. } else {
  181. SortedSet<IPoblacion> sPoblacion = Aprovincias.get(provincia);
  182. Iterator<IPoblacion> ite = sPoblacion.iterator();
  183. int contador = 1;
  184. while (ite.hasNext() && contador < posicion) {
  185. ite.next();
  186. contador++;
  187. }
  188. if (ite.hasNext() && contador == posicion) {
  189. ite.next();
  190. ite.remove();
  191. Aprovincias.put(provincia, sPoblacion);
  192. return true;
  193. }
  194. }
  195. return false;
  196. }
  197.  
  198. /**
  199. * Borra de la provincia la población que se pasa como parámetro.
  200. *
  201. * @param provincia
  202. *            - La provincia donde buscaremos
  203. * @param poblacion
  204. *            - La poblacion que se eliminara
  205. */
  206. public boolean delPoblacion(String provincia, IPoblacion poblacion) {
  207. boolean res = false;
  208. if (!Aprovincias.containsKey(provincia)) {
  209. System.out.print("La provincia no existe");
  210. } else {
  211. SortedSet<IPoblacion> sPoblacion = Aprovincias.get(provincia);
  212. sPoblacion.remove(poblacion);
  213. Aprovincias.put(provincia, sPoblacion);
  214. }
  215. return res;
  216. }
  217.  
  218. /**
  219. * Borra de la provincia la población cuyo nombre se pasa como parámetro.
  220. *
  221. * @param provincia
  222. *            - La provincia de donde eliminaremos la poblacion
  223. * @param poblacion
  224. *            - El nombre de la poblacion
  225. */
  226. public boolean delPoblacion(String provincia, String poblacion) {
  227. if (!Aprovincias.containsKey(provincia)) {
  228. System.out.print("La provincia no existe");
  229. return false;
  230. } else {
  231. SortedSet<IPoblacion> sPoblacion = Aprovincias.get(provincia);
  232. for (IPoblacion s : sPoblacion) {
  233. if (s.getNombre().equals(poblacion)) {
  234. sPoblacion.remove(s);
  235. return true;
  236. }
  237. }
  238. return false;
  239. }
  240. }
  241.  
  242. /**
  243. * Borra un provincia del almacén de poblaciones si está presente en el
  244. * almacén. Si no hay una del mismo nombre no se realiza ningún cambio en el
  245. * almacén y la llamada devuelve false.
  246. *
  247. * @param provincia
  248. *            - La provincia que queremos eliminar
  249. */
  250. public boolean delProvincia(String provincia) {
  251. if (Aprovincias.containsKey(provincia)) {
  252. Aprovincias.remove(provincia);
  253. return true;
  254. } else {
  255. System.out.println("La provincia no esta en el almacen");
  256. return false;
  257. }
  258. }
  259.  
  260. /**
  261. * Devuelve el número de poblaciones que contiene la provincia cuyo nombre
  262. * se indica.
  263. *
  264. * @param provincia
  265. *            - La provincia de la que obtendremos el numero de poblaciones
  266. */
  267. public int getNumPoblaciones(String provincia) {
  268. SortedSet<IPoblacion> spoblacion = Aprovincias.get(provincia);
  269. return spoblacion.size();
  270. }
  271.  
  272. /**
  273. * Devuelve la población situada en la posición correspondiente dentro de la
  274. * provincia. La posición es un entero entre 1 y el número de poblaciones
  275. * que contiene la provincia. La posición de una población es variable,
  276. * puesto que cambia si se borran poblaciones de la provincia o se
  277. * reordenan.
  278. *
  279. * @param provincia
  280. *            - la provincia en la que se buscara
  281. * @param posicion
  282. *            - la posicion que se eliminara
  283. */
  284. public IPoblacion getPoblacion(String provincia, int posicion) {
  285. IPoblacion pBuscada = null;
  286. if (!Aprovincias.containsKey(provincia)) {
  287. System.out.println("No existe la provincia");
  288. } else {
  289. SortedSet<IPoblacion> sPoblacion = Aprovincias.get(provincia);
  290. Iterator<IPoblacion> ite = sPoblacion.iterator();
  291. int contador = 1;
  292. while (ite.hasNext() && contador < posicion) {
  293. ite.next();
  294. contador++;
  295. }
  296. if (ite.hasNext() && contador == posicion) {
  297. pBuscada = ite.next();
  298. ite.remove();
  299. }
  300. }
  301. return pBuscada;
  302. }
  303.  
  304. /**
  305. * Devuelve de la provincia la población que posee el nombre que se pasa
  306. * como parámetro.
  307. *
  308. */
  309. public IPoblacion getPoblacion(String provincia, String poblacion) {
  310. SortedSet<IPoblacion> spoblacion = Aprovincias.get(provincia);
  311. IPoblacion p = null;
  312. for (IPoblacion s : spoblacion) {
  313. if (s.getNombre().equals(poblacion)) {
  314. p = s;
  315. }
  316. }
  317. return p;
  318. }
  319.  
  320. /**
  321. * Devuelve todas las poblaciones de la provincia correspondiente ordenadas
  322. * según el criterio actual.
  323. *
  324. * @param provincia
  325. *            - La provincia de la que obtendremos el Set con las
  326. *            poblaciones
  327. */
  328. public SortedSet<IPoblacion> getPoblaciones(String provincia) {
  329. SortedSet<IPoblacion> spoblacion = null;
  330. if (!Aprovincias.containsKey(provincia)) {
  331. System.out.println("No existe la provincia");
  332. } else {
  333. spoblacion = Aprovincias.get(provincia);
  334. }
  335. return spoblacion;
  336. }
  337.  
  338. /**
  339. * Devuelve un conjunto con los nombres de los provincias que existen en el
  340. * almacén de poblaciones.
  341. */
  342. public Set<String> getProvincias() {
  343. Set<String> provincias = Aprovincias.keySet();
  344. return provincias;
  345. }
  346.  
  347. /**
  348. * Guarda el almacén de poblaciones en el fichero cuyo nombre se pasa como
  349. * parámetro. Devuelve true si se ha guardado correctamente y false si hay
  350. * algún tipo de error o excepción.
  351. *
  352. * @param escritura
  353. *            - nombre del fichero
  354. */
  355. public boolean guardar(String escritura) {
  356. ObjectOutputStream salida = null;
  357. try {
  358. salida = new ObjectOutputStream(new FileOutputStream(escritura));
  359. salida.writeObject(Aprovincias);
  360. } catch (Exception e) {
  361. e.printStackTrace();
  362. } finally {
  363. if (salida != null)
  364. try {
  365. salida.close();
  366. System.out.println("Guardado");
  367. return true;
  368. } catch (IOException e) {
  369. e.printStackTrace();
  370. }
  371. }
  372. return false;
  373. }
  374.  
  375. /**
  376. * Permite cambiar el criterio de ordenación de la correspondiente
  377. * provincia, las poblaciones almacenadas serán reordenadas según el nuevo
  378. * criterio de ordenación que se indica como parámetro utilizando las
  379. * constantes predefinidas: ORDENARPORNOMBRE ú ORDENARPORHABITANTES (ver su
  380. * descripción en fields).
  381. *
  382. * @param provincia
  383. *            - Provincia en la que se reordenaran las poblaciones
  384. * @param ordenarPor
  385. *            - Metodo para ordenar las poblaciones
  386. */
  387. public boolean ordenarPor(String provincia, int ordenarPor) {
  388. if (provincia != null || ordenarPor != ORDENARPORNOMBRE
  389. || ordenarPor != ORDENARPORHABITANTES) {
  390. if (ordenarPor == ORDENARPORNOMBRE) {
  391. // Metemos en un Set las poblaciones de la provincia asociada
  392. Set<IPoblacion> spoblacion = Aprovincias.get(provincia);
  393. // Creamos un nuevo Set de tipo TreeSet y le aplicamos el
  394. // criterio de ordenacion
  395. // de la clase porNombre, luego le añadimos todas las
  396. // poblaciones para que se ordenen
  397. TreeSet<IPoblacion> n1Poblacion = new TreeSet<IPoblacion>(
  398. new porNombre());
  399. n1Poblacion.addAll(spoblacion);
  400. Aprovincias.put(provincia, n1Poblacion);
  401. } else if (ordenarPor == ORDENARPORHABITANTES) {
  402. // Mismo procedimiento que ORDENARPORNOMBRE pero ahora
  403. // utilizamos el criterio de ordenacion
  404. // de la clase CompareHabitantes
  405. Set<IPoblacion> spoblacion = Aprovincias.get(provincia);
  406. TreeSet<IPoblacion> n2Poblacion = new TreeSet<IPoblacion>(
  407. new CompareHabitantes());
  408. n2Poblacion.addAll(spoblacion);
  409. Aprovincias.put(provincia, n2Poblacion);
  410. }
  411. return true;
  412. }
  413. return false;
  414. }
  415.  
  416. /**
  417. * Recupera un almacén de poblaciones del fichero cuyo nombre se pasa como
  418. * parámetro. Si el fichero no existe o hay algún tipo de excepción devuelve
  419. * false y crea un almacén vacío. Si lo recupera, devuelve true.
  420. *
  421. * @param lectura
  422. *            - Nombre del archivo que leeremos
  423. */
  424. @SuppressWarnings("unchecked")
  425. public boolean recuperar(String lectura) {
  426. ObjectInputStream entrada = null;
  427. try {
  428. entrada = new ObjectInputStream(new FileInputStream(lectura));
  429.  
  430. Aprovincias = (Map<String, SortedSet<IPoblacion>>) entrada
  431. .readObject();
  432. } catch (Exception e) {
  433. e.printStackTrace();
  434. } finally {
  435. if (entrada != null)
  436. try {
  437. entrada.close();
  438. return true;
  439. } catch (IOException e) {
  440. e.printStackTrace();
  441. }
  442. }
  443. return false;
  444. }
  445.  
  446. /**
  447. * Clase para comparar las poblaciones por nombre
  448. *
  449. * @author kikian
  450. *
  451. */
  452. class porNombre implements Comparator<IPoblacion> {
  453. @Override
  454. public int compare(IPoblacion o1, IPoblacion o2) {
  455. return o1.getNombre().compareTo(o2.getNombre());
  456. }
  457.  
  458. }
  459.  
  460. /**
  461. * Obtiene el codigo AEMET asociado a la poblacion
  462. */
  463. public String getCodigoAEMET() {
  464. // TODO Auto-generated method stub
  465. return null;
  466. }
  467.  
  468. }
  469.  

las demas clases son las correspondientes a las ventanas auxiliares y estan correctamente, a ver si alguno me podeis hechar una mano, muchas gracias
5  Programación / Java / Aplicacion en swing para mostrar el tiempo de provincias y poblaciones en: 12 Abril 2015, 16:05 pm
hola, estoy diseñando una aplicacion en swing que se tiene que conectar a la AEMET y descargar los datos de las poblaciones que previamente se le han añadido, el problema que tengo es con los componentes.
En primer lugar este es el codigo:
Código
  1. package principal;
  2. import java.awt.*;
  3. import java.awt.event.*;
  4.  
  5. import javax.swing.Icon;
  6. import javax.swing.ImageIcon;
  7. import javax.swing.JButton;
  8. import javax.swing.JFrame;
  9. import javax.swing.JLabel;
  10. import javax.swing.JMenu;
  11. import javax.swing.JMenuBar;
  12. import javax.swing.JMenuItem;
  13. import javax.swing.JOptionPane;
  14. import javax.swing.JPanel;
  15. import javax.swing.JScrollPane;
  16. import javax.swing.JSplitPane;
  17. import javax.swing.JToolBar;
  18. import javax.swing.JTree;
  19. import javax.swing.SwingConstants;
  20. import javax.swing.WindowConstants;
  21. import javax.swing.tree.DefaultMutableTreeNode;
  22. import javax.swing.tree.DefaultTreeModel;
  23.  
  24. import Poblacion.VentanaBorrarPoblacion;
  25. import Poblacion.VentanaCrearPoblacion;
  26. import paa.provincias.GestorAEMET;
  27. import paa.provincias.GestorAEMETException;
  28. import paa.provincias.IPoblacion;
  29. import paa.provincias.IPoblacionAEMET;
  30. import paa.provincias.IPrediccion;
  31.  
  32.  
  33. /**
  34.  * Fichero: InterfazAWT_AEMET.java Clase que implementa la Interfaz Gráfica
  35.  * AEMET con awt.
  36.  *
  37.  * @author PAA
  38.  * @version 1.0
  39.  */
  40. public class InterfazAWT_AEMET extends JFrame {
  41. /**
  42. *
  43. */
  44. private static final long serialVersionUID = 502635761186556414L;
  45.  
  46. private static final String FICHERO = "almacen.dat";
  47. private AlmacenPoblaciones almacen;
  48.  
  49. // private IAlmacenPoblaciones almacenPoblaciones;
  50. private List listaPoblaciones = new List();
  51. private List listaPredicciones = new List();
  52. private List listaProvincias = new List();
  53. private InterfazAWT_AEMET gui;
  54. private GestorAEMET gestor = new GestorAEMET();
  55. private Aviso aviso;
  56. /**
  57. * Constructor.
  58. *
  59. * @throws GestorAEMETException
  60. */
  61. public InterfazAWT_AEMET(String titulo, int ancho, int alto) {
  62. super(titulo);
  63. setSize(ancho, alto);
  64. setLocationRelativeTo(null);
  65. setLayout(new BorderLayout()); // Layout de la aplicación, podría ser otro
  66. almacen = RecuperarAlmacenPoblaciones();
  67. initComponents();
  68. JFrame.setDefaultLookAndFeelDecorated(true);
  69. }
  70.  
  71. public AlmacenPoblaciones RecuperarAlmacenPoblaciones() {
  72. // Recuperamos el almacén
  73. AlmacenPoblaciones almacenPoblaciones1 = new AlmacenPoblaciones();
  74.  
  75. if (almacenPoblaciones1.recuperar(FICHERO)){
  76. Icon icono= new ImageIcon(getClass().getResource("/iconos/check.png"));
  77. JOptionPane.showMessageDialog(null, "Recuperado el almacen del fichero " + FICHERO, "Recuperado",JOptionPane.INFORMATION_MESSAGE,icono);
  78. }else{
  79. JOptionPane.showMessageDialog(null, "No se ha podido recuperar el almacen del fichero" + FICHERO, "Error",JOptionPane.ERROR_MESSAGE);
  80.  
  81. }return almacenPoblaciones1;
  82.  
  83. }
  84.  
  85. private void initComponents() {
  86.  
  87. // Boton salir por defecto
  88. this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  89.  
  90. setJMenuBar(addJMenuBar());
  91. this.add(addJToolBar(), BorderLayout.NORTH);
  92. this.add(addlineaEstado(), BorderLayout.SOUTH);
  93. this.add(addPanelIzquierda(), BorderLayout.WEST);
  94.  //Create a split pane with the two scroll panes in it.
  95.    JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,addPanelIzquierda(),addpredicciones());
  96.    splitPane.setDividerLocation(150);
  97.    splitPane.setDividerSize(10);
  98.    splitPane.setOneTouchExpandable(true);
  99.  
  100. /*
  101.    // Provide minimum sizes for the two components in the split pane
  102.    Dimension minimumSize = new Dimension(100, 50);
  103.    addPanelIzquierda().setMinimumSize(minimumSize);
  104.    addpredicciones().setMinimumSize(minimumSize);
  105.  
  106.    // Set the initial location and size of the divider
  107.  
  108.  
  109.    // Provide a preferred size for the split pane
  110.    splitPane.setPreferredSize(new Dimension(400, 200));*/
  111. this.add(addpredicciones(), BorderLayout.CENTER);
  112. }
  113.  
  114. private JMenuBar addJMenuBar() {
  115. // Sitúo los menús desplegables
  116. JMenuBar barraDeMenu = new JMenuBar();
  117.  
  118. // Creo el menú Archivo
  119. JMenu menuArchivo = new JMenu("Archivo");
  120. JMenuItem crearGuardar = new JMenuItem("Guardar");
  121. JMenuItem crearCargar = new JMenuItem("Cargar");
  122. JMenuItem salir = new JMenuItem("Salir");
  123. crearCargar.addActionListener(new Controller());
  124. crearGuardar.addActionListener(new Controller());
  125. salir.addActionListener(new Controller());
  126. menuArchivo.add(crearCargar);
  127. menuArchivo.add(crearGuardar);
  128. menuArchivo.add(salir);
  129.  
  130. // Creo el menú Provincias
  131. JMenu menuProvincias = new JMenu("Provincias");
  132. JMenuItem crearProvincias = new JMenuItem("Crear provincia");
  133. JMenuItem borrarProvincias = new JMenuItem("Borrar provincia");
  134. crearProvincias.addActionListener(new Controller());
  135. borrarProvincias.addActionListener(new Controller());
  136. menuProvincias.add(crearProvincias);
  137. menuProvincias.add(borrarProvincias);
  138.  
  139. // Creo el menu Poblaciones
  140. JMenu menuPoblaciones = new JMenu("Poblaciones");
  141. JMenuItem crearPoblacion = new JMenuItem("Crear poblacion");
  142. JMenuItem borrarPoblacion = new JMenuItem("Borrar poblacion");
  143. JMenuItem ordenarNombre = new JMenuItem("Ordenar por nombre");
  144. JMenuItem ordenarHabitantes = new JMenuItem("Ordenar por habitantes");
  145. JMenuItem modPoblacion = new JMenuItem("Modificar poblacion");
  146. JMenuItem movPoblacion = new JMenuItem("Mover poblacion");
  147. crearPoblacion.addActionListener(new Controller());
  148. borrarPoblacion.addActionListener(new Controller());
  149. ordenarNombre.addActionListener(new Controller());
  150. ordenarHabitantes.addActionListener(new Controller());
  151. modPoblacion.addActionListener(new Controller());
  152. movPoblacion.addActionListener(new Controller());
  153. menuPoblaciones.add(crearPoblacion);
  154. menuPoblaciones.add(borrarPoblacion);
  155. menuPoblaciones.add(ordenarNombre);
  156. menuPoblaciones.add(ordenarHabitantes);
  157. menuPoblaciones.add(modPoblacion);
  158. menuPoblaciones.add(movPoblacion);
  159.  
  160. // Creo el menú de ayuda
  161. JMenu ayuda = new JMenu("Ayuda");
  162. JMenuItem acercaDe = new JMenuItem("Acerca de");
  163. acercaDe.addActionListener(new AcercaDe());
  164. ayuda.add(acercaDe);
  165.  
  166. // Crea el
  167. barraDeMenu.add(menuArchivo);
  168. barraDeMenu.add(menuProvincias);
  169. barraDeMenu.add(menuPoblaciones);
  170. barraDeMenu.add(ayuda);
  171. return barraDeMenu;
  172. }
  173.  
  174. private JToolBar addJToolBar() {
  175. // Sitúo la línea de botones
  176. JToolBar lineaDeBotones = new JToolBar();
  177. lineaDeBotones.setBackground(new Color(200,100,100));
  178.  
  179. // Boton crear provincia
  180. Icon Iprovincia= new ImageIcon(getClass().getResource("/iconos/provincia.png"));
  181. JButton proCrear = new JButton("Crear provincia",Iprovincia);
  182. proCrear.addActionListener(new Controller());
  183.  
  184. // Boton crear poblacion
  185. Icon Ipoblacion= new ImageIcon(getClass().getResource("/iconos/poblacion.png"));
  186. JButton poCrear = new JButton("Crear poblacion",Ipoblacion);
  187. poCrear.addActionListener(new Controller());
  188.  
  189. // Boton actualizar prediccion
  190. Icon actualizar= new ImageIcon(getClass().getResource("/iconos/actualizar.png"));
  191.  
  192. JButton aPrediccion = new JButton("Actualizar Predicción",actualizar);
  193. aPrediccion.setToolTipText("Click para actualizar las predicciones");
  194. aPrediccion.addActionListener(new Controller());
  195.  
  196. // Añadir los botones a la barra
  197. lineaDeBotones.add(proCrear);
  198. lineaDeBotones.add(poCrear);
  199. lineaDeBotones.add(aPrediccion);
  200. return lineaDeBotones;
  201. }
  202.  
  203. private JTree addPanelIzquierda() {
  204. // Construccion del arbol
  205.        DefaultMutableTreeNode provinciasPrincipal = new DefaultMutableTreeNode("Provincias");
  206.        DefaultTreeModel modelo = new DefaultTreeModel(provinciasPrincipal);
  207.        JTree tree = new JTree(modelo);
  208.  
  209.        // Construccion de los datos del arbol
  210.  
  211.        for(String s : almacen.getProvincias()){
  212.         int j = 0;
  213.         DefaultMutableTreeNode provincia = new DefaultMutableTreeNode(s);
  214.         modelo.insertNodeInto(provincia, provinciasPrincipal, j);
  215.         j++;
  216.         for(IPoblacion i : almacen.getPoblaciones(s)){
  217.         int x = 0;
  218.         DefaultMutableTreeNode poblacion = new DefaultMutableTreeNode(i.getNombre());
  219.         modelo.insertNodeInto(poblacion, provincia, x);
  220.         x++;
  221.         }
  222.        }
  223. return tree;
  224. }
  225.  
  226. private JPanel addpredicciones() {
  227. // Creamos el panel de las predicciones
  228. JPanel predicciones = new JPanel(new BorderLayout());
  229. JLabel lPrediccion = new JLabel("Predicciones de :");
  230. predicciones.add(lPrediccion, BorderLayout.NORTH);
  231. predicciones.add(listaPredicciones, BorderLayout.CENTER);
  232. return predicciones;
  233. }
  234.  
  235. private JPanel addlineaEstado() {
  236. // Sitúo la línea de estado
  237. JPanel lineaDeEstado = new JPanel();
  238. lineaDeEstado.setLayout(new FlowLayout(FlowLayout.LEFT));
  239. lineaDeEstado.setBackground(new Color(0,80,80));
  240. JLabel ventanaDeeventos = new JLabel("Gestor AEMET v2.0 (PAA)",SwingConstants.CENTER);
  241. ventanaDeeventos.setForeground(new Color(200,200,60));
  242. ventanaDeeventos.setHorizontalAlignment(SwingConstants.CENTER);
  243. ventanaDeeventos.setVerticalAlignment(SwingConstants.CENTER);
  244. lineaDeEstado.add(ventanaDeeventos);
  245. return lineaDeEstado;
  246. }
  247.  
  248. private void guardarAntesDeSalir() {
  249.  
  250. // Guardar almacen
  251. almacen.guardar(FICHERO);
  252. System.out.println("Gracias por utilizar nuestro programa");
  253. }
  254.  
  255. class Controller implements ActionListener {
  256.  
  257. public void actionPerformed(ActionEvent e) {
  258. String nombre = e.getActionCommand();
  259. EvaluarAccion(nombre);
  260.  
  261. }
  262.  
  263. public void EvaluarAccion(String accion) {
  264.  
  265. switch (accion) {
  266. case "Guardar":
  267. almacen.guardar(FICHERO);
  268. JOptionPane.showMessageDialog(null, "El almacen ha sido guardado", "Guardado", DISPOSE_ON_CLOSE);
  269. break;
  270. case "Cargar":
  271. almacen = RecuperarAlmacenPoblaciones();
  272. break;
  273. case "Salir":
  274. System.exit(0);
  275. break;
  276. case "Crear provincia":
  277. String crearProvincia = JOptionPane.showInputDialog(null,"Provincia:","Nueva provincia",JOptionPane.QUESTION_MESSAGE);
  278. if((crearProvincia != null)&&(!crearProvincia.equals(""))){
  279. almacen.addProvincia(crearProvincia);
  280. }else{
  281. JOptionPane.showMessageDialog(null, "Error al crear provincia", "Error", DISPOSE_ON_CLOSE);
  282. }
  283.  
  284. break;
  285. case "Borrar provincia":
  286. String borrarProvincia = JOptionPane.showInputDialog(null,"Provincia:","Eliminar provincia",JOptionPane.QUESTION_MESSAGE);
  287. if((borrarProvincia != null)&&(!borrarProvincia.equals(""))){
  288. almacen.delProvincia(borrarProvincia);
  289. }else{
  290. JOptionPane.showMessageDialog(null, "Error al borrar provincia", "Error", DISPOSE_ON_CLOSE);
  291. }
  292. break;
  293. case "Crear poblacion":
  294. break;
  295. case "Borrar poblacion":
  296. new VentanaBorrarPoblacion(gui,almacen,listaPoblaciones,listaProvincias,listaPredicciones).setVisible(true);
  297. break;
  298. case "Ordenar por nombre":
  299. /*almacen.ordenarPor(listaProvincias.getSelectedItem(), almacen.ORDENARPORNOMBRE);
  300. listaProvincias.removeAll();
  301. Iterator<IPoblacion> i = almacen.getPoblaciones(listaProvincias.getSelectedItem()).iterator();
  302. while(i.hasNext()){
  303. i.next();
  304. listaProvincias.add(i.next().getNombre());
  305. }*/
  306. break;
  307. case "Ordenar por habitantes":
  308. /*almacen.ordenarPor(listaProvincias.getSelectedItem(), almacen.ORDENARPORHABITANTES);
  309. listaProvincias.removeAll();
  310. for(IPoblacion p : almacen.getPoblaciones(listaProvincias.getSelectedItem())){
  311. listaProvincias.add(p.getNombre());
  312. }*/
  313. break;
  314. case "Modificar poblacion":
  315. break;
  316. case "Mover poblacion":
  317. break;
  318. case "Actualizar Predicción":
  319.  
  320. IPoblacion poblacion = almacen.getPoblacion(listaProvincias.getSelectedItem(), listaPoblaciones.getSelectedItem());
  321. try {
  322. listaPredicciones.removeAll();
  323. for(IPrediccion p : gestor.getPredicciones((IPoblacionAEMET) poblacion)){
  324. listaPredicciones.add(p.getFecha() + " : " + p.getEstadoCielo() + " : " +
  325. p.getTemperaturaMaxima() + " : " + p.getTemperaturaMinima());
  326. }
  327. } catch (GestorAEMETException e) {
  328. new Aviso(gui,e.getMessage());
  329. }
  330. break;
  331. case "Acerca de" :
  332. new VentanaAcercaDe(gui);
  333. break;
  334. }
  335. }
  336. }
  337.  
  338. /**
  339. * Clase que implementa la acción del menú "acerca de".
  340. */
  341. class AcercaDe implements ActionListener { // Clase interna
  342. public void actionPerformed(ActionEvent e) {
  343. VentanaAcercaDe ventanaAcercaDe = new VentanaAcercaDe(
  344. InterfazAWT_AEMET.this);
  345. ventanaAcercaDe.setVisible(true);
  346. }
  347. }// Acerca de
  348.  
  349. /**
  350. * Método main.
  351. * @throws GestorAEMETException
  352. */
  353. public static void main(String[] args) throws GestorAEMETException {
  354.  
  355. InterfazAWT_AEMET mimarco = new InterfazAWT_AEMET("Gestor AEMET", 1000,
  356. 500);
  357. mimarco.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
  358. mimarco.setVisible(true);
  359. } // Main
  360. }
  361.  

el cual dibuja esto:




tengo el jsplitpane definido para que actue entre el jtree y el panel predicciones el cual tengo que sustituir por una jtable pero parece que no actua por que no aparece en la aplicacion.

tambien en los dialogos de la clase controller:
Código
  1. String borrarProvincia = JOptionPane.showInputDialog(null,"Provincia:","Eliminar provincia",JOptionPane.QUESTION_MESSAGE);
  2. if((borrarProvincia != null)&&(!borrarProvincia.equals(""))){
  3. almacen.delProvincia(borrarProvincia);
  4. }else{
  5. JOptionPane.showMessageDialog(null, "Error al borrar provincia", "Error", DISPOSE_ON_CLOSE);
  6. }

quiero modificar lo que pone en los botones para que cuando se pulsa el boton añadir provincia en vez de salir los botones aceptar y cancelar, salgan crear y cancelar

tambien necesito que al pulsar en una poblacion del jtree se cargue en la tabla de la derecha los datos de las predicciones si ya hubiera pulsado el boton actualizar prediccion al menos una vez para evitar que al pulsar en cada poblacion conecte con AEMET Y utilize mas ancho de banda


y por ultimo nos han dicho que la utilizacion del springlayout mejora la interfaz pero no me apaño muy bien a la hora de usarlo con los dialogos crear poblacion
6  Programación / Java / Re: Mostrar List al pulsar en un elemento de otra List en AWT en: 28 Marzo 2015, 17:30 pm
me ha salido!!!, mira:
Código
  1. private Panel addPanelIzquierda() {
  2. // Creamos panel para mostrar provincias y poblaciones y lo colocamos a
  3. // la izquierda
  4. Panel izquierda = new Panel(new GridLayout(4, 1));
  5. Label lProvincia = new Label("Provincias:");
  6. Label lPoblacion = new Label("Poblaciones:");
  7. listaPoblaciones.addActionListener(new Controller());
  8. listaProvincias.addItemListener(new ItemListener() {
  9. public void itemStateChanged(ItemEvent event) {
  10. String province = listaProvincias.getSelectedItem();
  11. listaPoblaciones.removeAll();
  12. for(IPoblacion p : almacen.getPoblaciones(province)) {
  13. listaPoblaciones.add(p.getNombre());
  14. }
  15. }
  16. });
  17.  
  18. izquierda.add(lProvincia);
  19. izquierda.add(listaProvincias);
  20. izquierda.add(lPoblacion);
  21. izquierda.add(listaPoblaciones);
  22. return izquierda;
  23. }
en vez de utilizar getItem utilizo getSelectedItem y me funciona correctamente, voy a mirar lo de las predicciones ;)
7  Programación / Java / Re: Mostrar List al pulsar en un elemento de otra List en AWT en: 28 Marzo 2015, 17:26 pm
donde debo de introducir ese metodo?,
lo he puesto a continuacion de la creacion de la list:
Código
  1. private Panel addPanelIzquierda() {
  2. // Creamos panel para mostrar provincias y poblaciones y lo colocamos a
  3. // la izquierda
  4. Panel izquierda = new Panel(new GridLayout(4, 1));
  5. Label lProvincia = new Label("Provincias:");
  6. Label lPoblacion = new Label("Poblaciones:");
  7. listaPoblaciones.addActionListener(new Controller());
  8. listaProvincias.addItemListener(new ItemListener() {
  9. public void itemStateChanged(ItemEvent event) {
  10. String province = (String) event.getItem();
  11. listaPoblaciones.removeAll();
  12. for(SortedSet<IPoblacion> set : almacen.getPoblaciones(province)){
  13. for(IPoblacion p : set) {
  14. listaPoblaciones.add(p.getNombre());
  15. }
  16. }
  17. }
  18. });
  19.  
  20. izquierda.add(lProvincia);
  21. izquierda.add(listaProvincias);
  22. izquierda.add(lPoblacion);
  23. izquierda.add(listaPoblaciones);
  24. return izquierda;
  25. }

pero no funciona por que tu me dices que provincia es un objeto, pero en mi codigo son string y cada string tiene asociado un sortedset de poblaciones por lo que me salta error y no compila, he conseguido hacer que funcione pero con doble click añadiendo en controller esto:
Código
  1. class Controller implements ActionListener {
  2.  
  3. public void actionPerformed(ActionEvent e) {
  4. String nombre = e.getActionCommand();
  5. if(listaProvincias.getSelectedItem()!=null){
  6. listaPoblaciones.removeAll();
  7. for(IPoblacion p : almacen.getPoblaciones(listaProvincias.getSelectedItem())){
  8. listaPoblaciones.add(p.getNombre());
  9. }
  10. }
  11. EvaluarAccion(nombre);
  12.  
  13. }
pero claro con doble click no me vale, tiene que ser con uno solo y no me sale, ya que da error
8  Programación / Java / Mostrar List al pulsar en un elemento de otra List en AWT en: 28 Marzo 2015, 16:11 pm
Hola, necesito crear una aplicacion para informar del tiempo de las provincias que se vayan añadiendo y tengo un problema a la hora de configurar la pantalla del programa:


Lo que debo de hacer es que al pulsar en una provincia automaticamente en la lista de debajo aparezcan las poblaciones creadas en esa provincia y que si hago doble click en una provincia en el panel de la derecha me aparezcan los datos relacionados con las predicciones, mis clases son estas:

La principal
Código
  1. package principal;
  2. import java.awt.*;
  3. import java.awt.event.*;
  4. import Poblacion.VentanaBorrarPoblacion;
  5. import Poblacion.VentanaCrearPoblacion;
  6. import Provincia.VentanaBorrarProvincia;
  7. import Provincia.VentanaCrearProvincia;
  8. import paa.provincias.GestorAEMET;
  9. import paa.provincias.GestorAEMETException;
  10. import paa.provincias.IPoblacion;
  11.  
  12. /**
  13.  * Fichero: InterfazAWT_AEMET.java Clase que implementa la Interfaz Gráfica
  14.  * AEMET con awt.
  15.  *
  16.  * @author PAA
  17.  * @version 1.0
  18.  */
  19. public class InterfazAWT_AEMET extends Frame {
  20. /**
  21. *
  22. */
  23. private static final long serialVersionUID = 502635761186556414L;
  24.  
  25. private static final String FICHERO = "almacen.dat";
  26. private AlmacenPoblaciones almacen;
  27.  
  28. // private IAlmacenPoblaciones almacenPoblaciones;
  29. private List listaPoblaciones = new List();
  30. private List listaPredicciones = new List();
  31. private List listaProvincias = new List();
  32. private InterfazAWT_AEMET gui;
  33. /**
  34. * Constructor.
  35. *
  36. * @throws GestorAEMETException
  37. */
  38. public InterfazAWT_AEMET(String titulo, int ancho, int alto) {
  39. super(titulo);
  40.  
  41. setSize(ancho, alto);
  42. setLocationRelativeTo(null);
  43. setLayout(new BorderLayout()); // Layout de la aplicación, podría ser otro
  44. almacen = RecuperarAlmacenPoblaciones();
  45. System.out.println(almacen.getProvincias());
  46. initComponents();
  47. for(String provincia : almacen.getProvincias()){
  48. listaProvincias.add(provincia);
  49. /*if(listaProvincias.getSelectedItem()==null){
  50. listaPoblaciones.add(almacen.getPoblaciones(listaProvincias.getSelectedItem()));
  51. }
  52. for(IPoblacion s : almacen.getPoblaciones(listaProvincias.getSelectedItem())){
  53.  
  54. }*/
  55. }
  56. //Imprimimos provincias y poblaciones en las listas
  57. }
  58.  
  59. public AlmacenPoblaciones RecuperarAlmacenPoblaciones() {
  60. // Recuperamos el almacén
  61. AlmacenPoblaciones almacenPoblaciones1 = new AlmacenPoblaciones();
  62.  
  63. if (almacenPoblaciones1.recuperar(FICHERO))
  64. System.out.println("Recuperado el almacen del fichero " + FICHERO);
  65. else
  66. System.out.println("No se pudo recuperar el almacen del fichero "+ FICHERO);
  67. return almacenPoblaciones1;
  68.  
  69. }
  70.  
  71. private void initComponents() {
  72.  
  73. // Boton salir por defecto
  74. addWindowListener(new WindowAdapter() {
  75. public void windowClosing(WindowEvent e) {
  76. guardarAntesDeSalir();
  77. System.exit(0);
  78. }
  79. });
  80.  
  81. setMenuBar(addMenuBar());
  82. this.add(addToolBar(), BorderLayout.NORTH);
  83. this.add(addlineaEstado(), BorderLayout.SOUTH);
  84. this.add(addPanelIzquierda(), BorderLayout.WEST);
  85. this.add(addpredicciones(), BorderLayout.CENTER);
  86. }
  87.  
  88. private MenuBar addMenuBar() {
  89. // Sitúo los menús desplegables
  90. MenuBar barraDeMenu = new MenuBar();
  91.  
  92. // Creo el menú Archivo
  93. Menu menuArchivo = new Menu("Archivo");
  94. MenuItem crearGuardar = new MenuItem("Guardar");
  95. MenuItem crearCargar = new MenuItem("Cargar");
  96. MenuItem salir = new MenuItem("Salir");
  97. crearCargar.addActionListener(new Controller());
  98. crearGuardar.addActionListener(new Controller());
  99. salir.addActionListener(new Controller());
  100. menuArchivo.add(crearCargar);
  101. menuArchivo.add(crearGuardar);
  102. menuArchivo.add(salir);
  103.  
  104. // Creo el menú Provincias
  105. Menu menuProvincias = new Menu("Provincias");
  106. MenuItem crearProvincias = new MenuItem("Crear provincia");
  107. MenuItem borrarProvincias = new MenuItem("Borrar provincia");
  108. crearProvincias.addActionListener(new Controller());
  109. borrarProvincias.addActionListener(new Controller());
  110. menuProvincias.add(crearProvincias);
  111. menuProvincias.add(borrarProvincias);
  112.  
  113. // Creo el menu Poblaciones
  114. Menu menuPoblaciones = new Menu("Poblaciones");
  115. MenuItem crearPoblacion = new MenuItem("Crear poblacion");
  116. MenuItem borrarPoblacion = new MenuItem("Borrar poblacion");
  117. MenuItem ordenarNombre = new MenuItem("Ordenar por nombre");
  118. MenuItem ordenarHabitantes = new MenuItem("Ordenar por habitantes");
  119. MenuItem modPoblacion = new MenuItem("Modificar poblacion");
  120. MenuItem movPoblacion = new MenuItem("Mover poblacion");
  121. crearPoblacion.addActionListener(new Controller());
  122. borrarPoblacion.addActionListener(new Controller());
  123. ordenarNombre.addActionListener(new Controller());
  124. ordenarHabitantes.addActionListener(new Controller());
  125. modPoblacion.addActionListener(new Controller());
  126. movPoblacion.addActionListener(new Controller());
  127. menuPoblaciones.add(crearPoblacion);
  128. menuPoblaciones.add(borrarPoblacion);
  129. menuPoblaciones.add(ordenarNombre);
  130. menuPoblaciones.add(ordenarHabitantes);
  131. menuPoblaciones.add(modPoblacion);
  132. menuPoblaciones.add(movPoblacion);
  133.  
  134. // Creo el menú de ayuda
  135. Menu ayuda = new Menu("Ayuda");
  136. MenuItem acercaDe = new MenuItem("Acerca de");
  137. acercaDe.addActionListener(new AcercaDe());
  138. ayuda.add(acercaDe);
  139.  
  140. // Crea el
  141. barraDeMenu.add(menuArchivo);
  142. barraDeMenu.add(menuProvincias);
  143. barraDeMenu.add(menuPoblaciones);
  144. // Sitúo el menú de ayuda en su sitio
  145. barraDeMenu.setHelpMenu(ayuda);
  146. return barraDeMenu;
  147. }
  148.  
  149. private Panel addToolBar() {
  150. // Sitúo la línea de botones
  151. Panel lineaDeBotones = new Panel(new FlowLayout(FlowLayout.LEFT));
  152. lineaDeBotones.setBackground(Color.lightGray);
  153.  
  154. // Boton crear provincia
  155. Button proCrear = new Button("Crear provincia");
  156. proCrear.addActionListener(new Controller());
  157.  
  158. // Boton crear poblacion
  159. Button poCrear = new Button("Crear poblacion");
  160. poCrear.addActionListener(new Controller());
  161.  
  162. // Boton actualizar prediccion
  163. Button aPrediccion = new Button("Actualizar Predicción");
  164. aPrediccion.addActionListener(new Controller());
  165.  
  166. // Añadir los botones a la barra
  167. lineaDeBotones.add(proCrear);
  168. lineaDeBotones.add(poCrear);
  169. lineaDeBotones.add(aPrediccion);
  170. return lineaDeBotones;
  171. }
  172.  
  173. private Panel addPanelIzquierda() {
  174. // Creamos panel para mostrar provincias y poblaciones y lo colocamos a
  175. // la izquierda
  176. Panel izquierda = new Panel(new GridLayout(4, 1));
  177. Label lProvincia = new Label("Provincias:");
  178. Label lPoblacion = new Label("Poblaciones:");
  179. izquierda.add(lProvincia);
  180. izquierda.add(listaProvincias);
  181. izquierda.add(lPoblacion);
  182. izquierda.add(listaPoblaciones);
  183. return izquierda;
  184. }
  185.  
  186. private Panel addpredicciones() {
  187. // Creamos el panel de las predicciones
  188. Panel predicciones = new Panel(new BorderLayout());
  189. Label lPrediccion = new Label("Predicciones de :");
  190. List tPrediccion = new List();
  191. predicciones.add(lPrediccion, BorderLayout.NORTH);
  192. predicciones.add(tPrediccion, BorderLayout.CENTER);
  193. return predicciones;
  194. }
  195.  
  196. private Panel addlineaEstado() {
  197. // Sitúo la línea de estado
  198. Panel lineaDeEstado = new Panel();
  199. lineaDeEstado.setLayout(new FlowLayout(FlowLayout.LEFT));
  200. lineaDeEstado.setBackground(Color.lightGray);
  201. Label ventanaDeeventos = new Label("Gestor AEMET v1.0 (PAA)");
  202. lineaDeEstado.add(ventanaDeeventos);
  203. return lineaDeEstado;
  204. }
  205.  
  206. private void guardarAntesDeSalir() {
  207.  
  208. // Guardar almacen
  209. almacen.guardar(FICHERO);
  210. System.out.println("Gracias por utilizar nuestro programa");
  211. }
  212.  
  213. class Controller implements ActionListener {
  214.  
  215. public void actionPerformed(ActionEvent e) {
  216. String nombre = e.getActionCommand();
  217. EvaluarAccion(nombre);
  218. }
  219.  
  220. public void EvaluarAccion(String accion) {
  221.  
  222. switch (accion) {
  223. case "Guardar":
  224. almacen.guardar(FICHERO);
  225. Aviso guardar = new Aviso(gui, "Archivo guardado");
  226. break;
  227. case "Salir":
  228. System.exit(0);
  229. break;
  230. case "Crear provincia":
  231. new VentanaCrearProvincia(gui,almacen,listaPoblaciones,listaProvincias,listaPredicciones).setVisible(true);
  232. break;
  233. case "Borrar provincia":
  234. new VentanaBorrarProvincia(gui,almacen,listaPoblaciones,listaProvincias,listaPredicciones).setVisible(true);
  235. break;
  236. case "Crear poblacion":
  237. new VentanaCrearPoblacion(gui,almacen,listaPoblaciones,listaProvincias,listaPredicciones).setVisible(true);
  238. break;
  239. case "Borrar poblacion":
  240. new VentanaBorrarPoblacion(gui,almacen,listaPoblaciones,listaProvincias,listaPredicciones).setVisible(true);
  241. break;
  242. case "Ordenar por nombre":
  243. break;
  244. case "Ordenar por habitantes":
  245. break;
  246. case "Modificar poblacion":
  247. break;
  248. case "Mover poblacion":
  249. break;
  250. }
  251. }
  252. }
  253.  
  254. /**
  255. * Clase que implementa la acción del menú "acerca de".
  256. */
  257. class AcercaDe implements ActionListener { // Clase interna
  258. public void actionPerformed(ActionEvent e) {
  259. VentanaAcercaDe ventanaAcercaDe = new VentanaAcercaDe(
  260. InterfazAWT_AEMET.this);
  261. ventanaAcercaDe.setVisible(true);
  262. }
  263. }// Acerca de
  264.  
  265. /**
  266. * Método main.
  267. * @throws GestorAEMETException
  268. */
  269. public static void main(String[] args) throws GestorAEMETException {
  270.  
  271. InterfazAWT_AEMET mimarco = new InterfazAWT_AEMET("Gestor AEMET", 1000,
  272. 500);
  273. mimarco.setVisible(true);
  274. } // Main
  275. }
  276.  

La que crea provincia:
Código
  1. package Provincia;
  2. import java.awt.Button;
  3. import java.awt.Dialog;
  4. import java.awt.Frame;
  5. import java.awt.GridLayout;
  6. import java.awt.Label;
  7. import java.awt.List;
  8. import java.awt.Panel;
  9. import java.awt.TextField;
  10. import java.awt.event.ActionEvent;
  11. import java.awt.event.ActionListener;
  12. import java.awt.event.WindowAdapter;
  13. import java.awt.event.WindowEvent;
  14.  
  15. import principal.AlmacenPoblaciones;
  16. import principal.Aviso;
  17.  
  18.  
  19. public class VentanaCrearProvincia extends Dialog {
  20.  
  21. private Button crear;
  22. private Button cancelar;
  23. private AlmacenPoblaciones almacen;
  24. private List listaPoblaciones;
  25. private List listaPredicciones;
  26. private List listaProvincias;
  27. private TextField textField;
  28. private static final long serialVersionUID = -2530069431684593677L;
  29.  
  30. public VentanaCrearProvincia(Frame gui, AlmacenPoblaciones almacen, List listaPoblaciones, List listaProvincias, List listaPredicciones) {
  31. super(gui);
  32.  
  33. this.almacen = almacen;
  34. this.listaPoblaciones = listaPoblaciones;
  35. this.listaProvincias = listaProvincias;
  36. this.listaPredicciones = listaPredicciones;
  37. initComponents(gui);
  38. }
  39.  
  40. public void initComponents (Frame gui){
  41. Panel panel = new Panel(new GridLayout(2,2,0,0));
  42. Label label = new Label("Provincia:");
  43. textField = new TextField();
  44. crear = new Button("Crear");
  45. cancelar = new Button("Cancelar");
  46. setLocationRelativeTo(gui);
  47. this.setTitle("Crear Provincia");
  48. this.setSize(300, 100);
  49. panel.add(label);
  50. panel.add(textField);
  51. panel.add(crear);
  52. panel.add(cancelar);
  53. crear.addActionListener(new Controller());
  54. cancelar.addActionListener(new Controller());
  55. this.add(panel);
  56. addWindowListener (new WindowAdapter (){
  57.          public void windowClosing(WindowEvent e) {
  58.          VentanaCrearProvincia.this.dispose();
  59.             }
  60.          });
  61. }
  62. public class Controller implements ActionListener {
  63. public void actionPerformed(ActionEvent e) {
  64. String label = e.getActionCommand();
  65. if(label.equals("Crear")){
  66. try{
  67. almacen.addProvincia(textField.getText());
  68. listaProvincias.removeAll();
  69. for(String provincia : almacen.getProvincias()){
  70. listaProvincias.add(provincia);
  71. }
  72. System.out.println(almacen.getProvincias());
  73. VentanaCrearProvincia.this.dispose();
  74.  
  75. Aviso aviso = new Aviso(VentanaCrearProvincia.this,e1.getMessage());
  76. }
  77. }else{
  78.  
  79. VentanaCrearProvincia.this.dispose();
  80. }
  81. }
  82.  
  83. }
  84. }
  85.  
y la que crea poblacion

Código
  1. package Poblacion;
  2. import java.awt.BorderLayout;
  3. import java.awt.Button;
  4. import java.awt.Dialog;
  5. import java.awt.FlowLayout;
  6. import java.awt.Frame;
  7. import java.awt.GridLayout;
  8. import java.awt.Label;
  9. import java.awt.List;
  10. import java.awt.Panel;
  11. import java.awt.TextField;
  12. import java.awt.event.ActionEvent;
  13. import java.awt.event.ActionListener;
  14. import java.awt.event.ItemEvent;
  15. import java.awt.event.WindowAdapter;
  16. import java.awt.event.WindowEvent;
  17.  
  18. import paa.provincias.IPoblacion;
  19. import principal.AlmacenPoblaciones;
  20. import principal.Aviso;
  21. import principal.Poblacion;
  22.  
  23. public class VentanaCrearPoblacion extends Dialog {
  24.  
  25. private Button crear;
  26. private Button cancelar;
  27. private AlmacenPoblaciones almacen;
  28. private List listaPoblaciones;
  29. private List listaPredicciones;
  30. private List listaProvincias;
  31. private TextField nombre;
  32. private TextField habitantes;
  33. private TextField codigo;
  34. private static final long serialVersionUID = 1434307119439314094L;
  35.  
  36. public VentanaCrearPoblacion(Frame gui, AlmacenPoblaciones almacen, List listaPoblaciones, List listaProvincias, List listaPredicciones) {
  37. super(gui);
  38. this.almacen = almacen;
  39. this.listaPoblaciones = listaPoblaciones;
  40. this.listaProvincias = listaProvincias;
  41. this.listaPredicciones = listaPredicciones;
  42. if(listaProvincias.getSelectedItem() != null){
  43. initComponents(gui);
  44. }else{
  45. Aviso aviso = new Aviso(gui,"Selecciona una provincia");
  46. gui.dispose();
  47. }
  48.  
  49. }
  50. public void initComponents(Frame gui){
  51. setLocationRelativeTo(gui);
  52. this.setLayout(new BorderLayout());
  53. this.setTitle("Crear Poblacion");
  54. this.setSize(300, 200);
  55. Panel texto = new Panel(new GridLayout(4,1,0,0));
  56. Panel panel = new Panel(new FlowLayout());
  57. crear = new Button("Crear");
  58. cancelar = new Button("Cancelar");
  59. nombre = new TextField("Nombre");
  60. Label nombreP = new Label(listaProvincias.getSelectedItem());
  61. habitantes = new TextField("Habitantes");
  62. codigo = new TextField("CodigoAEMET");
  63. crear.addActionListener(new Controller());
  64. cancelar.addActionListener(new Controller());